changed example to help files

svn path=/trunk/externals/iem16/; revision=7314

11 files changed, 378 insertions, 0 deletions

diff --git a/help/del16read~-help.pd b/help/del16read~-help.pd
new file mode 100644
index 0000000..6d4d511
--- /dev/null
+++ b/help/del16read~-help.pd
@@ -0,0 +1,41 @@
+#N canvas 24 20 800 531 12;
+#X text 372 274 1st argument: name of delay line;
+#X floatatom 116 253 0 0 0 0 - - -;
+#X text 151 255 float input (delay time in ms);
+#X text 127 310 signal output (delayed signal);
+#X floatatom 383 177 0 0 0 0 - - -;
+#X obj 116 375 snapshot~;
+#X floatatom 116 399 0 0 0 0 - - -;
+#X obj 24 246 loadbang;
+#X obj 24 313 metro 200;
+#X msg 32 273 \; pd dsp 1;
+#X text 424 176 input to delay line;
+#X obj 383 201 sig~;
+#X text 372 290 2nd argument: (initial) delay time in ms;
+#X text 36 443 see also:;
+#X obj 116 286 del16read~ del_example 1000;
+#X obj 383 226 del16write~ del_example 1000;
+#X obj 24 16 del16read~;
+#X obj 126 444 del16write~;
+#X obj 239 444 vd16~;
+#X text 133 14 - read a 16bit signal from a 16bit-delay line;
+#X obj 368 52 delread~;
+#X text 21 52 This is very similar to the pd-object;
+#X text 49 82 It uses only 16bit to store the samples \, which will
+need only half of the memory of pd's floatingpoint-based object.;
+#X text 50 120 However \, there are 2 drawbacks: there will be some
+additional noise (because floats are more precise than 16bit) \, and
+you cannot have values>1 stored in the delay-line;
+#X text 38 490 similar pd-objects:;
+#X obj 223 489 delread~;
+#X obj 307 489 delwrite~;
+#X obj 400 489 vd~;
+#X text 433 443 updated for iem16 version1.0;
+#X connect 1 0 14 0;
+#X connect 4 0 11 0;
+#X connect 5 0 6 0;
+#X connect 7 0 8 0;
+#X connect 7 0 9 0;
+#X connect 8 0 5 0;
+#X connect 11 0 15 0;
+#X connect 14 0 5 0;
diff --git a/help/del16write~-help.pd b/help/del16write~-help.pd
new file mode 100644
index 0000000..5aa280a
--- /dev/null
+++ b/help/del16write~-help.pd
@@ -0,0 +1,25 @@
+#N canvas 83 192 678 431 12;
+#X text 88 202 signal input;
+#X text 136 16 writes a signal in a delay line;
+#X text 281 235 1st argument: name of delay line;
+#X obj 24 203 sig~ 0;
+#X text 304 265 (= max. delay time);
+#X text 281 251 2nd argument: length of delay line in msec;
+#X text 24 292 see also:;
+#X obj 24 16 del16write~;
+#X obj 112 294 delread16~;
+#X obj 209 294 vd16~;
+#X text 16 353 similar pd-objects:;
+#X obj 201 352 delread~;
+#X obj 285 352 delwrite~;
+#X obj 378 352 vd~;
+#X obj 24 237 del16write~ del_line_xxx 500;
+#X text 21 51 This is very similar to the pd-object;
+#X text 49 81 It uses only 16bit to store the samples \, which will
+need only half of the memory of pd's floatingpoint-based object.;
+#X text 50 119 However \, there are 2 drawbacks: there will be some
+additional noise (because floats are more precise than 16bit) \, and
+you cannot have values>1 stored in the delay-line;
+#X obj 368 51 delwrite~;
+#X text 411 306 updated for iem16 version1.0;
+#X connect 3 0 14 0;
diff --git a/help/tab16play~-help.pd b/help/tab16play~-help.pd
new file mode 100644
index 0000000..8c53199
--- /dev/null
+++ b/help/tab16play~-help.pd
@@ -0,0 +1,56 @@
+#N canvas 159 54 804 495 10;
+#X msg 639 93 \; pd dsp 0;
+#X floatatom 11 342 0 0 0 0 - - -;
+#X msg 11 109 set array99;
+#X text 93 109 "set" message permits you to switch between arrays;
+#X text 138 228 creation argument initializes array name;
+#X obj 11 316 env~ 16384;
+#X obj 87 360 dac~ 1;
+#X obj 87 323 *~;
+#X obj 100 304 line~;
+#X msg 100 263 0.1 100;
+#X msg 116 284 0 100;
+#X text 162 264 on;
+#X text 157 283 off;
+#X text 148 301 envelope;
+#X text 148 312 generator;
+#X text 101 248 amplitude controls:;
+#X text 131 362 audio output;
+#X obj 87 342 hip~ 5;
+#X msg 26 179 0 44100;
+#X msg 27 158 44100;
+#X msg 26 138 bang;
+#X text 80 136 "bang" or 0 plays whole sample;
+#X text 82 157 play starting at 44100th sample;
+#X text 93 177 play starting at beginning for 44100 samples;
+#X msg 25 199 44100 1000;
+#X text 103 198 play from 44100 through 45099 (1000 samples);
+#X obj 11 228 tab16play~ array99;
+#X obj 589 205 table16 array99;
+#X text 389 444 updated for iem16 version1.0;
+#X obj 5 439 tab16write~;
+#X obj 5 458 tab16read4~;
+#X obj 89 458 tab16read;
+#X obj 89 439 tab16write;
+#X obj 166 439 tab16send~;
+#X obj 166 458 tab16receive~;
+#X obj 32 13 tab16play~;
+#X text 29 43 The [tab16play~] object is the same as the [tabplay~]
+object \, but it refers to 16bit-arrays stored in [table16] instead
+of floating-point arrays (stored in normal pd-tables/arrays);
+#X obj 328 444 table16;
+#X text 11 417 see also:;
+#X text 108 14 play a 16bit-table as a sample (non-transposing);
+#X connect 2 0 26 0;
+#X connect 5 0 1 0;
+#X connect 7 0 17 0;
+#X connect 8 0 7 1;
+#X connect 9 0 8 0;
+#X connect 10 0 8 0;
+#X connect 17 0 6 0;
+#X connect 18 0 26 0;
+#X connect 19 0 26 0;
+#X connect 20 0 26 0;
+#X connect 24 0 26 0;
+#X connect 26 0 5 0;
+#X connect 26 0 7 0;
diff --git a/help/tab16read-help.pd b/help/tab16read-help.pd
new file mode 100644
index 0000000..fd34feb
--- /dev/null
+++ b/help/tab16read-help.pd
@@ -0,0 +1,27 @@
+#N canvas 245 143 703 316 12;
+#X text 62 102 index;
+#X floatatom 25 103 0 0 0 0 - - -;
+#X floatatom 25 199 0 0 0 0 - - -;
+#X text 70 197 output = array99[index];
+#X text 189 157 creation argument;
+#X text 185 175 gives array name;
+#X msg 35 125 set array99;
+#X text 147 125 change array name;
+#X obj 25 165 tab16read array99;
+#X obj 422 131 table16 array99;
+#X obj 17 13 tab16read;
+#X text 412 257 updated for iem16 version1.0;
+#X obj 16 252 tab16write~;
+#X obj 16 271 tab16read4~;
+#X obj 120 271 tab16read;
+#X obj 120 252 tab16write;
+#X obj 217 252 tab16send~;
+#X obj 217 271 tab16receive~;
+#X obj 339 257 table16;
+#X text 108 15 - read numbers from a 16bit-table;
+#X text 21 42 since [table16] can only hold 16bit values \, the output
+of [tab16read] is limited to integer-values between -32768..+32767
+;
+#X connect 1 0 8 0;
+#X connect 6 0 8 0;
+#X connect 8 0 2 0;
diff --git a/help/tab16read4~-help.pd b/help/tab16read4~-help.pd
new file mode 100644
index 0000000..6757552
--- /dev/null
+++ b/help/tab16read4~-help.pd
@@ -0,0 +1,39 @@
+#N canvas 59 33 741 466 10;
+#X text 21 207 signal input x(n);
+#X text 127 21 4-point-interpolating table lookup;
+#X obj 11 316 snapshot~;
+#X obj 30 290 metro 200;
+#X obj 11 124 sig~;
+#X floatatom 11 98 0 0 0 0 - - -;
+#X obj 30 264 r readout;
+#X floatatom 11 342 0 0 0 0 - - -;
+#X text 49 94 incoming signal is index. Indices should range from 1
+to (size-2) so that the 4-point interpolation is meaningful. You can
+shift-drag the number box to see the effect of interpolation.;
+#X msg 34 158 set array99;
+#X text 116 158 "set" message permits you to switch between arrays
+;
+#X text 149 228 creation argument initializes array name;
+#X obj 10 228 tab16read4~ array99;
+#X obj 460 301 table16 array99;
+#X text 395 400 updated for iem16 version1.0;
+#X obj 11 395 tab16write~;
+#X obj 11 414 tab16read4~;
+#X obj 95 414 tab16read;
+#X obj 95 395 tab16write;
+#X obj 172 395 tab16send~;
+#X obj 172 414 tab16receive~;
+#X obj 334 400 table16;
+#X obj 47 21 tab16read4~;
+#X text 7 51 tab16read4~ is used to build samplers and other table
+lookup algorithms. The interpolation scheme is 4-point polynomial.
+;
+#X text 185 266 since [table16] can only hold 16bit-values \, the stored
+integer values -32768..+32767 are converted to floats -1.0..+1.0;
+#X connect 2 0 7 0;
+#X connect 3 0 2 0;
+#X connect 4 0 12 0;
+#X connect 5 0 4 0;
+#X connect 6 0 3 0;
+#X connect 9 0 12 0;
+#X connect 12 0 2 0;
diff --git a/help/tab16receive~-help.pd b/help/tab16receive~-help.pd
new file mode 100644
index 0000000..292ec2b
--- /dev/null
+++ b/help/tab16receive~-help.pd
@@ -0,0 +1,18 @@
+#N canvas 109 83 646 239 12;
+#X text 17 53 creation argument: name of array;
+#X text 16 83 By default a block is 64 samples \; this can be reset
+using the block~ object.;
+#X obj 21 18 tab16receive~;
+#X text 376 199 updated for iem16 version1.0;
+#X obj 5 176 tab16write~;
+#X obj 5 195 tab16read4~;
+#X obj 109 195 tab16read;
+#X obj 109 176 tab16write;
+#X obj 204 176 tab16send~;
+#X obj 204 195 tab16receive~;
+#X obj 328 181 table16;
+#X text 17 155 see also:;
+#X text 129 18 - read a block of a 16bit-signal from an array continuously
+;
+#X text 10 129 16bit-signals are limited to 65536 values between -1.0..+1.0
+;
diff --git a/help/tab16send~-help.pd b/help/tab16send~-help.pd
new file mode 100644
index 0000000..918d75a
--- /dev/null
+++ b/help/tab16send~-help.pd
@@ -0,0 +1,20 @@
+#N canvas 151 91 705 277 12;
+#X text 113 26 writes one block of a signal continuously to an array
+;
+#X text 41 60 creation argument: name of array;
+#X text 29 96 By default a block is 64 samples \; this can be reset
+using the block~ object.;
+#X text 376 239 updated for iem16 version1.0;
+#X obj 5 216 tab16write~;
+#X obj 5 235 tab16read4~;
+#X obj 109 235 tab16read;
+#X obj 109 216 tab16write;
+#X obj 204 216 tab16send~;
+#X obj 204 235 tab16receive~;
+#X obj 328 221 table16;
+#X text 17 195 see also:;
+#X text 14 137 16bit-signals are limited to 65536 values between -1.0..+1.0
+;
+#X text 16 157 if your signal has absolute values >1.0 \, these are
+wrapped around...;
+#X obj 11 27 tab16send~;
diff --git a/help/tab16write-help.pd b/help/tab16write-help.pd
new file mode 100644
index 0000000..209df02
--- /dev/null
+++ b/help/tab16write-help.pd
@@ -0,0 +1,28 @@
+#N canvas 44 17 653 456 12;
+#X floatatom 39 96 0 0 0 0 - - -;
+#X floatatom 176 170 0 0 0 0 - - -;
+#X text 208 192 creation argument;
+#X text 210 210 is array name;
+#X text 76 87 set y value;
+#X text 74 152 right inlet selects x value;
+#X msg 55 117 set array99;
+#X text 163 116 change array name;
+#X obj 39 195 tab16write array99;
+#X obj 31 27 tab16write;
+#X text 388 378 updated for iem16 version1.0;
+#X obj 17 355 tab16write~;
+#X obj 17 374 tab16read4~;
+#X obj 121 374 tab16read;
+#X obj 121 355 tab16write;
+#X obj 216 355 tab16send~;
+#X obj 216 374 tab16receive~;
+#X obj 340 360 table16;
+#X text 29 334 see also:;
+#X obj 438 156 table16 array99;
+#X text 133 28 write numbers to a 16bit-table;
+#X text 20 256 since [table16] can only hold 16bit-values \, the stored
+numbers have to be integer (ok \, we take care of this!) values between
+-32768..+32767.;
+#X connect 0 0 8 0;
+#X connect 1 0 8 1;
+#X connect 6 0 8 0;
diff --git a/help/tab16write~-help.pd b/help/tab16write~-help.pd
new file mode 100644
index 0000000..0904d65
--- /dev/null
+++ b/help/tab16write~-help.pd
@@ -0,0 +1,32 @@
+#N canvas 119 134 697 433 10;
+#X msg 43 131 bang;
+#X obj 23 82 sig~ 3000;
+#X obj 23 110 phasor~;
+#X text 158 213 creation argument initializes array name;
+#X msg 40 181 set array99;
+#X msg 445 35 \; pd dsp 1;
+#X msg 524 37 \; pd dsp 0;
+#X text 85 133 bang to start recording;
+#X text 126 180 set the destination array;
+#X msg 43 153 stop;
+#X text 85 154 stop recording;
+#X text 385 366 updated for iem16 version1.0;
+#X obj 14 343 tab16write~;
+#X obj 14 362 tab16read4~;
+#X obj 118 362 tab16read;
+#X obj 118 343 tab16write;
+#X obj 213 343 tab16send~;
+#X obj 213 362 tab16receive~;
+#X obj 337 348 table16;
+#X text 26 322 see also:;
+#X obj 22 211 tab16write~ array99;
+#X obj 492 160 table16 array99;
+#X obj 31 27 tab16write~;
+#X text 120 27 object to write a 16bit-signal in an array;
+#X text 261 261 since [table16] can only hold 16bit-values \, the incoming
+signal (-1.0..+1.0) is stored as integer values -32768..+32767;
+#X connect 0 0 20 0;
+#X connect 1 0 2 0;
+#X connect 2 0 20 0;
+#X connect 4 0 20 0;
+#X connect 9 0 20 0;
diff --git a/help/table16-help.pd b/help/table16-help.pd
new file mode 100644
index 0000000..50e6ccb
--- /dev/null
+++ b/help/table16-help.pd
@@ -0,0 +1,60 @@
+#N canvas 37 0 856 640 10;
+#X obj 30 21 table16;
+#X text 97 22 16bit-table;
+#X text 32 51 [table16] stores 16bit values. The normal pd-tables ([table]
+\, array) store the values as floating-points. While floating points
+are (often) more precise (this is of course not really true... \, esp.
+when comparing integer(4byte) to floating-point.) they use a lot of
+memory (4byte).;
+#X text 32 121 [table16] uses only 16bit (2bytes) to store the values
+\, which is half of the memory.;
+#X text 32 155 However there are 2 major drawbacks;
+#X text 53 172 a) less precision means less SNR - you can only store
+65536 different values \, but this is what CD-quality is (should be
+good enough for most musical applications);
+#X text 55 221 b) the 65536 values (-32678..+32767) are mapped to -1.0..+1.0!
+This means you cannot store signals that exceed this magical limit.
+Please make sure \, that the signal has correct values (use [clip~])
+or the unclipped values will get wrapped!;
+#X text 20 323 There are several objects to access the data of [table16]:
+;
+#X obj 55 344 tab16write~;
+#X obj 55 363 tab16read4~;
+#X obj 279 363 tab16read;
+#X obj 279 344 tab16write;
+#X obj 164 344 tab16send~;
+#X obj 164 363 tab16receive~;
+#X obj 55 382 tab16read~;
+#X text 19 410 The message-objects [tab16read]/[tab16write] store the
+values directly (-32767..+32768) \, while the signal-objects convert
+the floats -1.0..+1.0 to the correct values or vice-versa.;
+#X text 270 21 updated for iem16 version1.0;
+#X msg 496 53 resize 100;
+#X obj 496 308 table16 array16 99;
+#N canvas 0 0 450 300 graph6 0;
+#X array array100 10 float 1;
+#A 0 1 2 3 4 5 6 7 8 9 0;
+#X coords 0 10 9 0 200 140 1;
+#X restore 477 452 graph;
+#X msg 478 409 \; array100 0 1 2 3 4 5 6 7 8 9;
+#X text 481 389 click to init float-array;
+#X msg 502 114 from array100;
+#X text 21 497 There is no beautiful graphical representation as with
+pd's arrays.;
+#X msg 508 139 from array100 resize;
+#X msg 516 190 from array100 20 30;
+#X msg 517 213 from array100 20 30 resize;
+#X msg 527 259 from array100 20 30 95;
+#X msg 527 279 from array100 20 30 95 resize;
+#X text 502 95 copy the data from a float-array;
+#X text 603 117 and resize the 16bit-array;
+#X text 513 173 copy floats (index20..30);
+#X text 653 192 and resize to 30-20;
+#X text 526 241 copy indexed values and insert at index95;
+#X connect 17 0 18 0;
+#X connect 22 0 18 0;
+#X connect 24 0 18 0;
+#X connect 25 0 18 0;
+#X connect 26 0 18 0;
+#X connect 27 0 18 0;
+#X connect 28 0 18 0;
diff --git a/help/vd16~-help.pd b/help/vd16~-help.pd
new file mode 100644
index 0000000..cf59065
--- /dev/null
+++ b/help/vd16~-help.pd
@@ -0,0 +1,32 @@
+#N canvas 88 40 717 480 12;
+#X floatatom 50 254 0 0 0 0 - - -;
+#X obj 50 347 outlet~;
+#X text 130 346 signal output (delayed signal);
+#X obj 50 282 sig~;
+#X text 99 279 signal input (delay time in ms);
+#X text 218 310 creation argument: name of delay line;
+#X text 35 400 see also:;
+#X obj 24 16 vd16~;
+#X text 77 10 reads a signal from a 16bit delay line at a variable
+delay time (4-point-interpolation);
+#X text 31 51 vd16~ implements a 4-point interpolating delay tap from
+a corresponding delwrite~ object. The delay in milliseconds of the
+tap is specified by the incoming signal.;
+#X obj 50 314 vd16~ del_example;
+#X text 16 433 similar pd-objects:;
+#X obj 201 432 delread~;
+#X obj 285 432 delwrite~;
+#X obj 378 432 vd~;
+#X obj 123 403 del16write~;
+#X obj 242 403 del16read~;
+#X text 411 386 updated for iem16 version1.0;
+#X text 28 116 This is very similar to the pd-object;
+#X text 56 137 It uses only 16bit to store the samples \, which will
+need only half of the memory of pd's floatingpoint-based object.;
+#X text 57 175 However \, there are 2 drawbacks: there will be some
+additional noise (because floats are more precise than 16bit) \, and
+you cannot have values>1 stored in the delay-line;
+#X obj 375 112 vd~;
+#X connect 0 0 3 0;
+#X connect 3 0 10 0;
+#X connect 10 0 1 0;