| 1 |
/* |
| 2 |
pinknoise: pink noise generator for libsyn123 |
| 3 |
|
| 4 |
based on: |
| 5 |
patest_pink.c |
| 6 |
|
| 7 |
Generate Pink Noise using Gardner method. |
| 8 |
Optimization suggested by James McCartney uses a tree |
| 9 |
to select which random value to replace. |
| 10 |
|
| 11 |
x x x x x x x x x x x x x x x x |
| 12 |
x x x x x x x x |
| 13 |
x x x x |
| 14 |
x x |
| 15 |
x |
| 16 |
|
| 17 |
Tree is generated by counting trailing zeros in an increasing index. |
| 18 |
When the index is zero, no random number is selected. |
| 19 |
|
| 20 |
This program uses the Portable Audio library which is under development. |
| 21 |
For more information see: http://www.audiomulch.com/portaudio/ |
| 22 |
|
| 23 |
Author: Phil Burk, http://www.softsynth.com |
| 24 |
|
| 25 |
Revision History: |
| 26 |
|
| 27 |
Copyleft 1999 Phil Burk - No rights reserved. |
| 28 |
*/ |
| 29 |
|
| 30 |
#define NO_SMAX |
| 31 |
#define NO_SMIN |
| 32 |
#include "syn123_int.h" |
| 33 |
#include <math.h> |
| 34 |
|
| 35 |
// Calculate pseudo-random 32 bit number based on linear congruential method. |
| 36 |
// ... or via xor after all? That looks a lot better when not |
| 37 |
// faking out with 64 bit long. |
| 38 |
static int32_t GenerateRandomNumber(uint32_t *seed) |
| 39 |
{ |
| 40 |
#if 0 |
| 41 |
*seed = *seed * 196314165 + 907633515; |
| 42 |
#else |
| 43 |
*seed ^= (*seed<<13); |
| 44 |
*seed ^= (*seed>>17); |
| 45 |
*seed ^= (*seed<<5); |
| 46 |
#endif |
| 47 |
return (int32_t)*seed; // Implementaton-defined ... |
| 48 |
} |
| 49 |
|
| 50 |
#define PINK_MAX_RANDOM_ROWS (30) |
| 51 |
#define PINK_RANDOM_BITS (24) |
| 52 |
#define PINK_RANDOM_SHIFT ((sizeof(int32_t)*8)-PINK_RANDOM_BITS-1) |
| 53 |
|
| 54 |
typedef struct |
| 55 |
{ |
| 56 |
int32_t pink_Rows[PINK_MAX_RANDOM_ROWS]; |
| 57 |
int32_t pink_RunningSum; /* Used to optimize summing of generators. */ |
| 58 |
int pink_Index; /* Incremented each sample. */ |
| 59 |
int pink_IndexMask; /* Index wrapped by ANDing with this mask. */ |
| 60 |
float pink_Scalar; /* Used to scale within range of -1.0 to +1.0 */ |
| 61 |
uint32_t rand_value; /* The state of the random number generator. */ |
| 62 |
} PinkNoise; |
| 63 |
|
| 64 |
/* Setup PinkNoise structure for N rows of generators. */ |
| 65 |
static void InitializePinkNoise( PinkNoise *pink, int numRows ) |
| 66 |
{ |
| 67 |
int i; |
| 68 |
int32_t pmax; |
| 69 |
pink->pink_Index = 0; |
| 70 |
pink->pink_IndexMask = (1<<numRows) - 1; |
| 71 |
/* Calculate maximum possible random value. Extra 1 for white noise always added. */ |
| 72 |
pmax = (numRows + 1) * (1<<(PINK_RANDOM_BITS-1)); |
| 73 |
pink->pink_Scalar = 1.0f / pmax; |
| 74 |
/* Initialize rows. */ |
| 75 |
for( i=0; i<numRows; i++ ) pink->pink_Rows[i] = 0; |
| 76 |
pink->pink_RunningSum = 0; |
| 77 |
} |
| 78 |
|
| 79 |
/* Generate Pink noise values between -1.0 and +1.0 */ |
| 80 |
static float GeneratePinkNoise( PinkNoise *pink ) |
| 81 |
{ |
| 82 |
int32_t newRandom; |
| 83 |
int32_t sum; |
| 84 |
float output; |
| 85 |
|
| 86 |
/* Increment and mask index. */ |
| 87 |
pink->pink_Index = (pink->pink_Index + 1) & pink->pink_IndexMask; |
| 88 |
|
| 89 |
/* If index is zero, don't update any random values. */ |
| 90 |
if( pink->pink_Index != 0 ) |
| 91 |
{ |
| 92 |
/* Determine how many trailing zeros in PinkIndex. */ |
| 93 |
/* This algorithm will hang if n==0 so test first. */ |
| 94 |
int numZeros = 0; |
| 95 |
int n = pink->pink_Index; |
| 96 |
while( (n & 1) == 0 ) |
| 97 |
{ |
| 98 |
n = n >> 1; |
| 99 |
numZeros++; |
| 100 |
} |
| 101 |
|
| 102 |
/* Replace the indexed ROWS random value. |
| 103 |
* Subtract and add back to RunningSum instead of adding all the random |
| 104 |
* values together. Only one changes each time. |
| 105 |
*/ |
| 106 |
pink->pink_RunningSum -= pink->pink_Rows[numZeros]; |
| 107 |
newRandom = GenerateRandomNumber(&pink->rand_value) >> PINK_RANDOM_SHIFT; |
| 108 |
pink->pink_RunningSum += newRandom; |
| 109 |
pink->pink_Rows[numZeros] = newRandom; |
| 110 |
} |
| 111 |
|
| 112 |
/* Add extra white noise value. */ |
| 113 |
newRandom = GenerateRandomNumber(&pink->rand_value) >> PINK_RANDOM_SHIFT; |
| 114 |
sum = pink->pink_RunningSum + newRandom; |
| 115 |
|
| 116 |
/* Scale to range of -1.0 to 0.9999. */ |
| 117 |
output = pink->pink_Scalar * sum; |
| 118 |
|
| 119 |
return output; |
| 120 |
} |
| 121 |
|
| 122 |
static void pink_generator(syn123_handle *sh, int samples) |
| 123 |
{ |
| 124 |
for(int i=0; i<samples; ++i) |
| 125 |
sh->workbuf.f64[1][i] = GeneratePinkNoise(sh->handle); |
| 126 |
} |
| 127 |
|
| 128 |
int attribute_align_arg |
| 129 |
syn123_setup_pink(syn123_handle *sh, int rows, unsigned long seed, size_t *period) |
| 130 |
{ |
| 131 |
int ret = SYN123_OK; |
| 132 |
if(!sh) |
| 133 |
return SYN123_BAD_HANDLE; |
| 134 |
syn123_setup_silence(sh); |
| 135 |
if(rows < 1) |
| 136 |
rows = 22; |
| 137 |
if(rows > PINK_MAX_RANDOM_ROWS) |
| 138 |
rows = PINK_MAX_RANDOM_ROWS; |
| 139 |
PinkNoise *handle = malloc(sizeof(PinkNoise)); |
| 140 |
if(!handle) |
| 141 |
return SYN123_DOOM; |
| 142 |
handle->rand_value = seed; |
| 143 |
InitializePinkNoise(handle, rows); |
| 144 |
sh->handle = handle; |
| 145 |
sh->generator = pink_generator; |
| 146 |
if(sh->maxbuf) |
| 147 |
{ |
| 148 |
size_t samplesize = MPG123_SAMPLESIZE(sh->fmt.encoding); |
| 149 |
size_t buffer_samples = sh->maxbuf/samplesize; |
| 150 |
grow_buf(sh, buffer_samples*samplesize); |
| 151 |
if(buffer_samples > sh->bufs/samplesize) |
| 152 |
{ |
| 153 |
ret = SYN123_DOOM; |
| 154 |
goto setup_pink_end; |
| 155 |
} |
| 156 |
int outchannels = sh->fmt.channels; |
| 157 |
sh->fmt.channels = 1; |
| 158 |
size_t buffer_bytes = syn123_read(sh, sh->buf, buffer_samples*samplesize); |
| 159 |
sh->fmt.channels = outchannels; |
| 160 |
InitializePinkNoise(handle, rows); |
| 161 |
if(buffer_bytes != buffer_samples*samplesize) |
| 162 |
{ |
| 163 |
ret = SYN123_WEIRD; |
| 164 |
goto setup_pink_end; |
| 165 |
} |
| 166 |
sh->samples = buffer_samples; |
| 167 |
} |
| 168 |
if(sh->samples) |
| 169 |
{ |
| 170 |
handle->rand_value = seed; |
| 171 |
InitializePinkNoise(handle, rows); |
| 172 |
} |
| 173 |
setup_pink_end: |
| 174 |
if(ret != SYN123_OK) |
| 175 |
syn123_setup_silence(sh); |
| 176 |
if(period) |
| 177 |
*period = sh->samples; |
| 178 |
return ret; |
| 179 |
} |
| 180 |
|