OOP initial commit with new traces.
[Faustine.git] / interpretor / faust-0.9.47mr3 / architecture / alchemy-as.cpp
1 /************************************************************************
2
3 IMPORTANT NOTE : this file contains two clearly delimited sections :
4 the ARCHITECTURE section (in two parts) and the USER section. Each section
5 is governed by its own copyright and license. Please check individually
6 each section for license and copyright information.
7 *************************************************************************/
8
9 /*******************BEGIN ARCHITECTURE SECTION (part 1/2)****************/
10
11 /************************************************************************
12 FAUST Architecture File
13 Copyright (C) 2010-2011 Travis Skare
14 ---------------------------------------------------------------------
15 This Architecture section is free software; you can redistribute it
16 and/or modify it under the terms of the GNU General Public License
17 as published by the Free Software Foundation; either version 3 of
18 the License, or (at your option) any later version.
19
20 This program is distributed in the hope that it will be useful,
21 but WITHOUT ANY WARRANTY; without even the implied warranty of
22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 GNU General Public License for more details.
24
25 You should have received a copy of the GNU General Public License
26 along with this program; If not, see <http://www.gnu.org/licenses/>.
27
28 EXCEPTION : As a special exception, you may create a larger work that
29 contains this FAUST architecture section and distribute
30 that work under terms of your choice, so long as that this FAUST
31 architecture section is not modified.
32
33
34 ************************************************************************
35 ************************************************************************/
36
37 // Faust -> Alchemy -> ActionScript C++ Architecture File
38
39 #include "AS3.h"
40 // math.h is needed for many faust examples, so include it.
41 // otherwise we have to hand-edit c++.
42 #include "math.h"
43
44
45 #ifdef __GNUC__
46
47 #define max(x,y) (((x)>(y)) ? (x) : (y))
48 #define min(x,y) (((x)<(y)) ? (x) : (y))
49
50 // abs is now predefined
51 //template<typename T> T abs (T a) { return (a<T(0)) ? -a : a; }
52
53 inline int lsr (int x, int n) { return int(((unsigned int)x) >> n); }
54 #else
55 #endif
56 /******************************************************************************
57 *******************************************************************************
58
59 VECTOR INTRINSICS
60
61 *******************************************************************************
62 *******************************************************************************/
63
64 //inline void *aligned_calloc(size_t nmemb, size_t size) { return (void*)((unsigned)(calloc((nmemb*size)+15,sizeof(char)))+15 & 0xfffffff0); }
65 inline void *aligned_calloc(size_t nmemb, size_t size) { return (void*)((size_t)(calloc((nmemb*size)+15,sizeof(char)))+15 & ~15); }
66
67 <<includeIntrinsic>>
68
69 /******************************************************************************
70 *******************************************************************************
71
72 ABSTRACT USER INTERFACE
73
74 *******************************************************************************
75 *******************************************************************************/
76
77 class UI
78 {
79
80 public:
81 bool fStopped;
82 UI() : fStopped(false) {}
83 virtual ~UI() {}
84
85 virtual void addButton(char* label, float* zone) = 0;
86 virtual void addToggleButton(char* label, float* zone) = 0;
87 virtual void addCheckButton(char* label, float* zone) = 0;
88 virtual void addVerticalSlider(char* label, float* zone, float init, float min, float max, float step) = 0;
89 virtual void addHorizontalSlider(char* label, float* zone, float init, float min, float max, float step) = 0;
90 virtual void addNumEntry(char* label, float* zone, float init, float min, float max, float step) = 0;
91
92 virtual void openFrameBox(char* label) = 0;
93 virtual void openTabBox(char* label) = 0;
94 virtual void openHorizontalBox(char* label) = 0;
95 virtual void openVerticalBox(char* label) = 0;
96 virtual void closeBox() = 0;
97
98 virtual void run() = 0;
99
100 void stop() { fStopped = true; }
101 bool stopped() { return fStopped; }
102 };
103
104
105 ////// Implementation of UI
106
107 // Faust UI hookup is straightforward
108 // We subclass from UI and then these methods will get called by compiled
109 // Faust which assembles controls. We handle all UI as needed, and when
110 // things changed we need to set *zone=(some value).
111 // This is a little more complicated when jumping between alchemy/script.
112 // So rather than deal with marshalling pointers, just cheat and use an int:pointer map.
113 // NOTE: I should have used an STL map but that wasn't working back when I used gcc.
114 // I'll investigate since that would clean up the code quite a bit.
115
116 // upper bound on number of controls
117 #define MAX_CONTROLS 25
118 // map of unique ui control id to a float* where faust reads the corresponding value.
119 static float* uidToZone[MAX_CONTROLS];
120 // Counter that assigns control IDs.
121 static int uiMap_id = 0;
122
123 // I wasn't able to properly thunk the UI actionscrpit methods to C.
124 // Since we know the complete UI at the time of creation, a collection of
125 // ui creation info is passed back from faust_init, and actionscript
126 // can read it and create the UI.
127 // This is a little messy and was done last-minute.
128 const int TYPE_BUTTON = 0;
129 const int TYPE_TOGGLE = 1;
130 const int TYPE_SLIDER = 2;
131 // max length for a label - more than 50 chars will get cut.
132 #define LABEL_LEN 50
133 struct uiElemInfo {
134 int type;
135 int id;
136 char label[LABEL_LEN+1];
137 float min;
138 float max;
139 float init;
140 float step;
141 };
142 uiElemInfo uielems[MAX_CONTROLS];
143 static int uielems_size = 0;
144
145 // todo: stdio.h has strncpy, I just got paranoid about extra includes making the code bigger :)
146 void strcopy(char *src, char *dst) {
147 dst[LABEL_LEN] = '\0';
148 for (int i = 0; i < LABEL_LEN; ++i) {
149 if (0 == (dst[i] = src[i])) return;
150 }
151 }
152
153 void BuildUIArray(AS3_Val &array) {
154 for (int i = 0; i < uielems_size; ++i) {
155 AS3_Val result = AS3_Object( "type:AS3ValType,id:AS3ValType,label:AS3ValType,min:AS3ValType,max:AS3ValType,init:AS3ValType,step:AS3ValType",
156 AS3_Int(uielems[i].type),
157 AS3_Int(uielems[i].id),
158 AS3_String(uielems[i].label),
159 AS3_Number(uielems[i].min),
160 AS3_Number(uielems[i].max),
161 AS3_Number(uielems[i].init),
162 AS3_Number(uielems[i].step)
163 );
164 AS3_Set(array, AS3_Int(i), result);
165 // decrease refcount? todo: this may leak memory...
166 //AS3_Release(result);
167 }
168 }
169
170 class ActionScriptUI : public UI {
171 public:
172 ActionScriptUI() {
173 fStopped = false;
174 }
175
176 virtual ~ActionScriptUI() {
177 }
178
179 // Pass in a zone, get back a unique ID.
180 int registerControl(float *zone) {
181 if (!zone) return 0;
182 uiMap_id++;
183 uidToZone[uiMap_id] = zone;
184 return uiMap_id;
185 }
186
187 // Called from Flash when any control is updated.
188 // Results will take effect on the next dsp callback
189 // since everything runs in the same thread.
190 void updateControl(int id, float value) {
191 *(uidToZone[id]) = value;
192 }
193
194
195 virtual void addButton(char* label, float* zone) {
196 int id = registerControl(zone);
197 uielems[uielems_size].type = TYPE_BUTTON;
198 uielems[uielems_size].id = id;
199 strcopy(label, uielems[uielems_size].label);
200 uielems[uielems_size].min = 0;
201 uielems[uielems_size].max = 0;
202 uielems[uielems_size].init = 0;
203 uielems[uielems_size].step = 0;
204 uielems_size++;
205 }
206 virtual void addToggleButton(char* label, float* zone) {
207 int id = registerControl(zone);
208 uielems[uielems_size].type = TYPE_TOGGLE;
209 uielems[uielems_size].id = id;
210 strcopy(label, uielems[uielems_size].label);
211 uielems[uielems_size].min = 0;
212 uielems[uielems_size].max = 0;
213 uielems[uielems_size].init = 0;
214 uielems[uielems_size].step = 0;
215 uielems_size++;
216 }
217 virtual void addCheckButton(char* label, float* zone) {
218 return addToggleButton(label, zone);
219 }
220 virtual void addVerticalSlider(char* label, float* zone, float init, float min, float max, float step) {
221 return addHorizontalSlider(label, zone, init, min, max, step);
222 }
223 virtual void addHorizontalSlider(char* label, float* zone, float init, float min, float max, float step) {
224 int id = registerControl(zone);
225 uielems[uielems_size].type = TYPE_SLIDER;
226 uielems[uielems_size].id = id;
227 strcopy(label, uielems[uielems_size].label);
228 uielems[uielems_size].min = min;
229 uielems[uielems_size].max = max;
230 uielems[uielems_size].init = init;
231 uielems[uielems_size].step = step;
232 uielems_size++;
233 }
234 virtual void addNumEntry(char* label, float* zone, float init, float min, float max, float step) {
235 return addHorizontalSlider(label, zone, init, min, max, step);
236 }
237
238 // Not implemented yet - these only affect UI layout and aren't critical.
239 // See actionscript comments for details.
240 virtual void openFrameBox(char* label) {}
241 virtual void openTabBox(char* label) {}
242 virtual void openHorizontalBox(char* label) {}
243 virtual void openVerticalBox(char* label) {}
244 virtual void closeBox() {}
245 virtual void run() { }
246 };
247
248 /******************************************************************************
249 *******************************************************************************
250
251 FAUST DSP
252
253 *******************************************************************************
254 *******************************************************************************/
255
256
257
258 //----------------------------------------------------------------
259 // abstract definition of a signal processor
260 //----------------------------------------------------------------
261
262 class dsp {
263 protected:
264 int fSamplingFreq;
265 public:
266 dsp() {}
267 virtual ~dsp() {}
268
269 virtual int getNumInputs() = 0;
270 virtual int getNumOutputs() = 0;
271 virtual void buildUserInterface(UI* interface) = 0;
272 virtual void init(int samplingRate) = 0;
273 virtual void compute(int len, float** inputs, float** outputs) = 0;
274 };
275
276
277 //----------------------------------------------------------------------------
278 // FAUST generated signal processor
279 //----------------------------------------------------------------------------
280
281
282
283 /********************END ARCHITECTURE SECTION (part 1/2)****************/
284
285 /**************************BEGIN USER SECTION **************************/
286
287 <<includeclass>>
288
289 /***************************END USER SECTION ***************************/
290
291 /*******************BEGIN ARCHITECTURE SECTION (part 2/2)***************/
292
293
294
295
296 /// Alchemy DSP
297 class Faust {
298 public:
299 Faust() {
300 // mydsp will be defined by faust in 'includeclass'
301 dsp_ = new mydsp();
302 ui_ = new ActionScriptUI();
303 dsp_->buildUserInterface(ui_);
304 dsp_->init(44100); // 44.1k, 2 channels, @ 32-bit is hardcoded into flash player 10.
305 }
306
307 ~Faust() {
308 if (dsp_) delete dsp_;
309 if (ui_) delete ui_;
310 }
311
312 //private:
313 public: // we're all friends here
314 mydsp *dsp_;
315 ActionScriptUI *ui_;
316 };
317
318
319 Faust *faust = NULL;
320
321 // Alchemy wrapper interface code
322 static AS3_Val api_init(void *thisPtr, AS3_Val args) {
323 faust = new Faust();
324 AS3_Val array = AS3_Array("");
325 BuildUIArray(array);
326 return array;
327 }
328
329 static AS3_Val api_shutdown(void *thisPtr, AS3_Val args) {
330 if (faust)
331 delete faust;
332 return AS3_Int(0);
333 }
334
335 // args = int id, float value
336 static AS3_Val api_onControlChange(void *thisPtr, AS3_Val args) {
337 if (!faust) return AS3_Int(0);
338
339 // Marshall the arguments in.
340 int id = 0;
341 AS3_Val controlVal;
342 AS3_ArrayValue(args, "IntType, AS3ValType", &id, &controlVal);
343 double control_double = AS3_NumberValue(controlVal);
344
345 // loss of precision is ok.
346 float value = (float)control_double;
347
348 // Call the actual update function
349 faust->ui_->updateControl(id, value);
350 return AS3_Int(0);
351 }
352
353 #define MAX_FLASH_BUFFER 8192
354 // output buffers - L/R channels separate
355 static float bufferL[MAX_FLASH_BUFFER];
356 static float bufferR[MAX_FLASH_BUFFER];
357 // output buffer - construct interleaved output
358 static float bufferSum[2*MAX_FLASH_BUFFER];
359
360 // input buffers - L/R separate
361 static float inputL[MAX_FLASH_BUFFER];
362 static float inputR[MAX_FLASH_BUFFER];
363 // input buffer scratch space - interleaved
364 static float bufferInSum[2*MAX_FLASH_BUFFER];
365
366 // This is the most 'interesting' function of the file - it takes in flash sound buffers
367 // and sends them through Faust DSP code.
368 // args = int nsamples, float* buffer (byte[] in flash)
369 static AS3_Val api_tick(void *thisPtr, AS3_Val args) {
370 if (!faust) return AS3_Int(0);
371
372 // Marshall arguments in.
373 int nsamples = 0;
374 int use_input = 0;
375 AS3_Val buffer;
376 AS3_Val input;
377 AS3_ArrayValue(args, "IntType, IntType, AS3ValType, AS3ValType", &nsamples, &use_input, &input, &buffer);
378
379 float* outputs[2] = {bufferL, bufferR};
380 float* inputs[2] = {inputL, inputR};
381 if (use_input) {
382 //AS3_ByteArray_seek(input, 0, 0);
383 // we need (#samples * sizeof(float) * 2 channels) bytes.
384 AS3_ByteArray_readBytes((char*)bufferInSum, input, nsamples * 4 * 2);
385 char *src = (char*)bufferInSum;
386 char *dl = (char*)inputL, *dr = (char*)inputR;
387 for (int i = 0; i < nsamples; ++i) {
388 // fix endianness
389 dl[3] = src[0];
390 dl[2] = src[1];
391 dl[1] = src[2];
392 dl[0] = src[3];
393 dr[3] = src[4];
394 dr[2] = src[5];
395 dr[1] = src[6];
396 dr[0] = src[7];
397 dl += 4;
398 dr += 4;
399 src += 8;
400 }
401 }
402
403 // magic!
404 faust->dsp_->compute(nsamples, inputs, outputs);
405
406
407 // Post-process: interleave arrays.
408 // Faust outputs to two separate arrays (which are probably contiguous in memory - see above)
409 // Flash's sound callback needs this as LRLRLRLR...
410 // For added fun, LLVM internal float seems to be the opposite endianness
411 // as what Flash uses, so we have to do this byte-by-byte.
412 char *copyL = (char*)bufferL;
413 char *copyR = (char*)bufferR;
414 char *tape_head = (char*)bufferSum;
415 for (int i = 0; i < nsamples; ++i) {
416 *tape_head++ = copyL[3];
417 *tape_head++ = copyL[2];
418 *tape_head++ = copyL[1];
419 *tape_head++ = copyL[0];
420 *tape_head++ = copyR[3];
421 *tape_head++ = copyR[2];
422 *tape_head++ = copyR[1];
423 *tape_head++ = copyR[0];
424 copyL+=4;
425 copyR+=4;
426 }
427 AS3_ByteArray_writeBytes(buffer, bufferSum, 4 * nsamples * 2);
428
429 return AS3_Int(0);
430 }
431
432
433 //Alchemy entry point
434 // Here we are responsible for contructing an API object to pass back to Flash.
435 // This must contain pointers to all functions which may be called.
436 int main()
437 {
438 //define the methods exposed to ActionScript
439 //typed as an ActionScript Function instance
440 AS3_Val methodInit = AS3_Function( NULL, api_init );
441 AS3_Val methodShutdown = AS3_Function( NULL, api_shutdown );
442 AS3_Val methodOnControlChange = AS3_Function( NULL, api_onControlChange );
443 AS3_Val methodTick = AS3_Function( NULL, api_tick );
444
445 // construct an API lookup table with references to all functions
446 // In flash we'll instantiate one of these and call methods on it
447 // e.g. faust.api_tick().
448 AS3_Val result = AS3_Object(
449 "api_init:AS3ValType, api_shutdown:AS3ValType, api_onControlChange:AS3ValType, api_tick:AS3ValType",
450 methodInit, methodShutdown, methodOnControlChange, methodTick);
451
452 AS3_Release(methodInit);
453 AS3_Release(methodShutdown);
454 AS3_Release(methodOnControlChange);
455 AS3_Release(methodTick);
456
457 // notify Flash of our functions and run -- this function never returns.
458 AS3_LibInit(result);
459
460 return 0;
461 }
462 /********************END ARCHITECTURE SECTION (part 2/2)****************/
463