3 Ann Hell Ex Machina - Music Software
4 Copyright (C) 2003/2006 Angel Ortega <angel@triptico.com>
6 ss_gen.c - Software syntesizer's sound generators
8 This program is free software; you can redistribute it and/or
9 modify it under the terms of the GNU General Public License
10 as published by the Free Software Foundation; either version 2
11 of the License, or (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 http://www.triptico.com
39 /* maximum number of generators */
40 int ss_gen_num
= SS_MAX_GENERATORS
;
43 static struct ss_gen
* ss_gen_pool
= NULL
;
45 /* free generator queue */
46 static struct ss_gen
* ss_gen_free_queue
= NULL
;
53 static void ss_gen_enqueue(struct ss_gen
** q
, struct ss_gen
* g
)
54 /* Enqueues a generator in a generator queue */
66 void ss_gen_init(void)
67 /* inits the generator pool */
71 ss_gen_pool
= (struct ss_gen
*) realloc(ss_gen_pool
, ss_gen_num
*
72 sizeof(struct ss_gen
));
74 memset(ss_gen_pool
, '\0', ss_gen_num
* sizeof(struct ss_gen
));
76 /* enqueue all into the free generator queue */
77 for(n
= 0;n
< ss_gen_num
;n
++)
78 ss_gen_enqueue(&ss_gen_free_queue
, &ss_gen_pool
[n
]);
82 static struct ss_gen
* ss_gen_dequeue(struct ss_gen
** q
, struct ss_gen
* g
)
83 /* Dequeues a generator from a generator queue */
86 g
->prev
->next
= g
->next
;
91 g
->next
->prev
= g
->prev
;
97 static struct ss_gen
* ss_gen_pop(struct ss_gen
** q
)
98 /* gets the first enqueued generator from q */
100 struct ss_gen
* g
= NULL
;
103 g
= ss_gen_dequeue(q
, *q
);
110 * ss_gen_alloc - Allocs and enqueues a generator
111 * @q: queue where the generator will be enqueued
113 * Allocs and enqueues a generator into the @q queue.
115 * The new generator is returned, or NULL if the
116 * generator pool is empty.
118 struct ss_gen
* ss_gen_alloc(struct ss_gen
** q
)
122 if((g
= ss_gen_pop(&ss_gen_free_queue
)) != NULL
)
123 ss_gen_enqueue(q
, g
);
130 * ss_gen_free - Dequeues a generator and frees it
131 * @q: the queue holding the generator
134 * Dequeues a generator and sends it back to the generator pool.
136 void ss_gen_free(struct ss_gen
** q
, struct ss_gen
* g
)
138 ss_gen_enqueue(&ss_gen_free_queue
, ss_gen_dequeue(q
, g
));
143 * ss_gen_sustain - Sets sustain for a generator
145 * @sustain: sustain time in msecs
147 * Sets sustain for a generator, where @sustain is expressed
150 void ss_gen_sustain(struct ss_gen
* g
, double sustain
)
152 g
->sustain
= MS2F(sustain
);
157 * ss_gen_attack - Sets attack for a generator
159 * @attack: attack time in msecs
161 * Sets attack for a generator, where @attack is expressed
164 void ss_gen_attack(struct ss_gen
* g
, double attack
)
166 if((g
->attack
= MS2F(attack
)) > 0)
168 /* calculates the delta volume */
169 g
->davol
= g
->vol
/ (sample_t
) g
->attack
;
177 * ss_gen_vibrato - Sets vibrato for a generator
179 * @depth: vibrato depth in msecs
180 * @freq: vibrato frequency
182 * Sets vibrato for a generator, with a @depth expressed in
183 * milliseconds and a frequency @freq expressed in hzs.
185 void ss_gen_vibrato(struct ss_gen
* g
, double depth
, double freq
)
187 /* good freq: 6 Hz (0.001) */
188 /* good depth: 1/6 semitone (20, 30 frames) */
190 g
->vib_depth
= MS2F(depth
);
191 g
->vib_inc
= ( 6.28 * freq
) / (double)ss_frequency
;
197 * ss_gen_portamento - Sets portamento for a generator
199 * @portamento: portamento value
201 * Sets portamento for a generator, where @portamento is an
202 * increment to the internal cursor of the wave. This value must
203 * be very small. Negative values will make the frequency slide
204 * down and positive slide up.
206 void ss_gen_portamento(struct ss_gen
* g
, double portamento
)
208 g
->portamento
= portamento
;
213 * ss_gen_play - Activates a generator.
215 * @freq: frequency of the sound to be generated
220 * Activates a generator, usually as a response for a 'note on'
221 * message from an upper level. The wave @w holds all the sample
222 * data (PCM data, base frequency, etc.), @freq is the desired
223 * frequency, @vol the volume and @note_id a positive, unique
224 * identifier for the note.
226 void ss_gen_play(struct ss_gen
* g
, double freq
, sample_t vol
, int note_id
,
230 g
->note_id
= note_id
;
234 /* start from the beginning */
237 /* calculate increment */
238 g
->inc
= freq
/ w
->base_freq
;
239 g
->inc
*= (double) w
->s_rate
/ (double) ss_frequency
;
241 /* default sustain, vibrato and portamento */
242 ss_gen_sustain(g
, 50.0);
243 ss_gen_attack(g
, 0.0);
244 ss_gen_vibrato(g
, 0.0, 0.0);
245 ss_gen_portamento(g
, 0.0);
250 * ss_gen_release - Releases a generator.
253 * Releases a generator, usually as a response for a 'note off'
254 * message from an upper level. The generator enters SS_GEN_RELEASED
255 * mode, which starts generating sustain data until it's over.
257 void ss_gen_release(struct ss_gen
* g
)
259 /* note needs not be tracked anymore */
262 /* calculates the delta volume */
263 g
->dsvol
= g
->vol
/ (sample_t
) g
->sustain
;
268 * ss_gen_frame - Generates a frame of samples.
270 * @n_channels: the desired number of channels
271 * @frame: array where the output samples will be stored
273 * Generates a frame of samples from the @g generator, that will be stored
274 * in the @frame array. If @n_channels is greater than the number
275 * of channels the generator has, they are sequentially spread.
277 * Returns non-zero if the generator is stopped and should be freed.
279 int ss_gen_frame(struct ss_gen
* g
, int n_channels
, sample_t frame
[])
284 sample_t l_frame
[SS_MAX_CHANNELS
];
297 /* process vibrato */
300 g
->vibrato
+= g
->vib_inc
;
301 v
+= sin(g
->vibrato
) * g
->vib_depth
;
304 /* add samples to frame */
305 for(n
= 0;n
< w
->n_channels
;n
++)
306 l_frame
[n
] = ss_get_sample(w
, n
, v
) * g
->vol
;
308 /* spread the frame into n_channels */
309 for(n
= w
->first_channel
, m
= 0;n
< n_channels
;n
++, m
++)
311 frame
[n
] += l_frame
[m
% w
->n_channels
];
313 n
+= w
->skip_channels
;
316 /* increment pointer */
319 /* test loop boundaries */
320 if(g
->cursor
> w
->loop_end
)
323 if(w
->loop_start
< 0)
326 g
->cursor
= w
->loop_start
;
329 /* process sustain */
334 if(--g
->sustain
<= 0)
338 /* process portamento */
339 g
->inc
+= g
->portamento
;