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