| 1 |
/* |
| 2 |
* ReplayGainAnalysis - analyzes input samples and give the recommended dB change |
| 3 |
* Copyright (C) 2001 David Robinson and Glen Sawyer |
| 4 |
* Improvements and optimizations added by Frank Klemm, and by Marcel Muller |
| 5 |
* |
| 6 |
* This library is free software; you can redistribute it and/or |
| 7 |
* modify it under the terms of the GNU Lesser General Public |
| 8 |
* License as published by the Free Software Foundation; either |
| 9 |
* version 2.1 of the License, or (at your option) any later version. |
| 10 |
* |
| 11 |
* This library is distributed in the hope that it will be useful, |
| 12 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
| 13 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| 14 |
* Lesser General Public License for more details. |
| 15 |
* |
| 16 |
* You should have received a copy of the GNU Lesser General Public |
| 17 |
* License along with this library; if not, write to the Free Software |
| 18 |
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| 19 |
* |
| 20 |
* concept and filter values by David Robinson ([email protected]) |
| 21 |
* -- blame him if you think the idea is flawed |
| 22 |
* original coding by Glen Sawyer ([email protected]) |
| 23 |
* -- blame him if you think this runs too slowly, or the coding is otherwise flawed |
| 24 |
* |
| 25 |
* lots of code improvements by Frank Klemm ( http://www.uni-jena.de/~pfk/mpp/ ) |
| 26 |
* -- credit him for all the _good_ programming ;) |
| 27 |
* |
| 28 |
* |
| 29 |
* For an explanation of the concepts and the basic algorithms involved, go to: |
| 30 |
* http://www.replaygain.org/ |
| 31 |
*/ |
| 32 |
|
| 33 |
/* |
| 34 |
* Here's the deal. Call |
| 35 |
* |
| 36 |
* InitGainAnalysis ( long samplefreq ); |
| 37 |
* |
| 38 |
* to initialize everything. Call |
| 39 |
* |
| 40 |
* AnalyzeSamples ( const Float_t* left_samples, |
| 41 |
* const Float_t* right_samples, |
| 42 |
* size_t num_samples, |
| 43 |
* int num_channels ); |
| 44 |
* |
| 45 |
* as many times as you want, with as many or as few samples as you want. |
| 46 |
* If mono, pass the sample buffer in through left_samples, leave |
| 47 |
* right_samples NULL, and make sure num_channels = 1. |
| 48 |
* |
| 49 |
* GetTitleGain() |
| 50 |
* |
| 51 |
* will return the recommended dB level change for all samples analyzed |
| 52 |
* SINCE THE LAST TIME you called GetTitleGain() OR InitGainAnalysis(). |
| 53 |
* |
| 54 |
* GetAlbumGain() |
| 55 |
* |
| 56 |
* will return the recommended dB level change for all samples analyzed |
| 57 |
* since InitGainAnalysis() was called and finalized with GetTitleGain(). |
| 58 |
* |
| 59 |
* Pseudo-code to process an album: |
| 60 |
* |
| 61 |
* Float_t l_samples [4096]; |
| 62 |
* Float_t r_samples [4096]; |
| 63 |
* size_t num_samples; |
| 64 |
* unsigned int num_songs; |
| 65 |
* unsigned int i; |
| 66 |
* |
| 67 |
* InitGainAnalysis ( 44100 ); |
| 68 |
* for ( i = 1; i <= num_songs; i++ ) { |
| 69 |
* while ( ( num_samples = getSongSamples ( song[i], left_samples, right_samples ) ) > 0 ) |
| 70 |
* AnalyzeSamples ( left_samples, right_samples, num_samples, 2 ); |
| 71 |
* fprintf ("Recommended dB change for song %2d: %+6.2f dB\n", i, GetTitleGain() ); |
| 72 |
* } |
| 73 |
* fprintf ("Recommended dB change for whole album: %+6.2f dB\n", GetAlbumGain() ); |
| 74 |
*/ |
| 75 |
|
| 76 |
/* |
| 77 |
* So here's the main source of potential code confusion: |
| 78 |
* |
| 79 |
* The filters applied to the incoming samples are IIR filters, |
| 80 |
* meaning they rely on up to <filter order> number of previous samples |
| 81 |
* AND up to <filter order> number of previous filtered samples. |
| 82 |
* |
| 83 |
* I set up the AnalyzeSamples routine to minimize memory usage and interface |
| 84 |
* complexity. The speed isn't compromised too much (I don't think), but the |
| 85 |
* internal complexity is higher than it should be for such a relatively |
| 86 |
* simple routine. |
| 87 |
* |
| 88 |
* Optimization/clarity suggestions are welcome. |
| 89 |
*/ |
| 90 |
|
| 91 |
#ifdef HAVE_CONFIG_H |
| 92 |
#include <config.h> |
| 93 |
#endif |
| 94 |
|
| 95 |
#include <stdio.h> |
| 96 |
#include <stdlib.h> |
| 97 |
#include <string.h> |
| 98 |
|
| 99 |
#include "lame.h" |
| 100 |
#include "machine.h" |
| 101 |
#include "gain_analysis.h" |
| 102 |
|
| 103 |
/* for each filter: */ |
| 104 |
/* [0] 48 kHz, [1] 44.1 kHz, [2] 32 kHz, [3] 24 kHz, [4] 22050 Hz, [5] 16 kHz, [6] 12 kHz, [7] is 11025 Hz, [8] 8 kHz */ |
| 105 |
|
| 106 |
#ifdef WIN32 |
| 107 |
#pragma warning ( disable : 4305 ) |
| 108 |
#endif |
| 109 |
|
| 110 |
|
| 111 |
/*lint -save -e736 loss of precision */ |
| 112 |
static const Float_t ABYule[9][multiple_of(4, 2 * YULE_ORDER + 1)] = { |
| 113 |
/* 20 18 16 14 12 10 8 6 4 2 0 19 17 15 13 11 9 7 5 3 1 */ |
| 114 |
{ 0.00288463683916, 0.00012025322027, 0.00306428023191, 0.00594298065125, -0.02074045215285, 0.02161526843274, -0.01655260341619, -0.00009291677959, -0.00123395316851, -0.02160367184185, 0.03857599435200, 0.13919314567432, -0.86984376593551, 2.75465861874613, -5.87257861775999, 9.48293806319790,-12.28759895145294, 13.05504219327545,-11.34170355132042, 7.81501653005538, -3.84664617118067}, |
| 115 |
{-0.00187763777362, 0.00674613682247, -0.00240879051584, 0.01624864962975, -0.02596338512915, 0.02245293253339, -0.00834990904936, -0.00851165645469, -0.00848709379851, -0.02911007808948, 0.05418656406430, 0.13149317958808, -0.75104302451432, 2.19611684890774, -4.39470996079559, 6.85401540936998, -8.81498681370155, 9.47693607801280, -8.54751527471874, 6.36317777566148, -3.47845948550071}, |
| 116 |
{-0.00881362733839, 0.00651420667831, -0.01390589421898, 0.03174092540049, 0.00222312597743, 0.04781476674921, -0.05588393329856, 0.02163541888798, -0.06247880153653, -0.09331049056315, 0.15457299681924, 0.02347897407020, -0.05032077717131, 0.16378164858596, -0.45953458054983, 1.00595954808547, -1.67148153367602, 2.23697657451713, -2.64577170229825, 2.84868151156327, -2.37898834973084}, |
| 117 |
{-0.02950134983287, 0.00205861885564, -0.00000828086748, 0.06276101321749, -0.00584456039913, -0.02364141202522, -0.00915702933434, 0.03282930172664, -0.08587323730772, -0.22613988682123, 0.30296907319327, 0.00302439095741, 0.02005851806501, 0.04500235387352, -0.22138138954925, 0.39120800788284, -0.22638893773906, -0.16276719120440, -0.25656257754070, 1.07977492259970, -1.61273165137247}, |
| 118 |
{-0.01760176568150, -0.01635381384540, 0.00832043980773, 0.05724228140351, -0.00589500224440, -0.00469977914380, -0.07834489609479, 0.11921148675203, -0.11828570177555, -0.25572241425570, 0.33642304856132, 0.02977207319925, -0.04237348025746, 0.08333755284107, -0.04067510197014, -0.12453458140019, 0.47854794562326, -0.80774944671438, 0.12205022308084, 0.87350271418188, -1.49858979367799}, |
| 119 |
{ 0.00541907748707, -0.03193428438915, -0.01863887810927, 0.10478503600251, 0.04097565135648, -0.12398163381748, 0.04078262797139, -0.01419140100551, -0.22784394429749, -0.14351757464547, 0.44915256608450, 0.03222754072173, 0.05784820375801, 0.06747620744683, 0.00613424350682, 0.22199650564824, -0.42029820170918, 0.00213767857124, -0.37256372942400, 0.29661783706366, -0.62820619233671}, |
| 120 |
{-0.00588215443421, -0.03788984554840, 0.08647503780351, 0.00647310677246, -0.27562961986224, 0.30931782841830, -0.18901604199609, 0.16744243493672, 0.16242137742230, -0.75464456939302, 0.56619470757641, 0.01807364323573, 0.01639907836189, -0.04784254229033, 0.06739368333110, -0.33032403314006, 0.45054734505008, 0.00819999645858, -0.26806001042947, 0.29156311971249, -1.04800335126349}, |
| 121 |
{-0.00749618797172, -0.03721611395801, 0.06920467763959, 0.01628462406333, -0.25344790059353, 0.15558449135573, 0.02377945217615, 0.17520704835522, -0.14289799034253, -0.53174909058578, 0.58100494960553, 0.01818801111503, 0.02442357316099, -0.02505961724053, -0.05246019024463, -0.23313271880868, 0.38952639978999, 0.14728154134330, -0.20256413484477, -0.31863563325245, -0.51035327095184}, |
| 122 |
{-0.02217936801134, 0.04788665548180, -0.04060034127000, -0.11202315195388, -0.02459864859345, 0.14590772289388, -0.10214864179676, 0.04267842219415, -0.00275953611929, -0.42163034350696, 0.53648789255105, 0.04704409688120, 0.05477720428674, -0.18823009262115, -0.17556493366449, 0.15113130533216, 0.26408300200955, -0.04678328784242, -0.03424681017675, -0.43193942311114, -0.25049871956020} |
| 123 |
}; |
| 124 |
|
| 125 |
static const Float_t ABButter[9][multiple_of(4, 2 * BUTTER_ORDER + 1)] = { |
| 126 |
/* 5 4 3 2 1 */ |
| 127 |
{0.98621192462708, 0.97261396931306, -1.97242384925416, -1.97223372919527, 0.98621192462708}, |
| 128 |
{0.98500175787242, 0.97022847566350, -1.97000351574484, -1.96977855582618, 0.98500175787242}, |
| 129 |
{0.97938932735214, 0.95920349965459, -1.95877865470428, -1.95835380975398, 0.97938932735214}, |
| 130 |
{0.97531843204928, 0.95124613669835, -1.95063686409857, -1.95002759149878, 0.97531843204928}, |
| 131 |
{0.97316523498161, 0.94705070426118, -1.94633046996323, -1.94561023566527, 0.97316523498161}, |
| 132 |
{0.96454515552826, 0.93034775234268, -1.92909031105652, -1.92783286977036, 0.96454515552826}, |
| 133 |
{0.96009142950541, 0.92177618768381, -1.92018285901082, -1.91858953033784, 0.96009142950541}, |
| 134 |
{0.95856916599601, 0.91885558323625, -1.91713833199203, -1.91542108074780, 0.95856916599601}, |
| 135 |
{0.94597685600279, 0.89487434461664, -1.89195371200558, -1.88903307939452, 0.94597685600279} |
| 136 |
}; |
| 137 |
|
| 138 |
/*lint -restore */ |
| 139 |
|
| 140 |
#ifdef WIN32 |
| 141 |
#pragma warning ( default : 4305 ) |
| 142 |
#endif |
| 143 |
|
| 144 |
/* When calling this procedure, make sure that ip[-order] and op[-order] point to real data! */ |
| 145 |
|
| 146 |
static void |
| 147 |
filterYule(const Float_t * input, Float_t * output, size_t nSamples, const Float_t * const kernel) |
| 148 |
{ |
| 149 |
while (nSamples--) { |
| 150 |
Float_t y0 = input[-10] * kernel[ 0]; |
| 151 |
Float_t y2 = input[ -9] * kernel[ 1]; |
| 152 |
Float_t y4 = input[ -8] * kernel[ 2]; |
| 153 |
Float_t y6 = input[ -7] * kernel[ 3]; |
| 154 |
Float_t s00 = y0 + y2 + y4 + y6; |
| 155 |
Float_t y8 = input[ -6] * kernel[ 4]; |
| 156 |
Float_t yA = input[ -5] * kernel[ 5]; |
| 157 |
Float_t yC = input[ -4] * kernel[ 6]; |
| 158 |
Float_t yE = input[ -3] * kernel[ 7]; |
| 159 |
Float_t s01 = y8 + yA + yC + yE; |
| 160 |
Float_t yG = input[ -2] * kernel[ 8] + input[ -1] * kernel[ 9]; |
| 161 |
Float_t yK = input[ 0] * kernel[10]; |
| 162 |
|
| 163 |
Float_t s1 = s00 + s01 + yG + yK; |
| 164 |
|
| 165 |
Float_t x1 = output[-10] * kernel[11] + output[ -9] * kernel[12]; |
| 166 |
Float_t x5 = output[ -8] * kernel[13] + output[ -7] * kernel[14]; |
| 167 |
Float_t x9 = output[ -6] * kernel[15] + output[ -5] * kernel[16]; |
| 168 |
Float_t xD = output[ -4] * kernel[17] + output[ -3] * kernel[18]; |
| 169 |
Float_t xH = output[ -2] * kernel[19] + output[ -1] * kernel[20]; |
| 170 |
|
| 171 |
Float_t s2 = x1 + x5 + x9 + xD + xH; |
| 172 |
|
| 173 |
output[0] = (Float_t)(s1 - s2); |
| 174 |
|
| 175 |
++output; |
| 176 |
++input; |
| 177 |
} |
| 178 |
} |
| 179 |
|
| 180 |
static void |
| 181 |
filterButter(const Float_t * input, Float_t * output, size_t nSamples, const Float_t * const kernel) |
| 182 |
{ |
| 183 |
while (nSamples--) { |
| 184 |
Float_t s1 = input[-2] * kernel[0] + input[-1] * kernel[2] + input[ 0] * kernel[4]; |
| 185 |
Float_t s2 = output[-2] * kernel[1] + output[-1] * kernel[3]; |
| 186 |
output[0] = (Float_t)(s1 - s2); |
| 187 |
++output; |
| 188 |
++input; |
| 189 |
} |
| 190 |
} |
| 191 |
|
| 192 |
|
| 193 |
|
| 194 |
static int ResetSampleFrequency(replaygain_t * rgData, long samplefreq); |
| 195 |
|
| 196 |
/* returns a INIT_GAIN_ANALYSIS_OK if successful, INIT_GAIN_ANALYSIS_ERROR if not */ |
| 197 |
|
| 198 |
int |
| 199 |
ResetSampleFrequency(replaygain_t * rgData, long samplefreq) |
| 200 |
{ |
| 201 |
/* zero out initial values, only first MAX_ORDER values */ |
| 202 |
memset(rgData->linprebuf, 0, MAX_ORDER * sizeof(*rgData->linprebuf)); |
| 203 |
memset(rgData->rinprebuf, 0, MAX_ORDER * sizeof(*rgData->rinprebuf)); |
| 204 |
memset(rgData->lstepbuf, 0, MAX_ORDER * sizeof(*rgData->lstepbuf)); |
| 205 |
memset(rgData->rstepbuf, 0, MAX_ORDER * sizeof(*rgData->rstepbuf)); |
| 206 |
memset(rgData->loutbuf, 0, MAX_ORDER * sizeof(*rgData->loutbuf)); |
| 207 |
memset(rgData->routbuf, 0, MAX_ORDER * sizeof(*rgData->routbuf)); |
| 208 |
|
| 209 |
switch ((int) (samplefreq)) { |
| 210 |
case 48000: |
| 211 |
rgData->freqindex = 0; |
| 212 |
break; |
| 213 |
case 44100: |
| 214 |
rgData->freqindex = 1; |
| 215 |
break; |
| 216 |
case 32000: |
| 217 |
rgData->freqindex = 2; |
| 218 |
break; |
| 219 |
case 24000: |
| 220 |
rgData->freqindex = 3; |
| 221 |
break; |
| 222 |
case 22050: |
| 223 |
rgData->freqindex = 4; |
| 224 |
break; |
| 225 |
case 16000: |
| 226 |
rgData->freqindex = 5; |
| 227 |
break; |
| 228 |
case 12000: |
| 229 |
rgData->freqindex = 6; |
| 230 |
break; |
| 231 |
case 11025: |
| 232 |
rgData->freqindex = 7; |
| 233 |
break; |
| 234 |
case 8000: |
| 235 |
rgData->freqindex = 8; |
| 236 |
break; |
| 237 |
default: |
| 238 |
return INIT_GAIN_ANALYSIS_ERROR; |
| 239 |
} |
| 240 |
|
| 241 |
rgData->sampleWindow = |
| 242 |
(samplefreq * RMS_WINDOW_TIME_NUMERATOR + RMS_WINDOW_TIME_DENOMINATOR - |
| 243 |
1) / RMS_WINDOW_TIME_DENOMINATOR; |
| 244 |
|
| 245 |
rgData->lsum = 0.; |
| 246 |
rgData->rsum = 0.; |
| 247 |
rgData->totsamp = 0; |
| 248 |
|
| 249 |
memset(rgData->A, 0, sizeof(rgData->A)); |
| 250 |
|
| 251 |
return INIT_GAIN_ANALYSIS_OK; |
| 252 |
} |
| 253 |
|
| 254 |
int |
| 255 |
InitGainAnalysis(replaygain_t * rgData, long samplefreq) |
| 256 |
{ |
| 257 |
if (ResetSampleFrequency(rgData, samplefreq) != INIT_GAIN_ANALYSIS_OK) { |
| 258 |
return INIT_GAIN_ANALYSIS_ERROR; |
| 259 |
} |
| 260 |
|
| 261 |
rgData->linpre = rgData->linprebuf + MAX_ORDER; |
| 262 |
rgData->rinpre = rgData->rinprebuf + MAX_ORDER; |
| 263 |
rgData->lstep = rgData->lstepbuf + MAX_ORDER; |
| 264 |
rgData->rstep = rgData->rstepbuf + MAX_ORDER; |
| 265 |
rgData->lout = rgData->loutbuf + MAX_ORDER; |
| 266 |
rgData->rout = rgData->routbuf + MAX_ORDER; |
| 267 |
|
| 268 |
memset(rgData->B, 0, sizeof(rgData->B)); |
| 269 |
|
| 270 |
return INIT_GAIN_ANALYSIS_OK; |
| 271 |
} |
| 272 |
|
| 273 |
/* returns GAIN_ANALYSIS_OK if successful, GAIN_ANALYSIS_ERROR if not */ |
| 274 |
|
| 275 |
int |
| 276 |
AnalyzeSamples(replaygain_t * rgData, const Float_t * left_samples, const Float_t * right_samples, |
| 277 |
size_t num_samples, int num_channels) |
| 278 |
{ |
| 279 |
const Float_t *curleft; |
| 280 |
const Float_t *curright; |
| 281 |
long batchsamples; |
| 282 |
long cursamples; |
| 283 |
long cursamplepos; |
| 284 |
int i; |
| 285 |
Float_t sum_l, sum_r; |
| 286 |
|
| 287 |
if (num_samples == 0) |
| 288 |
return GAIN_ANALYSIS_OK; |
| 289 |
|
| 290 |
cursamplepos = 0; |
| 291 |
batchsamples = (long) num_samples; |
| 292 |
|
| 293 |
switch (num_channels) { |
| 294 |
case 1: |
| 295 |
right_samples = left_samples; |
| 296 |
break; |
| 297 |
case 2: |
| 298 |
break; |
| 299 |
default: |
| 300 |
return GAIN_ANALYSIS_ERROR; |
| 301 |
} |
| 302 |
|
| 303 |
if (num_samples < MAX_ORDER) { |
| 304 |
memcpy(rgData->linprebuf + MAX_ORDER, left_samples, num_samples * sizeof(Float_t)); |
| 305 |
memcpy(rgData->rinprebuf + MAX_ORDER, right_samples, num_samples * sizeof(Float_t)); |
| 306 |
} |
| 307 |
else { |
| 308 |
memcpy(rgData->linprebuf + MAX_ORDER, left_samples, MAX_ORDER * sizeof(Float_t)); |
| 309 |
memcpy(rgData->rinprebuf + MAX_ORDER, right_samples, MAX_ORDER * sizeof(Float_t)); |
| 310 |
} |
| 311 |
|
| 312 |
while (batchsamples > 0) { |
| 313 |
cursamples = batchsamples > rgData->sampleWindow - rgData->totsamp ? |
| 314 |
rgData->sampleWindow - rgData->totsamp : batchsamples; |
| 315 |
if (cursamplepos < MAX_ORDER) { |
| 316 |
curleft = rgData->linpre + cursamplepos; |
| 317 |
curright = rgData->rinpre + cursamplepos; |
| 318 |
if (cursamples > MAX_ORDER - cursamplepos) |
| 319 |
cursamples = MAX_ORDER - cursamplepos; |
| 320 |
} |
| 321 |
else { |
| 322 |
curleft = left_samples + cursamplepos; |
| 323 |
curright = right_samples + cursamplepos; |
| 324 |
} |
| 325 |
|
| 326 |
YULE_FILTER(curleft, rgData->lstep + rgData->totsamp, cursamples, |
| 327 |
ABYule[rgData->freqindex]); |
| 328 |
YULE_FILTER(curright, rgData->rstep + rgData->totsamp, cursamples, |
| 329 |
ABYule[rgData->freqindex]); |
| 330 |
|
| 331 |
BUTTER_FILTER(rgData->lstep + rgData->totsamp, rgData->lout + rgData->totsamp, cursamples, |
| 332 |
ABButter[rgData->freqindex]); |
| 333 |
BUTTER_FILTER(rgData->rstep + rgData->totsamp, rgData->rout + rgData->totsamp, cursamples, |
| 334 |
ABButter[rgData->freqindex]); |
| 335 |
|
| 336 |
curleft = rgData->lout + rgData->totsamp; /* Get the squared values */ |
| 337 |
curright = rgData->rout + rgData->totsamp; |
| 338 |
|
| 339 |
sum_l = 0; |
| 340 |
sum_r = 0; |
| 341 |
i = cursamples & 0x03; |
| 342 |
while (i--) { |
| 343 |
Float_t const l = *curleft++; |
| 344 |
Float_t const r = *curright++; |
| 345 |
sum_l += l * l; |
| 346 |
sum_r += r * r; |
| 347 |
} |
| 348 |
i = cursamples / 4; |
| 349 |
while (i--) { |
| 350 |
Float_t l0 = curleft[0] * curleft[0]; |
| 351 |
Float_t l1 = curleft[1] * curleft[1]; |
| 352 |
Float_t l2 = curleft[2] * curleft[2]; |
| 353 |
Float_t l3 = curleft[3] * curleft[3]; |
| 354 |
Float_t sl = l0 + l1 + l2 + l3; |
| 355 |
Float_t r0 = curright[0] * curright[0]; |
| 356 |
Float_t r1 = curright[1] * curright[1]; |
| 357 |
Float_t r2 = curright[2] * curright[2]; |
| 358 |
Float_t r3 = curright[3] * curright[3]; |
| 359 |
Float_t sr = r0 + r1 + r2 + r3; |
| 360 |
sum_l += sl; |
| 361 |
curleft += 4; |
| 362 |
sum_r += sr; |
| 363 |
curright += 4; |
| 364 |
} |
| 365 |
rgData->lsum += sum_l; |
| 366 |
rgData->rsum += sum_r; |
| 367 |
|
| 368 |
batchsamples -= cursamples; |
| 369 |
cursamplepos += cursamples; |
| 370 |
rgData->totsamp += cursamples; |
| 371 |
if (rgData->totsamp == rgData->sampleWindow) { /* Get the Root Mean Square (RMS) for this set of samples */ |
| 372 |
double const val = |
| 373 |
STEPS_per_dB * 10. * log10((rgData->lsum + rgData->rsum) / rgData->totsamp * 0.5 + |
| 374 |
1.e-37); |
| 375 |
size_t ival = (val <= 0) ? 0 : (size_t) val; |
| 376 |
if (ival >= sizeof(rgData->A) / sizeof(*(rgData->A))) |
| 377 |
ival = sizeof(rgData->A) / sizeof(*(rgData->A)) - 1; |
| 378 |
rgData->A[ival]++; |
| 379 |
rgData->lsum = rgData->rsum = 0.; |
| 380 |
memmove(rgData->loutbuf, rgData->loutbuf + rgData->totsamp, |
| 381 |
MAX_ORDER * sizeof(Float_t)); |
| 382 |
memmove(rgData->routbuf, rgData->routbuf + rgData->totsamp, |
| 383 |
MAX_ORDER * sizeof(Float_t)); |
| 384 |
memmove(rgData->lstepbuf, rgData->lstepbuf + rgData->totsamp, |
| 385 |
MAX_ORDER * sizeof(Float_t)); |
| 386 |
memmove(rgData->rstepbuf, rgData->rstepbuf + rgData->totsamp, |
| 387 |
MAX_ORDER * sizeof(Float_t)); |
| 388 |
rgData->totsamp = 0; |
| 389 |
} |
| 390 |
if (rgData->totsamp > rgData->sampleWindow) /* somehow I really screwed up: Error in programming! Contact author about totsamp > sampleWindow */ |
| 391 |
return GAIN_ANALYSIS_ERROR; |
| 392 |
} |
| 393 |
if (num_samples < MAX_ORDER) { |
| 394 |
memmove(rgData->linprebuf, rgData->linprebuf + num_samples, |
| 395 |
(MAX_ORDER - num_samples) * sizeof(Float_t)); |
| 396 |
memmove(rgData->rinprebuf, rgData->rinprebuf + num_samples, |
| 397 |
(MAX_ORDER - num_samples) * sizeof(Float_t)); |
| 398 |
memcpy(rgData->linprebuf + MAX_ORDER - num_samples, left_samples, |
| 399 |
num_samples * sizeof(Float_t)); |
| 400 |
memcpy(rgData->rinprebuf + MAX_ORDER - num_samples, right_samples, |
| 401 |
num_samples * sizeof(Float_t)); |
| 402 |
} |
| 403 |
else { |
| 404 |
memcpy(rgData->linprebuf, left_samples + num_samples - MAX_ORDER, |
| 405 |
MAX_ORDER * sizeof(Float_t)); |
| 406 |
memcpy(rgData->rinprebuf, right_samples + num_samples - MAX_ORDER, |
| 407 |
MAX_ORDER * sizeof(Float_t)); |
| 408 |
} |
| 409 |
|
| 410 |
return GAIN_ANALYSIS_OK; |
| 411 |
} |
| 412 |
|
| 413 |
|
| 414 |
static Float_t |
| 415 |
analyzeResult(uint32_t const *Array, size_t len) |
| 416 |
{ |
| 417 |
uint32_t elems; |
| 418 |
uint32_t upper; |
| 419 |
uint32_t sum; |
| 420 |
size_t i; |
| 421 |
|
| 422 |
elems = 0; |
| 423 |
for (i = 0; i < len; i++) |
| 424 |
elems += Array[i]; |
| 425 |
if (elems == 0) |
| 426 |
return GAIN_NOT_ENOUGH_SAMPLES; |
| 427 |
|
| 428 |
upper = (uint32_t) ceil(elems * (1. - RMS_PERCENTILE)); |
| 429 |
sum = 0; |
| 430 |
for (i = len; i-- > 0;) { |
| 431 |
sum += Array[i]; |
| 432 |
if (sum >= upper) { |
| 433 |
break; |
| 434 |
} |
| 435 |
} |
| 436 |
|
| 437 |
return (Float_t) ((Float_t) PINK_REF - (Float_t) i / (Float_t) STEPS_per_dB); |
| 438 |
} |
| 439 |
|
| 440 |
|
| 441 |
Float_t |
| 442 |
GetTitleGain(replaygain_t * rgData) |
| 443 |
{ |
| 444 |
Float_t retval; |
| 445 |
unsigned int i; |
| 446 |
|
| 447 |
retval = analyzeResult(rgData->A, sizeof(rgData->A) / sizeof(*(rgData->A))); |
| 448 |
|
| 449 |
for (i = 0; i < sizeof(rgData->A) / sizeof(*(rgData->A)); i++) { |
| 450 |
rgData->B[i] += rgData->A[i]; |
| 451 |
rgData->A[i] = 0; |
| 452 |
} |
| 453 |
|
| 454 |
for (i = 0; i < MAX_ORDER; i++) |
| 455 |
rgData->linprebuf[i] = rgData->lstepbuf[i] |
| 456 |
= rgData->loutbuf[i] |
| 457 |
= rgData->rinprebuf[i] |
| 458 |
= rgData->rstepbuf[i] |
| 459 |
= rgData->routbuf[i] = 0.f; |
| 460 |
|
| 461 |
rgData->totsamp = 0; |
| 462 |
rgData->lsum = rgData->rsum = 0.; |
| 463 |
return retval; |
| 464 |
} |
| 465 |
|
| 466 |
#if 0 |
| 467 |
static Float_t GetAlbumGain(replaygain_t const* rgData); |
| 468 |
|
| 469 |
Float_t |
| 470 |
GetAlbumGain(replaygain_t const* rgData) |
| 471 |
{ |
| 472 |
return analyzeResult(rgData->B, sizeof(rgData->B) / sizeof(*(rgData->B))); |
| 473 |
} |
| 474 |
#endif |
| 475 |
|
| 476 |
/* end of gain_analysis.c */ |