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