Debian Codegraph @

src/libsyn123/pinknoise.c

raw
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