apps/replaygain.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 Magnus Holmgren
  11  *
  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.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <ctype.h>
  23 #include <inttypes.h>
  24 #include <math.h>
  25 #include <stdbool.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <system.h>
  30 #include "metadata.h"
  31 #include "debug.h"
  32 #include "replaygain.h"
  33 #include "fixedpoint.h"
  34
  35 #define FP_BITS         (12)
  36 #define FP_ONE          (1 << FP_BITS)
  37
  38
  39 static long fp_atof(const char* s, int precision)
  40 {
  41     long int_part = 0;
  42     long int_one = BIT_N(precision);
  43     long frac_part = 0;
  44     long frac_count = 0;
  45     long frac_max = ((precision * 4) + 12) / 13;
  46     long frac_max_int = 1;
  47     long sign = 1;
  48     bool point = false;
  49
  50     while ((*s != '\0') && isspace(*s))
  51     {
  52         s++;
  53     }
  54
  55     if (*s == '-')
  56     {
  57         sign = -1;
  58         s++;
  59     }
  60     else if (*s == '+')
  61     {
  62         s++;
  63     }
  64
  65     while (*s != '\0')
  66     {
  67         if (*s == '.')
  68         {
  69             if (point)
  70             {
  71                 break;
  72             }
  73
  74             point = true;
  75         }
  76         else if (isdigit(*s))
  77         {
  78             if (point)
  79             {
  80                 if (frac_count < frac_max)
  81                 {
  82                     frac_part = frac_part * 10 + (*s - '0');
  83                     frac_count++;
  84                     frac_max_int *= 10;
  85                 }
  86             }
  87             else
  88             {
  89                 int_part = int_part * 10 + (*s - '0');
  90             }
  91         }
  92         else
  93         {
  94             break;
  95         }
  96
  97         s++;
  98     }
  99
 100     while (frac_count < frac_max)
 101     {
 102       frac_part *= 10;
 103       frac_count++;
 104       frac_max_int *= 10;
 105     }
 106
 107     return sign * ((int_part * int_one)
 108         + (((int64_t) frac_part * int_one) / frac_max_int));
 109 }
 110
 111 static long convert_gain(long gain)
 112 {
 113     /* Don't allow unreasonably low or high gain changes.
 114      * Our math code can't handle it properly anyway. :)
 115      */
 116     if (gain < (-48 * FP_ONE))
 117     {
 118         gain = -48 * FP_ONE;
 119     }
 120
 121     if (gain > (17 * FP_ONE))
 122     {
 123         gain = 17 * FP_ONE;
 124     }
 125
 126     gain = fp_factor(gain, FP_BITS) << (24 - FP_BITS);
 127
 128     return gain;
 129 }
 130
 131 /* Get the sample scale factor in Q7.24 format from a gain value. Returns 0
 132  * for no gain.
 133  *
 134  * str  Gain in dB as a string. E.g., "-3.45 dB"; the "dB" part is ignored.
 135  */
 136 static long get_replaygain(const char* str)
 137 {
 138     long gain = 0;
 139
 140     if (str)
 141     {
 142         gain = fp_atof(str, FP_BITS);
 143         gain = convert_gain(gain);
 144     }
 145
 146     return gain;
 147 }
 148
 149 /* Get the peak volume in Q7.24 format.
 150  *
 151  * str  Peak volume. Full scale is specified as "1.0". Returns 0 for no peak.
 152  */
 153 static long get_replaypeak(const char* str)
 154 {
 155     long peak = 0;
 156
 157     if (str)
 158     {
 159         peak = fp_atof(str, 24);
 160     }
 161
 162     return peak;
 163 }
 164
 165 /* Get a sample scale factor in Q7.24 format from a gain value.
 166  *
 167  * int_gain  Gain in dB, multiplied by 100.
 168  */
 169 long get_replaygain_int(long int_gain)
 170 {
 171     return convert_gain(int_gain * FP_ONE / 100);
 172 }
 173
 174 /* Parse a ReplayGain tag conforming to the "VorbisGain standard". If a
 175  * valid tag is found, update mp3entry struct accordingly. Existing values
 176  * are not overwritten. Returns number of bytes written to buffer.
 177  *
 178  * key     Name of the tag.
 179  * value   Value of the tag.
 180  * entry   mp3entry struct to update.
 181  * buffer  Where to store the text for gain values (for later display).
 182  * length  Bytes left in buffer.
 183  */
 184 long parse_replaygain(const char* key, const char* value,
 185     struct mp3entry* entry, char* buffer, int length)
 186 {
 187     char **p = NULL;
 188
 189     if (((strcasecmp(key, "replaygain_track_gain") == 0)
 190         || (strcasecmp(key, "rg_radio") == 0)) && !entry->track_gain)
 191     {
 192         entry->track_gain = get_replaygain(value);
 193         p = &(entry->track_gain_string);
 194     }
 195     else if (((strcasecmp(key, "replaygain_album_gain") == 0)
 196         || (strcasecmp(key, "rg_audiophile") == 0)) && !entry->album_gain)
 197     {
 198         entry->album_gain = get_replaygain(value);
 199         p = &(entry->album_gain_string);
 200     }
 201     else if (((strcasecmp(key, "replaygain_track_peak") == 0)
 202         || (strcasecmp(key, "rg_peak") == 0)) && !entry->track_peak)
 203     {
 204         entry->track_peak = get_replaypeak(value);
 205     }
 206     else if ((strcasecmp(key, "replaygain_album_peak") == 0)
 207         && !entry->album_peak)
 208     {
 209         entry->album_peak = get_replaypeak(value);
 210     }
 211
 212     if (p)
 213     {
 214         int len = strlen(value);
 215
 216         len = MIN(len, length - 1);
 217
 218         /* A few characters just isn't interesting... */
 219         if (len > 1)
 220         {
 221             strlcpy(buffer, value, len + 1);
 222             *p = buffer;
 223             return len + 1;
 224         }
 225     }
 226
 227     return 0;
 228 }
 229
 230 /* Set ReplayGain values from integers. Existing values are not overwritten.
 231  * Returns number of bytes written to buffer.
 232  *
 233  * album   If true, set album values, otherwise set track values.
 234  * gain    Gain value in dB, multiplied by 512. 0 for no gain.
 235  * peak    Peak volume in Q7.24 format, where 1.0 is full scale. 0 for no
 236  *         peak volume.
 237  * buffer  Where to store the text for gain values (for later display).
 238  * length  Bytes left in buffer.
 239  */
 240 long parse_replaygain_int(bool album, long gain, long peak,
 241     struct mp3entry* entry, char* buffer, int length)
 242 {
 243     long len = 0;
 244
 245     if (buffer != NULL)
 246     {
 247         len = snprintf(buffer, length, "%d.%02d dB", gain / 512,
 248             ((abs(gain) & 0x01ff) * 100 + 256) / 512);
 249         len++;
 250     }
 251
 252     if (gain != 0)
 253     {
 254         gain = convert_gain(gain * FP_ONE / 512);
 255     }
 256
 257     if (album)
 258     {
 259         entry->album_gain = gain;
 260         entry->album_gain_string = buffer;
 261
 262         if (peak)
 263         {
 264             entry->album_peak = peak;
 265         }
 266     }
 267     else
 268     {
 269         entry->track_gain = gain;
 270         entry->track_gain_string = buffer;
 271
 272         if (peak)
 273         {
 274             entry->track_peak = peak;
 275         }
 276     }
 277
 278     return len;
 279 }