1 /*
2 dumpf.c:
3
4 Copyright (C) 1991 Barry Vercoe, John ffitch
5
6 This file is part of Csound.
7
8 The Csound Library is free software; you can redistribute it
9 and/or modify it under the terms of the GNU Lesser General Public
10 License as published by the Free Software Foundation; either
11 version 2.1 of the License, or (at your option) any later version.
12
13 Csound 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 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public
19 License along with Csound; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21 02110-1301 USA
22 */
23
24 #include "csoundCore.h" /* DUMPF.C */
25 #include "dumpf.h"
26 #include <ctype.h>
27 #include <inttypes.h>
28
29 static const int32_t dumpf_format_table[9] = {
30 0,
31 CSFTYPE_INTEGER_BINARY,
32 0,
33 0,
34 CSFTYPE_INTEGER_BINARY,
35 CSFTYPE_INTEGER_BINARY,
36 CSFTYPE_FLOATS_BINARY,
37 CSFTYPE_INTEGER_TEXT,
38 CSFTYPE_FLOATS_TEXT,
39 };
40
kdmpset_S(CSOUND * csound,KDUMP * p)41 int32_t kdmpset_S(CSOUND *csound, KDUMP *p) {
42 /* open in curdir or pathname */
43 char soundoname[1024];
44 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
45 return csound->InitError(csound, Str("unknown format request"));
46 }
47 if (UNLIKELY(p->format == 2 || p->format == 3)) {
48 return csound->InitError(csound,
49 Str("alaw and ulaw not implemented here"));
50 }
51 strNcpy(soundoname, ((STRINGDAT *)p->ifilcod)->data, 1023);
52 if (p->fdch.fd != NULL)
53 csound_fd_close(csound, &(p->fdch));
54 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundoname,
55 "wb", "", dumpf_format_table[p->format], 0);
56 if (UNLIKELY(p->fdch.fd == NULL))
57 return csound->InitError(csound, Str("Cannot open %s"), soundoname);
58 fdrecord(csound, &p->fdch);
59 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
60 p->timcount = 1;
61 p->countdown = p->timcount;
62 return OK;
63
64 }
65
66
kdmpset_p(CSOUND * csound,KDUMP * p)67 int32_t kdmpset_p(CSOUND *csound, KDUMP *p)
68 {
69 /* open in curdir or pathname */
70 char soundoname[1024];
71 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
72 return csound->InitError(csound, Str("unknown format request"));
73 }
74 if (UNLIKELY(p->format == 2 || p->format == 3)) {
75 return csound->InitError(csound,
76 Str("alaw and ulaw not implemented here"));
77 }
78 if (csound->ISSTRCOD(*p->ifilcod))
79 strNcpy(soundoname, get_arg_string(csound, *p->ifilcod), 1023);
80 else csound->strarg2name(csound, soundoname, p->ifilcod, "dumpk.", 0);
81 if (p->fdch.fd != NULL)
82 csound_fd_close(csound, &(p->fdch));
83 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundoname,
84 "wb", "", dumpf_format_table[p->format], 0);
85 if (UNLIKELY(p->fdch.fd == NULL))
86 return csound->InitError(csound, Str("Cannot open %s"), soundoname);
87 fdrecord(csound, &p->fdch);
88 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
89 p->timcount = 1;
90 p->countdown = p->timcount;
91 return OK;
92 }
93
kdmp2set_S(CSOUND * csound,KDUMP2 * p)94 int32_t kdmp2set_S(CSOUND *csound, KDUMP2 *p)
95 {
96 /* open in curdir or pathname */
97 char soundoname[1024];
98 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
99 return csound->InitError(csound, Str("unknown format request"));
100 }
101 if (UNLIKELY(p->format == 2 || p->format == 3)) {
102 return csound->InitError(csound,
103 Str("alaw and ulaw not implemented here"));
104 }
105 strNcpy(soundoname, ((STRINGDAT *)p->ifilcod)->data, 1023);
106 if (p->fdch.fd != NULL)
107 csound_fd_close(csound, &(p->fdch));
108 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundoname,
109 "wb", "", dumpf_format_table[p->format], 0);
110 if (UNLIKELY(p->fdch.fd == NULL))
111 return csound->InitError(csound, Str("Cannot open %s"), soundoname);
112 fdrecord(csound, &p->fdch);
113 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
114 p->timcount = 1;
115 p->countdown = p->timcount;
116 return OK;
117 }
118
119
kdmp2set_p(CSOUND * csound,KDUMP2 * p)120 int32_t kdmp2set_p(CSOUND *csound, KDUMP2 *p)
121 {
122 /* open in curdir or pathname */
123 char soundoname[1024];
124 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
125 return csound->InitError(csound, Str("unknown format request"));
126 }
127 if (UNLIKELY(p->format == 2 || p->format == 3)) {
128 return csound->InitError(csound,
129 Str("alaw and ulaw not implemented here"));
130 }
131 if (csound->ISSTRCOD(*p->ifilcod))
132 strNcpy(soundoname, get_arg_string(csound, *p->ifilcod), 1023);
133 else csound->strarg2name(csound, soundoname, p->ifilcod, "dumpk.", 0);
134 if (p->fdch.fd != NULL)
135 csound_fd_close(csound, &(p->fdch));
136 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundoname,
137 "wb", "", dumpf_format_table[p->format], 0);
138 if (UNLIKELY(p->fdch.fd == NULL))
139 return csound->InitError(csound, Str("Cannot open %s"), soundoname);
140 fdrecord(csound, &p->fdch);
141 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
142 p->timcount = 1;
143 p->countdown = p->timcount;
144 return OK;
145 }
146
147
kdmp3set_S(CSOUND * csound,KDUMP3 * p)148 int32_t kdmp3set_S(CSOUND *csound, KDUMP3 *p)
149 {
150 /* open in curdir or pathname */
151 char soundoname[1024];
152 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
153 return csound->InitError(csound, Str("unknown format request"));
154 }
155 if (UNLIKELY(p->format == 2 || p->format == 3)) {
156 return csound->InitError(csound,
157 Str("alaw and ulaw not implemented here"));
158 }
159 strNcpy(soundoname, ((STRINGDAT *)p->ifilcod)->data, 1023);
160 if (p->fdch.fd != NULL)
161 csound_fd_close(csound, &(p->fdch));
162 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundoname,
163 "wb", "", dumpf_format_table[p->format], 0);
164 if (UNLIKELY(p->fdch.fd == NULL))
165 return csound->InitError(csound, Str("Cannot open %s"), soundoname);
166 fdrecord(csound, &p->fdch);
167 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
168 p->timcount = 1;
169 p->countdown = p->timcount;
170 return OK;
171 }
172
173
174
kdmp3set_p(CSOUND * csound,KDUMP3 * p)175 int32_t kdmp3set_p(CSOUND *csound, KDUMP3 *p)
176 {
177 /* open in curdir or pathname */
178 char soundoname[1024];
179 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
180 return csound->InitError(csound, Str("unknown format request"));
181 }
182 if (UNLIKELY(p->format == 2 || p->format == 3)) {
183 return csound->InitError(csound,
184 Str("alaw and ulaw not implemented here"));
185 }
186 if (csound->ISSTRCOD(*p->ifilcod))
187 strNcpy(soundoname, get_arg_string(csound, *p->ifilcod), 1023);
188 else csound->strarg2name(csound, soundoname, p->ifilcod, "dumpk.", 0);
189 if (p->fdch.fd != NULL)
190 csound_fd_close(csound, &(p->fdch));
191 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundoname,
192 "wb", "", dumpf_format_table[p->format], 0);
193 if (UNLIKELY(p->fdch.fd == NULL))
194 return csound->InitError(csound, Str("Cannot open %s"), soundoname);
195 fdrecord(csound, &p->fdch);
196 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
197 p->timcount = 1;
198 p->countdown = p->timcount;
199 return OK;
200 }
201
kdmp4set_S(CSOUND * csound,KDUMP4 * p)202 int32_t kdmp4set_S(CSOUND *csound, KDUMP4 *p)
203 {
204 /* open in curdir or pathname */
205 char soundoname[1024];
206 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
207 return csound->InitError(csound, Str("unknown format request"));
208 }
209 if (UNLIKELY(p->format == 2 || p->format == 3)) {
210 return csound->InitError(csound,
211 Str("alaw and ulaw not implemented here"));
212 }
213 strNcpy(soundoname, ((STRINGDAT *)p->ifilcod)->data, 1023);
214 if (p->fdch.fd != NULL)
215 csound_fd_close(csound, &(p->fdch));
216 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundoname,
217 "wb", "", dumpf_format_table[p->format], 0);
218 if (p->fdch.fd == NULL)
219 return csound->InitError(csound, Str("Cannot open %s"), soundoname);
220 fdrecord(csound, &p->fdch);
221 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
222 p->timcount = 1;
223 p->countdown = p->timcount;
224 return OK;
225 }
226
kdmp4set_p(CSOUND * csound,KDUMP4 * p)227 int32_t kdmp4set_p(CSOUND *csound, KDUMP4 *p)
228 {
229 /* open in curdir or pathname */
230 char soundoname[1024];
231 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
232 return csound->InitError(csound, Str("unknown format request"));
233 }
234 if (UNLIKELY(p->format == 2 || p->format == 3)) {
235 return csound->InitError(csound,
236 Str("alaw and ulaw not implemented here"));
237 }
238 if (csound->ISSTRCOD(*p->ifilcod))
239 strNcpy(soundoname, get_arg_string(csound, *p->ifilcod), 1023);
240 else csound->strarg2name(csound, soundoname, p->ifilcod, "dumpk.", 0);
241 if (p->fdch.fd != NULL)
242 csound_fd_close(csound, &(p->fdch));
243 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundoname,
244 "wb", "", dumpf_format_table[p->format], 0);
245 if (p->fdch.fd == NULL)
246 return csound->InitError(csound, Str("Cannot open %s"), soundoname);
247 fdrecord(csound, &p->fdch);
248 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
249 p->timcount = 1;
250 p->countdown = p->timcount;
251 return OK;
252 }
253
nkdump(CSOUND * csound,MYFLT * kp,FILE * ofd,int32_t format,int32_t nk,void * p)254 static void nkdump(CSOUND *csound, MYFLT *kp, FILE *ofd, int32_t format,
255 int32_t nk, void *p)
256 {
257 char buf1[256], outbuf[256];
258 int32_t len = 0;
259
260 switch(format) { /* place formatted kvals into outbuf */
261 case 1: {
262 int8_t *bp = (int8_t*) outbuf;
263 len = nk;
264 while (nk--)
265 *bp++ = (int8_t) *kp++;
266 break;
267 }
268 case 4: {
269 int16_t *bp = (int16_t*) outbuf;
270 len = nk * 2;
271 while (nk--)
272 *bp++ = (int16_t) *kp++;
273 break;
274 }
275 case 5: {
276 int32_t *bp = (int32_t*) outbuf;
277 len = nk * 4;
278 while (nk--)
279 *bp++ = (int32_t) *kp++;
280 break;
281 }
282 case 6: {
283 float *bp = (float*) outbuf;
284 len = nk * sizeof(float);
285 while (nk--)
286 *bp++ = (float) *kp++;
287 break;
288 }
289 case 7:
290 outbuf[0] = '\0';
291 while (--nk) {
292 snprintf(buf1, 256, "%" PRId64 "\t", (int64_t)*kp++);
293 strlcat(outbuf, buf1, 256);
294 }
295 snprintf(buf1, 256, "%" PRId64 "\n", (int64_t)*kp);
296 strlcat(outbuf, buf1, 256);
297 len = strlen(outbuf);
298 break;
299 case 8: *outbuf = '\0';
300 while (--nk) {
301 CS_SPRINTF(buf1, "%6.4f\t", *kp++);
302 strlcat(outbuf, buf1, 256);
303 }
304 CS_SPRINTF(buf1, "%6.4f\n", *kp);
305 strlcat(outbuf, buf1, 256);
306 len = strlen(outbuf);
307 break;
308 default:
309 csound->PerfError(csound,&(((KDUMP *)p)->h),
310 Str("unknown kdump format"));
311 }
312 if (UNLIKELY(fwrite(outbuf, len, 1, ofd)!=1)) { /* now write the buffer */
313 csound->PerfError(csound, &(((KDUMP *)p)->h),
314 Str("write failure in dumpk"));
315 }
316 }
317
kdump(CSOUND * csound,KDUMP * p)318 int32_t kdump(CSOUND *csound, KDUMP *p)
319 {
320 MYFLT kval[4];
321
322 if (--p->countdown <= 0) {
323 p->countdown = p->timcount;
324 kval[0] = *p->ksig;
325 nkdump(csound, kval, p->f, p->format, 1, p);
326 }
327 return OK;
328 }
329
kdump2(CSOUND * csound,KDUMP2 * p)330 int32_t kdump2(CSOUND *csound, KDUMP2 *p)
331 {
332 MYFLT kval[4];
333
334 if (--p->countdown <= 0) {
335 p->countdown = p->timcount;
336 kval[0] = *p->ksig1;
337 kval[1] = *p->ksig2;
338 nkdump(csound, kval, p->f, p->format, 2, p);
339 }
340 return OK;
341 }
342
kdump3(CSOUND * csound,KDUMP3 * p)343 int32_t kdump3(CSOUND *csound, KDUMP3 *p)
344 {
345 MYFLT kval[4];
346
347 if (--p->countdown <= 0) {
348 p->countdown = p->timcount;
349 kval[0] = *p->ksig1;
350 kval[1] = *p->ksig2;
351 kval[2] = *p->ksig3;
352 nkdump(csound, kval, p->f, p->format, 3, p);
353 }
354 return OK;
355 }
356
kdump4(CSOUND * csound,KDUMP4 * p)357 int32_t kdump4(CSOUND *csound, KDUMP4 *p)
358 {
359 MYFLT kval[4];
360
361 if (--p->countdown <= 0) {
362 p->countdown = p->timcount;
363 kval[0] = *p->ksig1;
364 kval[1] = *p->ksig2;
365 kval[2] = *p->ksig3;
366 kval[3] = *p->ksig4;
367 nkdump(csound, kval, p->f, p->format, 4, p);
368 }
369 return OK;
370 }
371
372 /* ******************************************************************** */
373 /* ******** READK and friends; new code 1999 Feb 14 by JPff ******** */
374 /* ******************************************************************** */
375
krdset_p(CSOUND * csound,KREAD * p)376 int32_t krdset_p(CSOUND *csound, KREAD *p)
377 {
378 /* open in curdir or pathname */
379 char soundiname[1024];
380 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
381 return csound->InitError(csound, Str("unknown format request"));
382 }
383 if (UNLIKELY(p->format == 2 || p->format == 3)) {
384 return csound->InitError(csound,
385 Str("alaw and ulaw not implemented here"));
386 }
387 if (csound->ISSTRCOD(*p->ifilcod))
388 strNcpy(soundiname, get_arg_string(csound, *p->ifilcod), 1023);
389 else csound->strarg2name(csound, soundiname, p->ifilcod, "readk.", 0);
390 if (p->fdch.fd != NULL)
391 csound_fd_close(csound, &(p->fdch));
392 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
393 "SFDIR;SSDIR", dumpf_format_table[p->format], 0);
394 if (UNLIKELY(p->fdch.fd == NULL))
395 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
396 fdrecord(csound, &p->fdch);
397 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
398 p->timcount = 1;
399 p->countdown = 0;
400 p->k[0] = p->k[1] = p->k[2] = p->k[3] = FL(0.0);
401 return OK;
402 }
403
krdset_S(CSOUND * csound,KREAD * p)404 int32_t krdset_S(CSOUND *csound, KREAD *p)
405 {
406 /* open in curdir or pathname */
407 char soundiname[1024];
408 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
409 return csound->InitError(csound, Str("unknown format request"));
410 }
411 if (UNLIKELY(p->format == 2 || p->format == 3)) {
412 return csound->InitError(csound,
413 Str("alaw and ulaw not implemented here"));
414 }
415 strNcpy(soundiname, ((STRINGDAT *)p->ifilcod)->data, 1023);
416 if (p->fdch.fd != NULL)
417 csound_fd_close(csound, &(p->fdch));
418 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
419 "SFDIR;SSDIR", dumpf_format_table[p->format], 0);
420 if (UNLIKELY(p->fdch.fd == NULL))
421 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
422 fdrecord(csound, &p->fdch);
423 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
424 p->timcount = 1;
425 p->countdown = 0;
426 p->k[0] = p->k[1] = p->k[2] = p->k[3] = FL(0.0);
427 return OK;
428 }
429
krd2set_S(CSOUND * csound,KREAD2 * p)430 int32_t krd2set_S(CSOUND *csound, KREAD2 *p)
431 {
432 /* open in curdir or pathname */
433 char soundiname[1024];
434 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
435 return csound->InitError(csound, Str("unknown format request"));
436 }
437 if (UNLIKELY(p->format == 2 || p->format == 3)) {
438 return csound->InitError(csound,
439 Str("alaw and ulaw not implemented here"));
440 }
441 strNcpy(soundiname, ((STRINGDAT *)p->ifilcod)->data, 1023);
442 if (p->fdch.fd != NULL)
443 csound_fd_close(csound, &(p->fdch));
444 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
445 "SFDIR;SSDIR", dumpf_format_table[p->format], 0);
446 if (UNLIKELY(p->fdch.fd == NULL))
447 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
448 fdrecord(csound, &p->fdch);
449 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
450 p->timcount = 1;
451 p->countdown = 0;
452 p->k[0] = p->k[1] = p->k[2] = p->k[3] = FL(0.0);
453 return OK;
454 }
455
krd2set_p(CSOUND * csound,KREAD2 * p)456 int32_t krd2set_p(CSOUND *csound, KREAD2 *p)
457 {
458 /* open in curdir or pathname */
459 char soundiname[1024];
460 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
461 return csound->InitError(csound, Str("unknown format request"));
462 }
463 if (UNLIKELY(p->format == 2 || p->format == 3)) {
464 return csound->InitError(csound,
465 Str("alaw and ulaw not implemented here"));
466 }
467 if (csound->ISSTRCOD(*p->ifilcod))
468 strNcpy(soundiname, get_arg_string(csound, *p->ifilcod), 1023);
469 else csound->strarg2name(csound, soundiname, p->ifilcod, "readk.", 0);
470 if (p->fdch.fd != NULL)
471 csound_fd_close(csound, &(p->fdch));
472 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
473 "SFDIR;SSDIR", dumpf_format_table[p->format], 0);
474 if (UNLIKELY(p->fdch.fd == NULL))
475 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
476 fdrecord(csound, &p->fdch);
477 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
478 p->timcount = 1;
479 p->countdown = 0;
480 p->k[0] = p->k[1] = p->k[2] = p->k[3] = FL(0.0);
481 return OK;
482 }
483
krd3set_S(CSOUND * csound,KREAD3 * p)484 int32_t krd3set_S(CSOUND *csound, KREAD3 *p)
485 {
486 /* open in curdir or pathname */
487 char soundiname[1024];
488 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
489 return csound->InitError(csound, Str("unknown format request"));
490 }
491 if (UNLIKELY(p->format == 2 || p->format == 3)) {
492 return csound->InitError(csound,
493 Str("alaw and ulaw not implemented here"));
494 }
495 strNcpy(soundiname, ((STRINGDAT *)p->ifilcod)->data, 1023);
496 if (p->fdch.fd != NULL)
497 csound_fd_close(csound, &(p->fdch));
498 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
499 "SFDIR;SSDIR", dumpf_format_table[p->format], 0);
500 if (UNLIKELY(p->fdch.fd == NULL))
501 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
502 fdrecord(csound, &p->fdch);
503 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
504 p->timcount = 1;
505 p->countdown = 0;
506 p->k[0] = p->k[1] = p->k[2] = p->k[3] = FL(0.0);
507 return OK;
508 }
509
krd3set_p(CSOUND * csound,KREAD3 * p)510 int32_t krd3set_p(CSOUND *csound, KREAD3 *p)
511 {
512 /* open in curdir or pathname */
513 char soundiname[1024];
514 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
515 return csound->InitError(csound, Str("unknown format request"));
516 }
517 if (UNLIKELY(p->format == 2 || p->format == 3)) {
518 return csound->InitError(csound,
519 Str("alaw and ulaw not implemented here"));
520 }
521 if (csound->ISSTRCOD(*p->ifilcod))
522 strNcpy(soundiname, get_arg_string(csound, *p->ifilcod), 1023);
523 else csound->strarg2name(csound, soundiname, p->ifilcod, "readk.", 0);
524 if (p->fdch.fd != NULL)
525 csound_fd_close(csound, &(p->fdch));
526 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
527 "SFDIR;SSDIR", dumpf_format_table[p->format], 0);
528 if (UNLIKELY(p->fdch.fd == NULL))
529 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
530 fdrecord(csound, &p->fdch);
531 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
532 p->timcount = 1;
533 p->countdown = 0;
534 p->k[0] = p->k[1] = p->k[2] = p->k[3] = FL(0.0);
535 return OK;
536 }
537
krd4set_S(CSOUND * csound,KREAD4 * p)538 int32_t krd4set_S(CSOUND *csound, KREAD4 *p)
539 {
540 /* open in curdir or pathname */
541 char soundiname[1024];
542 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
543 return csound->InitError(csound, Str("unknown format request"));
544 }
545 if (UNLIKELY(p->format == 2 || p->format == 3)) {
546 return csound->InitError(csound,
547 Str("alaw and ulaw not implemented here"));
548 }
549 strNcpy(soundiname, ((STRINGDAT *)p->ifilcod)->data, 1023);
550 if (p->fdch.fd != NULL)
551 csound_fd_close(csound, &(p->fdch));
552 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
553 "SFDIR;SSDIR", dumpf_format_table[p->format], 0);
554 if (UNLIKELY(p->fdch.fd == NULL))
555 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
556 fdrecord(csound, &p->fdch);
557 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
558 p->timcount = 1;
559 p->countdown = 0;
560 p->k[0] = p->k[1] = p->k[2] = p->k[3] = FL(0.0);
561 return OK;
562 }
563
krd4set_p(CSOUND * csound,KREAD4 * p)564 int32_t krd4set_p(CSOUND *csound, KREAD4 *p)
565 {
566 /* open in curdir or pathname */
567 char soundiname[1024];
568 if (UNLIKELY((p->format = (int32_t)*p->iformat) < 1 || p->format > 8)) {
569 return csound->InitError(csound, Str("unknown format request"));
570 }
571 if (UNLIKELY(p->format == 2 || p->format == 3)) {
572 return csound->InitError(csound,
573 Str("alaw and ulaw not implemented here"));
574 }
575 if (csound->ISSTRCOD(*p->ifilcod))
576 strNcpy(soundiname, get_arg_string(csound, *p->ifilcod), 1023);
577 else csound->strarg2name(csound, soundiname, p->ifilcod, "readk.", 0);
578 if (p->fdch.fd != NULL)
579 csound_fd_close(csound, &(p->fdch));
580 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
581 "SFDIR;SSDIR", dumpf_format_table[p->format], 0);
582 if (UNLIKELY(p->fdch.fd == NULL))
583 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
584 fdrecord(csound, &p->fdch);
585 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
586 p->timcount = 1;
587 p->countdown = 0;
588 p->k[0] = p->k[1] = p->k[2] = p->k[3] = FL(0.0);
589 return OK;
590 }
591
592
nkread(CSOUND * csound,MYFLT * kp,FILE * ifd,int32_t format,int32_t nk)593 static void nkread(CSOUND *csound, MYFLT *kp, FILE *ifd, int32_t format, int32_t nk)
594 {
595 int32_t len;
596 char inbuf[256];
597
598 switch(format) { /* place formatted kvals into outbuf */
599 case 1: {
600 int8_t *bp = (int8_t*)inbuf;
601 len = nk;
602 len = fread(inbuf, 1, len, ifd); /* now read the buffer */
603 while (nk--)
604 *kp++ = (MYFLT)*bp++;
605 break;
606 }
607 case 4: {
608 int16_t *bp = (int16_t*)inbuf;
609 len = nk * 2;
610 len = fread(inbuf, 1, len, ifd); /* now read the buffer */
611 while (nk--)
612 *kp++ = (MYFLT)*bp++;
613 break;
614 }
615 case 5: {
616 int32_t *bp = (int32_t*)inbuf;
617 len = nk * 4;
618 len = fread(inbuf, 1, len, ifd); /* now read the buffer */
619 while (nk--)
620 *kp++ = (MYFLT)*bp++;
621 break;
622 }
623 case 6: {
624 float *bp = (float*)inbuf;
625 len = nk * sizeof(float);
626 len = fread(inbuf, 1, len, ifd); /* now read the buffer */
627 while (nk--)
628 *kp++ = (MYFLT)*bp++;
629 break;
630 }
631 case 7:
632 while (nk--) {
633 char *bp = inbuf;
634 do { /* Skip whitespace */
635 *bp = (char)getc(ifd);
636 } while (isspace(*bp));
637 do { /* Absorb digits */
638 *(++bp) = (char)getc(ifd);
639 } while (isdigit(*bp) ||
640 *bp=='-' || *bp=='+' || *bp=='.' || *bp=='e' ||*bp=='E');
641 ungetc(*bp, ifd); //fseek(ifd, -1L, SEEK_CUR);
642 *bp = '\0';
643 #ifndef USE_DOUBLE
644 CS_SSCANF(inbuf,"%f", kp);
645 #else
646 CS_SSCANF(inbuf,"%lf", kp);
647 #endif
648 kp++;
649 }
650 break;
651 case 8:
652 while (nk--) {
653 char *bp = inbuf;
654 do { /* Skip whitespace */
655 *bp = (char)getc(ifd);
656 } while (isspace(*bp));
657 do { /* Absorb digits and such*/
658 *(++bp) = (char)getc(ifd);
659 } while (!isspace(*bp));
660 (void)ungetc(*bp, ifd); //fseek(ifd, -1L, SEEK_CUR);
661 *bp = '\0';
662 #ifndef USE_DOUBLE
663 CS_SSCANF(inbuf,"%f", kp);
664 #else
665 CS_SSCANF(inbuf,"%lf", kp);
666 #endif
667 kp++;
668 }
669 break;
670 default: csound->Warning(csound,Str("unknown kdump format"));
671 }
672 }
673
kread(CSOUND * csound,KREAD * p)674 int32_t kread(CSOUND *csound, KREAD *p)
675 {
676 MYFLT kval[4];
677
678 if (--p->countdown <= 0) {
679 p->countdown = p->timcount;
680 nkread(csound, kval, p->f, p->format, 1);
681 *p->k1 = p->k[0] = kval[0];
682 }
683 else *p->k1 = p->k[0];
684 return OK;
685 }
686
kread2(CSOUND * csound,KREAD2 * p)687 int32_t kread2(CSOUND *csound, KREAD2 *p)
688 {
689 MYFLT kval[4];
690
691 if (--p->countdown <= 0) {
692 p->countdown = p->timcount;
693 nkread(csound, kval, p->f, p->format, 2);
694 *p->k1 = p->k[0] = kval[0];
695 *p->k2 = p->k[1] = kval[1];
696 }
697 else {
698 *p->k1 = p->k[0];
699 *p->k2 = p->k[1];
700 }
701 return OK;
702 }
703
kread3(CSOUND * csound,KREAD3 * p)704 int32_t kread3(CSOUND *csound, KREAD3 *p)
705 {
706 MYFLT kval[4];
707
708 if (--p->countdown <= 0) {
709 p->countdown = p->timcount;
710 nkread(csound, kval, p->f, p->format, 3);
711 *p->k1 = p->k[0] = kval[0];
712 *p->k2 = p->k[1] = kval[1];
713 *p->k3 = p->k[2] = kval[2];
714 }
715 else {
716 *p->k1 = p->k[0];
717 *p->k2 = p->k[1];
718 *p->k3 = p->k[2];
719 }
720 return OK;
721 }
722
kread4(CSOUND * csound,KREAD4 * p)723 int32_t kread4(CSOUND *csound, KREAD4 *p)
724 {
725 MYFLT kval[4];
726
727 if (--p->countdown <= 0) {
728 p->countdown = p->timcount;
729 nkread(csound, kval, p->f, p->format, 4);
730 *p->k1 = p->k[0] = kval[0];
731 *p->k2 = p->k[1] = kval[1];
732 *p->k3 = p->k[2] = kval[2];
733 *p->k4 = p->k[3] = kval[3];
734 }
735 else {
736 *p->k1 = p->k[0];
737 *p->k2 = p->k[1];
738 *p->k3 = p->k[2];
739 *p->k4 = p->k[3];
740 }
741 return OK;
742 }
743
744 #define INITSIZE 1024
745
krdsset_S(CSOUND * csound,KREADS * p)746 int32_t krdsset_S(CSOUND *csound, KREADS *p)
747 {
748 /* open in curdir or pathname */
749 char soundiname[1024];
750 strNcpy(soundiname, ((STRINGDAT *)p->ifilcod)->data, 1023);
751 if (p->fdch.fd != NULL)
752 csound_fd_close(csound, &(p->fdch));
753 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
754 "SFDIR;SSDIR", 0, 0);
755 if (UNLIKELY(p->fdch.fd == NULL))
756 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
757 fdrecord(csound, &p->fdch);
758 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
759 p->timcount = 1;
760 p->countdown = 0;
761 p->lasts = (char*)csound->Calloc(csound, INITSIZE);
762 p->lasts[0] = '\0';
763 if (p->str->data == NULL) {
764 p->str->data = csound->Calloc(csound, INITSIZE);
765 p->str->size = INITSIZE;
766 }
767 return OK;
768 }
769
770
krdsset_p(CSOUND * csound,KREADS * p)771 int32_t krdsset_p(CSOUND *csound, KREADS *p)
772 {
773 /* open in curdir or pathname */
774 char soundiname[1024];
775 if (csound->ISSTRCOD(*p->ifilcod))
776 strNcpy(soundiname, get_arg_string(csound, *p->ifilcod), 1023);
777 else csound->strarg2name(csound, soundiname, p->ifilcod, "readk.", 0);
778 if (p->fdch.fd != NULL)
779 csound_fd_close(csound, &(p->fdch));
780 p->fdch.fd = csound->FileOpen2(csound, &(p->f), CSFILE_STD, soundiname, "rb",
781 "SFDIR;SSDIR", 0, 0);
782 if (UNLIKELY(p->fdch.fd == NULL))
783 return csound->InitError(csound, Str("Cannot open %s"), soundiname);
784 fdrecord(csound, &p->fdch);
785 if ((p->timcount = (int32_t)(*p->iprd * CS_EKR)) <= 0)
786 p->timcount = 1;
787 p->countdown = 0;
788 p->lasts = (char*)csound->Malloc(csound, INITSIZE);
789 p->lasts[0] = '\0';
790 if (p->str->data == NULL) {
791 p->str->data = csound->Calloc(csound, INITSIZE);
792 p->str->size = INITSIZE;
793 }
794 return OK;
795 }
796
797
kreads(CSOUND * csound,KREADS * p)798 int32_t kreads(CSOUND *csound, KREADS *p)
799 {
800 if (--p->countdown <= 0) {
801 p->countdown = p->timcount;
802 if (UNLIKELY(fgets(p->lasts, INITSIZE-1, p->f)==NULL)) {
803 csound->PerfError(csound, &(p->h), Str("Read failure in readks"));
804 }
805 }
806 strNcpy((char*) p->str->data, p->lasts, INITSIZE);
807 return OK;
808 }
809