claunia/flac
1
0
Fork 0
mirror of https://github.com/claunia/flac.git synced 2025-12-16 18:54:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

replaygain_analysis : Switch to standard C sized integer types.

Browse Source
This commit is contained in:
Erik de Castro Lopo
2014-06-16 07:24:43 +10:00
parent 19b549f82f
commit b4f7528e9a
3 changed files with 69 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/share/replaygain_analysis.h
View File

@@ -42,15 +42,15 @@
extern "C" { extern "C" {
#endif #endif
typedef float Float_t; /* Type used for filtering */ typedef float float_t; /* Type used for filtering */
extern Float_t ReplayGainReferenceLoudness; /* in dB SPL, currently == 89.0 */ extern float_t ReplayGainReferenceLoudness; /* in dB SPL, currently == 89.0 */
int InitGainAnalysis ( long samplefreq ); int InitGainAnalysis ( long samplefreq );
int ValidGainFrequency ( long samplefreq ); int ValidGainFrequency ( long samplefreq );
int AnalyzeSamples ( const Float_t* left_samples, const Float_t* right_samples, size_t num_samples, int num_channels ); int AnalyzeSamples ( const float_t* left_samples, const float_t* right_samples, size_t num_samples, int num_channels );
Float_t GetTitleGain ( void ); float_t GetTitleGain ( void );
Float_t GetAlbumGain ( void ); float_t GetAlbumGain ( void );
#ifdef __cplusplus #ifdef __cplusplus
} }

14
src/share/grabbag/replaygain.c
View File

@@ -129,7 +129,7 @@ FLAC__bool grabbag__replaygain_init(unsigned sample_frequency)
FLAC__bool grabbag__replaygain_analyze(const FLAC__int32 * const input[], FLAC__bool is_stereo, unsigned bps, unsigned samples) FLAC__bool grabbag__replaygain_analyze(const FLAC__int32 * const input[], FLAC__bool is_stereo, unsigned bps, unsigned samples)
{ {
/* using a small buffer improves data locality; we'd like it to fit easily in the dcache */ /* using a small buffer improves data locality; we'd like it to fit easily in the dcache */
static Float_t lbuffer[2048], rbuffer[2048]; static float_t lbuffer[2048], rbuffer[2048];
static const unsigned nbuffer = sizeof(lbuffer) / sizeof(lbuffer[0]); static const unsigned nbuffer = sizeof(lbuffer) / sizeof(lbuffer[0]);
FLAC__int32 block_peak = 0, s; FLAC__int32 block_peak = 0, s;
unsigned i, j; unsigned i, j;
@@ -150,12 +150,12 @@ FLAC__bool grabbag__replaygain_analyze(const FLAC__int32 * const input[], FLAC__
const unsigned n = local_min(samples, nbuffer); const unsigned n = local_min(samples, nbuffer);
for(i = 0; i < n; i++, j++) { for(i = 0; i < n; i++, j++) {
s = input[0][j]; s = input[0][j];
lbuffer[i] = (Float_t)s; lbuffer[i] = (float_t)s;
s = abs(s); s = abs(s);
block_peak = local_max(block_peak, s); block_peak = local_max(block_peak, s);
s = input[1][j]; s = input[1][j];
rbuffer[i] = (Float_t)s; rbuffer[i] = (float_t)s;
s = abs(s); s = abs(s);
block_peak = local_max(block_peak, s); block_peak = local_max(block_peak, s);
} }
@@ -170,7 +170,7 @@ FLAC__bool grabbag__replaygain_analyze(const FLAC__int32 * const input[], FLAC__
const unsigned n = local_min(samples, nbuffer); const unsigned n = local_min(samples, nbuffer);
for(i = 0; i < n; i++, j++) { for(i = 0; i < n; i++, j++) {
s = input[0][j]; s = input[0][j];
lbuffer[i] = (Float_t)s; lbuffer[i] = (float_t)s;
s = abs(s); s = abs(s);
block_peak = local_max(block_peak, s); block_peak = local_max(block_peak, s);
} }
@@ -193,12 +193,12 @@ FLAC__bool grabbag__replaygain_analyze(const FLAC__int32 * const input[], FLAC__
const unsigned n = local_min(samples, nbuffer); const unsigned n = local_min(samples, nbuffer);
for(i = 0; i < n; i++, j++) { for(i = 0; i < n; i++, j++) {
s = input[0][j]; s = input[0][j];
lbuffer[i] = (Float_t)(scale * (double)s); lbuffer[i] = (float_t)(scale * (double)s);
s = abs(s); s = abs(s);
block_peak = local_max(block_peak, s); block_peak = local_max(block_peak, s);
s = input[1][j]; s = input[1][j];
rbuffer[i] = (Float_t)(scale * (double)s); rbuffer[i] = (float_t)(scale * (double)s);
s = abs(s); s = abs(s);
block_peak = local_max(block_peak, s); block_peak = local_max(block_peak, s);
} }
@@ -213,7 +213,7 @@ FLAC__bool grabbag__replaygain_analyze(const FLAC__int32 * const input[], FLAC__
const unsigned n = local_min(samples, nbuffer); const unsigned n = local_min(samples, nbuffer);
for(i = 0; i < n; i++, j++) { for(i = 0; i < n; i++, j++) {
s = input[0][j]; s = input[0][j];
lbuffer[i] = (Float_t)(scale * (double)s); lbuffer[i] = (float_t)(scale * (double)s);
s = abs(s); s = abs(s);
block_peak = local_max(block_peak, s); block_peak = local_max(block_peak, s);
} }

115
src/share/replaygain_analysis/replaygain_analysis.c
View File

@@ -38,8 +38,8 @@
* *
* to initialize everything. Call * to initialize everything. Call
* *
* AnalyzeSamples ( const Float_t* left_samples, * AnalyzeSamples ( const float_t* left_samples,
* const Float_t* right_samples, * const float_t* right_samples,
* size_t num_samples, * size_t num_samples,
* int num_channels ); * int num_channels );
* *
@@ -59,8 +59,8 @@
* *
* Pseudo-code to process an album: * Pseudo-code to process an album:
* *
* Float_t l_samples [4096]; * float_t l_samples [4096];
* Float_t r_samples [4096]; * float_t r_samples [4096];
* size_t num_samples; * size_t num_samples;
* unsigned int num_songs; * unsigned int num_songs;
* unsigned int i; * unsigned int i;
@@ -98,14 +98,13 @@
#include <string.h> #include <string.h>
#include <math.h> #include <math.h>
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
#include "replaygain_analysis.h" #include "replaygain_analysis.h"
Float_t ReplayGainReferenceLoudness = 89.0; /* in dB SPL */ float_t ReplayGainReferenceLoudness = 89.0; /* in dB SPL */
typedef unsigned short Uint16_t;
typedef signed short Int16_t;
typedef unsigned int Uint32_t;
typedef signed int Int32_t;
#define YULE_ORDER 10 #define YULE_ORDER 10
#define BUTTER_ORDER 2 #define BUTTER_ORDER 2
@@ -117,29 +116,29 @@ typedef signed int Int32_t;
#define MAX_ORDER (BUTTER_ORDER > YULE_ORDER ? BUTTER_ORDER : YULE_ORDER) #define MAX_ORDER (BUTTER_ORDER > YULE_ORDER ? BUTTER_ORDER : YULE_ORDER)
#define PINK_REF 64.82 /* 298640883795 */ /* calibration value */ #define PINK_REF 64.82 /* 298640883795 */ /* calibration value */
static Float_t linprebuf [MAX_ORDER * 2]; static float_t linprebuf [MAX_ORDER * 2];
static Float_t* linpre; /* left input samples, with pre-buffer */ static float_t* linpre; /* left input samples, with pre-buffer */
static Float_t* lstepbuf; static float_t* lstepbuf;
static Float_t* lstep; /* left "first step" (i.e. post first filter) samples */ static float_t* lstep; /* left "first step" (i.e. post first filter) samples */
static Float_t* loutbuf; static float_t* loutbuf;
static Float_t* lout; /* left "out" (i.e. post second filter) samples */ static float_t* lout; /* left "out" (i.e. post second filter) samples */
static Float_t rinprebuf [MAX_ORDER * 2]; static float_t rinprebuf [MAX_ORDER * 2];
static Float_t* rinpre; /* right input samples ... */ static float_t* rinpre; /* right input samples ... */
static Float_t* rstepbuf; static float_t* rstepbuf;
static Float_t* rstep; static float_t* rstep;
static Float_t* routbuf; static float_t* routbuf;
static Float_t* rout; static float_t* rout;
static unsigned int sampleWindow; /* number of samples required to reach number of milliseconds required for RMS window */ static unsigned int sampleWindow; /* number of samples required to reach number of milliseconds required for RMS window */
static unsigned long totsamp; static unsigned long totsamp;
static double lsum; static double lsum;
static double rsum; static double rsum;
#if 0 #if 0
static Uint32_t A [(size_t)(STEPS_per_dB * MAX_dB)]; static uint32_t A [(size_t)(STEPS_per_dB * MAX_dB)];
static Uint32_t B [(size_t)(STEPS_per_dB * MAX_dB)]; static uint32_t B [(size_t)(STEPS_per_dB * MAX_dB)];
#else #else
/* [JEC] Solaris Forte compiler doesn't like float calc in array indices */ /* [JEC] Solaris Forte compiler doesn't like float calc in array indices */
static Uint32_t A [120 * 100]; static uint32_t A [120 * 100];
static Uint32_t B [120 * 100]; static uint32_t B [120 * 100];
#endif #endif
#ifdef _MSC_VER #ifdef _MSC_VER
@@ -149,10 +148,10 @@ static Uint32_t B [120 * 100];
struct ReplayGainFilter { struct ReplayGainFilter {
long rate; long rate;
unsigned downsample; unsigned downsample;
Float_t BYule[YULE_ORDER+1]; float_t BYule[YULE_ORDER+1];
Float_t AYule[YULE_ORDER+1]; float_t AYule[YULE_ORDER+1];
Float_t BButter[BUTTER_ORDER+1]; float_t BButter[BUTTER_ORDER+1];
Float_t AButter[BUTTER_ORDER+1]; float_t AButter[BUTTER_ORDER+1];
}; };
static struct ReplayGainFilter *replaygainfilter; static struct ReplayGainFilter *replaygainfilter;
@@ -273,17 +272,17 @@ static const struct ReplayGainFilter ReplayGainFilters[] = {
/* When calling this procedure, make sure that ip[-order] and op[-order] point to real data! */ /* When calling this procedure, make sure that ip[-order] and op[-order] point to real data! */
static void static void
filter ( const Float_t* input, Float_t* output, size_t nSamples, const Float_t* a, const Float_t* b, size_t order, unsigned downsample ) filter ( const float_t* input, float_t* output, size_t nSamples, const float_t* a, const float_t* b, size_t order, unsigned downsample )
{ {
double y; double y;
size_t i; size_t i;
size_t k; size_t k;
const Float_t* input_head = input; const float_t* input_head = input;
const Float_t* input_tail; const float_t* input_tail;
Float_t* output_head = output; float_t* output_head = output;
Float_t* output_tail; float_t* output_tail;
for ( i = 0; i < nSamples; i++, input_head += downsample, ++output_head ) { for ( i = 0; i < nSamples; i++, input_head += downsample, ++output_head ) {
@@ -298,7 +297,7 @@ filter ( const Float_t* input, Float_t* output, size_t nSamples, const Float_t*
y += *input_tail * b[k] - *output_tail * a[k]; y += *input_tail * b[k] - *output_tail * a[k];
} }
output[i] = (Float_t)y; output[i] = (float_t)y;
} }
} }
@@ -342,7 +341,7 @@ CreateGainFilter ( long samplefreq )
} }
static void* static void*
ReallocateWindowBuffer(unsigned window_size, Float_t **window_buffer) ReallocateWindowBuffer(unsigned window_size, float_t **window_buffer)
{ {
void *p = realloc( void *p = realloc(
*window_buffer, sizeof(**window_buffer) * (window_size + MAX_ORDER)); *window_buffer, sizeof(**window_buffer) * (window_size + MAX_ORDER));
@@ -421,11 +420,11 @@ InitGainAnalysis ( long samplefreq )
/* returns GAIN_ANALYSIS_OK if successful, GAIN_ANALYSIS_ERROR if not */ /* returns GAIN_ANALYSIS_OK if successful, GAIN_ANALYSIS_ERROR if not */
int int
AnalyzeSamples ( const Float_t* left_samples, const Float_t* right_samples, size_t num_samples, int num_channels ) AnalyzeSamples ( const float_t* left_samples, const float_t* right_samples, size_t num_samples, int num_channels )
{ {
unsigned downsample = replaygainfilter->downsample; unsigned downsample = replaygainfilter->downsample;
const Float_t* curleft; const float_t* curleft;
const Float_t* curright; const float_t* curright;
long prebufsamples; long prebufsamples;
long batchsamples; long batchsamples;
long cursamples; long cursamples;
@@ -491,10 +490,10 @@ AnalyzeSamples ( const Float_t* left_samples, const Float_t* right_samples, size
if ( ival >= (int)(sizeof(A)/sizeof(*A)) ) ival = (int)(sizeof(A)/sizeof(*A)) - 1; if ( ival >= (int)(sizeof(A)/sizeof(*A)) ) ival = (int)(sizeof(A)/sizeof(*A)) - 1;
A [ival]++; A [ival]++;
lsum = rsum = 0.; lsum = rsum = 0.;
memmove ( loutbuf , loutbuf + totsamp, MAX_ORDER * sizeof(Float_t) ); memmove ( loutbuf , loutbuf + totsamp, MAX_ORDER * sizeof(float_t) );
memmove ( routbuf , routbuf + totsamp, MAX_ORDER * sizeof(Float_t) ); memmove ( routbuf , routbuf + totsamp, MAX_ORDER * sizeof(float_t) );
memmove ( lstepbuf, lstepbuf + totsamp, MAX_ORDER * sizeof(Float_t) ); memmove ( lstepbuf, lstepbuf + totsamp, MAX_ORDER * sizeof(float_t) );
memmove ( rstepbuf, rstepbuf + totsamp, MAX_ORDER * sizeof(Float_t) ); memmove ( rstepbuf, rstepbuf + totsamp, MAX_ORDER * sizeof(float_t) );
totsamp = 0; totsamp = 0;
} }
if ( totsamp > sampleWindow ) /* somehow I really screwed up: Error in programming! Contact author about totsamp > sampleWindow */ if ( totsamp > sampleWindow ) /* somehow I really screwed up: Error in programming! Contact author about totsamp > sampleWindow */
@@ -502,10 +501,10 @@ AnalyzeSamples ( const Float_t* left_samples, const Float_t* right_samples, size
} }
if ( num_samples < MAX_ORDER ) { if ( num_samples < MAX_ORDER ) {
memmove ( linprebuf, linprebuf + num_samples, (MAX_ORDER-num_samples) * sizeof(Float_t) ); memmove ( linprebuf, linprebuf + num_samples, (MAX_ORDER-num_samples) * sizeof(float_t) );
memmove ( rinprebuf, rinprebuf + num_samples, (MAX_ORDER-num_samples) * sizeof(Float_t) ); memmove ( rinprebuf, rinprebuf + num_samples, (MAX_ORDER-num_samples) * sizeof(float_t) );
memcpy ( linprebuf + MAX_ORDER - num_samples, left_samples, num_samples * sizeof(Float_t) ); memcpy ( linprebuf + MAX_ORDER - num_samples, left_samples, num_samples * sizeof(float_t) );
memcpy ( rinprebuf + MAX_ORDER - num_samples, right_samples, num_samples * sizeof(Float_t) ); memcpy ( rinprebuf + MAX_ORDER - num_samples, right_samples, num_samples * sizeof(float_t) );
} }
else { else {
downsample = replaygainfilter->downsample; downsample = replaygainfilter->downsample;
@@ -523,11 +522,11 @@ AnalyzeSamples ( const Float_t* left_samples, const Float_t* right_samples, size
} }
static Float_t static float_t
analyzeResult ( Uint32_t* Array, size_t len ) analyzeResult ( uint32_t* Array, size_t len )
{ {
Uint32_t elems; uint32_t elems;
Int32_t upper; int32_t upper;
size_t i; size_t i;
elems = 0; elems = 0;
@@ -537,23 +536,23 @@ analyzeResult ( Uint32_t* Array, size_t len )
return GAIN_NOT_ENOUGH_SAMPLES; return GAIN_NOT_ENOUGH_SAMPLES;
#if 0 /* GCC bug workaround: it incorrectly calculates 'elems * (1. - RMS_PERCENTILE)' with -O3 -msse2 ... options */ #if 0 /* GCC bug workaround: it incorrectly calculates 'elems * (1. - RMS_PERCENTILE)' with -O3 -msse2 ... options */
upper = (Int32_t) ceil (elems * (1. - RMS_PERCENTILE)); upper = (int32_t) ceil (elems * (1. - RMS_PERCENTILE));
#else #else
upper = (Int32_t) (elems / 20 + ((elems % 20) ? 1 : 0)); upper = (int32_t) (elems / 20 + ((elems % 20) ? 1 : 0));
#endif #endif
for ( i = len; i-- > 0; ) { for ( i = len; i-- > 0; ) {
if ( (upper -= Array[i]) <= 0 ) if ( (upper -= Array[i]) <= 0 )
break; break;
} }
return (Float_t) ((Float_t)PINK_REF - (Float_t)i / (Float_t)STEPS_per_dB); return (float_t) ((float_t)PINK_REF - (float_t)i / (float_t)STEPS_per_dB);
} }
Float_t float_t
GetTitleGain ( void ) GetTitleGain ( void )
{ {
Float_t retval; float_t retval;
unsigned int i; unsigned int i;
retval = analyzeResult ( A, sizeof(A)/sizeof(*A) ); retval = analyzeResult ( A, sizeof(A)/sizeof(*A) );
@@ -572,7 +571,7 @@ GetTitleGain ( void )
} }
Float_t float_t
GetAlbumGain ( void ) GetAlbumGain ( void )
{ {
return analyzeResult ( B, sizeof(B)/sizeof(*B) ); return analyzeResult ( B, sizeof(B)/sizeof(*B) );