← Back to branch summary

~drgeo-developers/drgeo/trunk

« back to all changes in this revision

Viewing changes to VMs/iPad/source/Cross/plugins/SoundGenerationPlugin/sqOldSoundPrims.c

  • Committer: Hilaire Fernandes
  • Date: 2012-01-27 21:15:40 UTC
  • Revision ID: hilaire.fernandes@gmail.com-20120127211540-912spf97bhpx6mve
Initial additions

Show diffs side-by-side

added added

removed removed

Lines of Context:
VMs/iPad/source/Cross/plugins/SoundGenerationPlugin/sqOldSoundPrims.c
 
1
/* Automatically generated from Squeak on (4 January 1998 3:05:25 am ) */
 
2
 
 
3
#include "sq.h"
 
4
 
 
5
 
 
6
/* Memory Access Macros */
 
7
#define byteAt(i) (*((unsigned char *) (i)))
 
8
#define byteAtput(i, val) (*((unsigned char *) (i)) = val)
 
9
#define longAt(i) (*((int *) (i)))
 
10
#define longAtput(i, val) (*((int *) (i)) = val)
 
11
 
 
12
/*** Imported Functions/Variables ***/
 
13
extern int stackValue(int);
 
14
extern int successFlag;
 
15
 
 
16
/*** Variables ***/
 
17
 
 
18
/*** Function Prototypes ***/
 
19
int primFMSoundmixSampleCountintostartingAtpan(void);
 
20
int primPluckedSoundmixSampleCountintostartingAtpan(void);
 
21
int primSampledSoundmixSampleCountintostartingAtpan(void);
 
22
int primWaveTableSoundmixSampleCountintostartingAtpan(void);
 
23
int oldprimSampledSoundmixSampleCountintostartingAtleftVolrightVol(void);
 
24
 
 
25
int primFMSoundmixSampleCountintostartingAtpan(void) {
 
26
    int rcvr;
 
27
    int n;
 
28
    short int *aSoundBuffer;
 
29
    int startIndex;
 
30
    int pan;
 
31
    int mySample;
 
32
    int sample;
 
33
    int lastIndex;
 
34
    int channelIndex;
 
35
    int i;
 
36
    short int *waveTable;
 
37
    int waveTableSize;
 
38
    int count;
 
39
    int amplitude;
 
40
    int increment;
 
41
    int index;
 
42
    int modulation;
 
43
    int offsetIncrement;
 
44
    int offsetIndex;
 
45
 
 
46
        rcvr = stackValue(4);
 
47
        n = checkedIntegerValueOf(stackValue(3));
 
48
        aSoundBuffer = arrayValueOf(stackValue(2));
 
49
        startIndex = checkedIntegerValueOf(stackValue(1));
 
50
        pan = checkedIntegerValueOf(stackValue(0));
 
51
        waveTable = fetchArrayofObject(1, rcvr);
 
52
        waveTableSize = fetchIntegerofObject(2, rcvr);
 
53
        count = fetchIntegerofObject(4, rcvr);
 
54
        amplitude = fetchIntegerofObject(6, rcvr);
 
55
        increment = fetchIntegerofObject(8, rcvr);
 
56
        index = fetchIntegerofObject(9, rcvr);
 
57
        modulation = fetchIntegerofObject(11, rcvr);
 
58
        offsetIncrement = fetchIntegerofObject(14, rcvr);
 
59
        offsetIndex = fetchIntegerofObject(15, rcvr);
 
60
        if (!(successFlag)) {
 
61
                return null;
 
62
        }
 
63
        lastIndex = (startIndex + n) - 1;
 
64
        for (i = startIndex; i <= lastIndex; i += 1) {
 
65
                mySample = (amplitude * (waveTable[index - 1])) / 1000;
 
66
                if (pan > 0) {
 
67
                        channelIndex = 2 * i;
 
68
                        sample = (aSoundBuffer[channelIndex - 1]) + ((mySample * pan) / 1000);
 
69
                        if (sample > 32767) {
 
70
                                sample = 32767;
 
71
                        }
 
72
                        if (sample < -32767) {
 
73
                                sample = -32767;
 
74
                        }
 
75
                        aSoundBuffer[channelIndex - 1] = sample;
 
76
                }
 
77
                if (pan < 1000) {
 
78
                        channelIndex = (2 * i) - 1;
 
79
                        sample = (aSoundBuffer[channelIndex - 1]) + ((mySample * (1000 - pan)) / 1000);
 
80
                        if (sample > 32767) {
 
81
                                sample = 32767;
 
82
                        }
 
83
                        if (sample < -32767) {
 
84
                                sample = -32767;
 
85
                        }
 
86
                        aSoundBuffer[channelIndex - 1] = sample;
 
87
                }
 
88
                index = (index + increment) + ((modulation * (waveTable[offsetIndex - 1])) / 1000000);
 
89
                if (index > waveTableSize) {
 
90
                        index -= waveTableSize;
 
91
                }
 
92
                if (index < 1) {
 
93
                        index += waveTableSize;
 
94
                }
 
95
                offsetIndex += offsetIncrement;
 
96
                if (offsetIndex > waveTableSize) {
 
97
                        offsetIndex -= waveTableSize;
 
98
                }
 
99
        }
 
100
        count -= n;
 
101
        storeIntegerofObjectwithValue(4, rcvr, count);
 
102
        storeIntegerofObjectwithValue(9, rcvr, index);
 
103
        storeIntegerofObjectwithValue(15, rcvr, offsetIndex);
 
104
        pop(4);
 
105
}
 
106
 
 
107
int primPluckedSoundmixSampleCountintostartingAtpan(void) {
 
108
    int rcvr;
 
109
    int n;
 
110
    short int *aSoundBuffer;
 
111
    int startIndex;
 
112
    int pan;
 
113
    int lastIndex;
 
114
    int channelIndex;
 
115
    int i;
 
116
    int sample;
 
117
    int mySample;
 
118
    int thisIndex;
 
119
    int nextIndex;
 
120
    int count;
 
121
    short int *ring;
 
122
    int ringSize;
 
123
    int ringIndx;
 
124
 
 
125
        rcvr = stackValue(4);
 
126
        n = checkedIntegerValueOf(stackValue(3));
 
127
        aSoundBuffer = arrayValueOf(stackValue(2));
 
128
        startIndex = checkedIntegerValueOf(stackValue(1));
 
129
        pan = checkedIntegerValueOf(stackValue(0));
 
130
        count = fetchIntegerofObject(2, rcvr);
 
131
        ring = fetchArrayofObject(4, rcvr);
 
132
        ringSize = fetchIntegerofObject(5, rcvr);
 
133
        ringIndx = fetchIntegerofObject(6, rcvr);
 
134
        if (!(successFlag)) {
 
135
                return null;
 
136
        }
 
137
        lastIndex = (startIndex + n) - 1;
 
138
        thisIndex = ringIndx;
 
139
        for (i = startIndex; i <= lastIndex; i += 1) {
 
140
                nextIndex = (thisIndex % ringSize) + 1;
 
141
                mySample = ((ring[thisIndex - 1]) + (ring[nextIndex - 1])) / 2;
 
142
                ring[thisIndex - 1] = mySample;
 
143
                thisIndex = nextIndex;
 
144
                if (pan > 0) {
 
145
                        channelIndex = 2 * i;
 
146
                        sample = (aSoundBuffer[channelIndex - 1]) + ((mySample * pan) / 1000);
 
147
                        if (sample > 32767) {
 
148
                                sample = 32767;
 
149
                        }
 
150
                        if (sample < -32767) {
 
151
                                sample = -32767;
 
152
                        }
 
153
                        aSoundBuffer[channelIndex - 1] = sample;
 
154
                }
 
155
                if (pan < 1000) {
 
156
                        channelIndex = (2 * i) - 1;
 
157
                        sample = (aSoundBuffer[channelIndex - 1]) + ((mySample * (1000 - pan)) / 1000);
 
158
                        if (sample > 32767) {
 
159
                                sample = 32767;
 
160
                        }
 
161
                        if (sample < -32767) {
 
162
                                sample = -32767;
 
163
                        }
 
164
                        aSoundBuffer[channelIndex - 1] = sample;
 
165
                }
 
166
        }
 
167
        ringIndx = nextIndex;
 
168
        count -= n;
 
169
        storeIntegerofObjectwithValue(2, rcvr, count);
 
170
        storeIntegerofObjectwithValue(6, rcvr, ringIndx);
 
171
        pop(4);
 
172
}
 
173
 
 
174
int primSampledSoundmixSampleCountintostartingAtpan(void) {
 
175
    int rcvr;
 
176
    int n;
 
177
    short int *aSoundBuffer;
 
178
    int startIndex;
 
179
    int pan;
 
180
    int lastIndex;
 
181
    int i;
 
182
    int channelIndex;
 
183
    int sample;
 
184
    int sampleIndex;
 
185
    int thisSample;
 
186
    short int *samples;
 
187
    int samplesSize;
 
188
    int incrementTimes1000;
 
189
    int count;
 
190
    int indexTimes1000;
 
191
 
 
192
        rcvr = stackValue(4);
 
193
        n = checkedIntegerValueOf(stackValue(3));
 
194
        aSoundBuffer = arrayValueOf(stackValue(2));
 
195
        startIndex = checkedIntegerValueOf(stackValue(1));
 
196
        pan = checkedIntegerValueOf(stackValue(0));
 
197
        samples = fetchArrayofObject(1, rcvr);
 
198
        samplesSize = fetchIntegerofObject(2, rcvr);
 
199
        incrementTimes1000 = fetchIntegerofObject(3, rcvr);
 
200
        count = fetchIntegerofObject(5, rcvr);
 
201
        indexTimes1000 = fetchIntegerofObject(6, rcvr);
 
202
        if (!(successFlag)) {
 
203
                return null;
 
204
        }
 
205
        lastIndex = (startIndex + n) - 1;
 
206
        i = startIndex;
 
207
        sampleIndex = indexTimes1000 / 1000;
 
208
        while ((sampleIndex <= samplesSize) && (i <= lastIndex)) {
 
209
                thisSample = samples[sampleIndex - 1];
 
210
                if (pan > 0) {
 
211
                        channelIndex = 2 * i;
 
212
                        sample = (aSoundBuffer[channelIndex - 1]) + ((thisSample * pan) / 1000);
 
213
                        if (sample > 32767) {
 
214
                                sample = 32767;
 
215
                        }
 
216
                        if (sample < -32767) {
 
217
                                sample = -32767;
 
218
                        }
 
219
                        aSoundBuffer[channelIndex - 1] = sample;
 
220
                }
 
221
                if (pan < 1000) {
 
222
                        channelIndex = (2 * i) - 1;
 
223
                        sample = (aSoundBuffer[channelIndex - 1]) + ((thisSample * (1000 - pan)) / 1000);
 
224
                        if (sample > 32767) {
 
225
                                sample = 32767;
 
226
                        }
 
227
                        if (sample < -32767) {
 
228
                                sample = -32767;
 
229
                        }
 
230
                        aSoundBuffer[channelIndex - 1] = sample;
 
231
                }
 
232
                indexTimes1000 += incrementTimes1000;
 
233
                sampleIndex = indexTimes1000 / 1000;
 
234
                i += 1;
 
235
        }
 
236
        count -= n;
 
237
        storeIntegerofObjectwithValue(5, rcvr, count);
 
238
        storeIntegerofObjectwithValue(6, rcvr, indexTimes1000);
 
239
        pop(4);
 
240
}
 
241
 
 
242
int primWaveTableSoundmixSampleCountintostartingAtpan(void) {
 
243
    int rcvr;
 
244
    int n;
 
245
    short int *aSoundBuffer;
 
246
    int startIndex;
 
247
    int pan;
 
248
    int lastIndex;
 
249
    int channelIndex;
 
250
    int i;
 
251
    int mySample;
 
252
    int sample;
 
253
    short int *waveTable;
 
254
    int waveTableSize;
 
255
    int count;
 
256
    int amplitude;
 
257
    int increment;
 
258
    int index;
 
259
 
 
260
        rcvr = stackValue(4);
 
261
        n = checkedIntegerValueOf(stackValue(3));
 
262
        aSoundBuffer = arrayValueOf(stackValue(2));
 
263
        startIndex = checkedIntegerValueOf(stackValue(1));
 
264
        pan = checkedIntegerValueOf(stackValue(0));
 
265
        waveTable = fetchArrayofObject(1, rcvr);
 
266
        waveTableSize = fetchIntegerofObject(2, rcvr);
 
267
        count = fetchIntegerofObject(4, rcvr);
 
268
        amplitude = fetchIntegerofObject(6, rcvr);
 
269
        increment = fetchIntegerofObject(8, rcvr);
 
270
        index = fetchIntegerofObject(9, rcvr);
 
271
        if (!(successFlag)) {
 
272
                return null;
 
273
        }
 
274
        lastIndex = (startIndex + n) - 1;
 
275
        for (i = startIndex; i <= lastIndex; i += 1) {
 
276
                mySample = (amplitude * (waveTable[index - 1])) / 1000;
 
277
                if (pan > 0) {
 
278
                        channelIndex = 2 * i;
 
279
                        sample = (aSoundBuffer[channelIndex - 1]) + ((mySample * pan) / 1000);
 
280
                        if (sample > 32767) {
 
281
                                sample = 32767;
 
282
                        }
 
283
                        if (sample < -32767) {
 
284
                                sample = -32767;
 
285
                        }
 
286
                        aSoundBuffer[channelIndex - 1] = sample;
 
287
                }
 
288
                if (pan < 1000) {
 
289
                        channelIndex = (2 * i) - 1;
 
290
                        sample = (aSoundBuffer[channelIndex - 1]) + ((mySample * (1000 - pan)) / 1000);
 
291
                        if (sample > 32767) {
 
292
                                sample = 32767;
 
293
                        }
 
294
                        if (sample < -32767) {
 
295
                                sample = -32767;
 
296
                        }
 
297
                        aSoundBuffer[channelIndex - 1] = sample;
 
298
                }
 
299
                index += increment;
 
300
                if (index > waveTableSize) {
 
301
                        index -= waveTableSize;
 
302
                }
 
303
        }
 
304
        count -= n;
 
305
        storeIntegerofObjectwithValue(4, rcvr, count);
 
306
        storeIntegerofObjectwithValue(9, rcvr, index);
 
307
        pop(4);
 
308
}
 
309
 
 
310
int oldprimSampledSoundmixSampleCountintostartingAtleftVolrightVol(void) {
 
311
    int rcvr;
 
312
    int n;
 
313
    short int *aSoundBuffer;
 
314
    int startIndex;
 
315
    int leftVol;
 
316
    int rightVol;
 
317
    int sliceIndex;
 
318
    int sampleIndex;
 
319
    int sample;
 
320
    int s;
 
321
    int lastIndex;
 
322
    int i;
 
323
    int scaledVol;
 
324
    int scaledVolIncr;
 
325
    int scaledVolLimit;
 
326
    int count;
 
327
    short int *samples;
 
328
    int samplesSize;
 
329
    int incrementTimes1000;
 
330
    int indexTimes1000;
 
331
 
 
332
        rcvr = stackValue(5);
 
333
        n = checkedIntegerValueOf(stackValue(4));
 
334
        aSoundBuffer = arrayValueOf(stackValue(3));
 
335
        aSoundBuffer -= 1;
 
336
        startIndex = checkedIntegerValueOf(stackValue(2));
 
337
        leftVol = checkedIntegerValueOf(stackValue(1));
 
338
        rightVol = checkedIntegerValueOf(stackValue(0));
 
339
        scaledVol = fetchIntegerofObject(3, rcvr);
 
340
        scaledVolIncr = fetchIntegerofObject(4, rcvr);
 
341
        scaledVolLimit = fetchIntegerofObject(5, rcvr);
 
342
        count = fetchIntegerofObject(7, rcvr);
 
343
        samples = fetchArrayofObject(8, rcvr);
 
344
        samples -= 1;
 
345
        samplesSize = fetchIntegerofObject(10, rcvr);
 
346
        incrementTimes1000 = fetchIntegerofObject(11, rcvr);
 
347
        indexTimes1000 = fetchIntegerofObject(12, rcvr);
 
348
        if (!(successFlag)) {
 
349
                return null;
 
350
        }
 
351
        lastIndex = (startIndex + n) - 1;
 
352
        sliceIndex = startIndex;
 
353
        sampleIndex = indexTimes1000 / 1000;
 
354
        while ((sampleIndex <= samplesSize) && (sliceIndex <= lastIndex)) {
 
355
                sample = ((int) ((samples[sampleIndex]) * scaledVol) >> 15);
 
356
                if (leftVol > 0) {
 
357
                        i = (2 * sliceIndex) - 1;
 
358
                        s = (aSoundBuffer[i]) + (((int) (sample * leftVol) >> 15));
 
359
                        if (s > 32767) {
 
360
                                s = 32767;
 
361
                        }
 
362
                        if (s < -32767) {
 
363
                                s = -32767;
 
364
                        }
 
365
                        aSoundBuffer[i] = s;
 
366
                }
 
367
                if (rightVol > 0) {
 
368
                        i = 2 * sliceIndex;
 
369
                        s = (aSoundBuffer[i]) + (((int) (sample * rightVol) >> 15));
 
370
                        if (s > 32767) {
 
371
                                s = 32767;
 
372
                        }
 
373
                        if (s < -32767) {
 
374
                                s = -32767;
 
375
                        }
 
376
                        aSoundBuffer[i] = s;
 
377
                }
 
378
                if (scaledVolIncr != 0) {
 
379
                        scaledVol += scaledVolIncr;
 
380
                        if (((scaledVolIncr > 0) && (scaledVol >= scaledVolLimit)) || ((scaledVolIncr < 0) && (scaledVol <= scaledVolLimit))) {
 
381
                                scaledVol = scaledVolLimit;
 
382
                                scaledVolIncr = 0;
 
383
                        }
 
384
                }
 
385
                indexTimes1000 += incrementTimes1000;
 
386
                sampleIndex = indexTimes1000 / 1000;
 
387
                sliceIndex += 1;
 
388
        }
 
389
        count -= n;
 
390
        if (!(successFlag)) {
 
391
                return null;
 
392
        }
 
393
        storeIntegerofObjectwithValue(3, rcvr, scaledVol);
 
394
        storeIntegerofObjectwithValue(4, rcvr, scaledVolIncr);
 
395
        storeIntegerofObjectwithValue(7, rcvr, count);
 
396
        storeIntegerofObjectwithValue(12, rcvr, indexTimes1000);
 
397
        pop(5);
 
398
}