static int osc_send_set(CSOUND *csound, OSCSEND *p)
{
char port[8];
char *pp = port;
char *hh;
//unsigned int i;
/* with too many args, XINCODE may not work correctly */
if (UNLIKELY(p->INOCOUNT > 31))
return csound->InitError(csound, Str("Too many arguments to OSCsend"));
/* a-rate arguments are not allowed */
/* for (i = 0; i < p->INOCOUNT-5; i++) { */
/* if (strcmp("a", csound->GetTypeForArg(p->arg[i])->varTypeName) == 0) { */
/* return csound->InitError(csound, Str("No a-rate arguments allowed")); */
/* } */
/* } */
if (*p->port<0)
pp = NULL;
else
snprintf(port, 8, "%d", (int) MYFLT2LRND(*p->port));
hh = (char*) p->host->data;
if (*hh=='\0') hh = NULL;
p->addr = lo_address_new(hh, pp);
p->cnt = 0;
p->last = 0;
csound->RegisterDeinitCallback(csound, p,
(int (*)(CSOUND *, void *)) oscsend_deinit);
return OK;
}
static int osc_send_set(CSOUND *csound, OSCSEND *p)
{
char port[8];
char *pp = port;
char *hh;
/* with too many args, XINCODE may not work correctly */
if (UNLIKELY(p->INOCOUNT > 31))
return csound->InitError(csound, Str("Too many arguments to OSCsend"));
/* a-rate arguments are not allowed */
if (UNLIKELY(p->XINCODE))
return csound->InitError(csound, Str("No a-rate arguments allowed"));
if (*p->port<0)
pp = NULL;
else
snprintf(port, 8, "%d", (int) MYFLT2LRND(*p->port));
hh = (char*) p->host->data;
if (*hh=='\0') hh = NULL;
p->addr = lo_address_new(hh, pp);
p->cnt = 0;
p->last = 0;
csound->RegisterDeinitCallback(csound, p,
(int (*)(CSOUND *, void *)) oscsend_deinit);
return OK;
}
void array_free_var_mem(void* csnd, void* p) {
CSOUND* csound = (CSOUND*)csnd;
ARRAYDAT* dat = (ARRAYDAT*)p;
if(dat->data != NULL) {
CS_TYPE* arrayType = dat->arrayType;
if (arrayType->freeVariableMemory != NULL) {
MYFLT* mem = dat->data;
size_t memMyfltSize = dat->arrayMemberSize / sizeof(MYFLT);
int i, size = dat->sizes[0];
for (i = 1; i < dat->dimensions; i++) {
size *= dat->sizes[i];
}
size = MYFLT2LRND(size);
for (i = 0; i < size; i++) {
arrayType->freeVariableMemory(csound,
dat->data + (i * memMyfltSize));
}
}
csound->Free(csound, dat->data);
}
if(dat->sizes != NULL) {
csound->Free(csound, dat->sizes);
}
}
static int pan2set(CSOUND *csound, PAN2 *p)
{
int type = p->type = MYFLT2LRND(*p->itype);
if (UNLIKELY(type <0 || type > 3))
return csound->InitError(csound, Str("Unknown panning type"));
return OK;
}
int32_t pvreadset_(CSOUND *csound, PVREAD *p, int32_t stringname)
{
char pvfilnam[256];
if (stringname==0){
if (csound->ISSTRCOD(*p->ifilno))
strNcpy(pvfilnam,get_arg_string(csound, *p->ifilno), MAXNAME);
else csound->strarg2name(csound, pvfilnam, p->ifilno, "pvoc.",0);
}
else strNcpy(pvfilnam, ((STRINGDAT *)p->ifilno)->data, MAXNAME);
if (pvocex_loadfile(csound, pvfilnam, p) == OK) {
p->prFlg = 1;
p->mybin = MYFLT2LRND(*p->ibin);
return OK;
}
return NOTOK;
}
void sfopenout(CSOUND *csound) /* init for sound out */
{ /* (not called if nosound) */
OPARMS *O = csound->oparms;
char *s, *fName, *fullName;
SF_INFO sfinfo;
int osfd = 1; /* stdout */
alloc_globals(csound);
if (O->outfilename == NULL) {
switch (O->filetyp) {
case TYP_WAV:
case TYP_W64:
case TYP_WAVEX:
case TYP_RF64:
O->outfilename = "test.wav";
break;
case TYP_AIFF:
O->outfilename = "test.aif";
break;
case TYP_AU:
O->outfilename = "test.au";
break;
case TYP_PAF:
O->outfilename = "test.paf";
break;
case TYP_SVX:
O->outfilename = "test.svx";
break;
case TYP_NIST:
O->outfilename = "test.sph";
break;
case TYP_VOC:
O->outfilename = "test.voc";
break;
/* case TYP_IRCAM: */
/* O->outfilename = ""; */
/* break; */
/* case TYP_MAT4: */
/* O->outfilename = ""; */
/* break; */
/* case TYP_MAT5: */
/* O->outfilename = ""; */
/* break; */
/* case TYP_PVF: */
/* O->outfilename = ""; */
/* break; */
case TYP_XI:
O->outfilename = "test.xi";
break;
/* case TYP_HTK: */
/* O->outfilename = ""; */
/* break; */
/* case TYP_SDS: */
/* O->outfilename = "test.sds"; */
/* break; */
case TYP_AVR:
O->outfilename = "test.avr";
break;
case TYP_SD2:
O->outfilename = "test.sd2";
break;
case TYP_FLAC:
O->outfilename = "test.flac";
break;
case TYP_CAF:
O->outfilename = "test.caf";
break;
case TYP_OGG:
O->outfilename = "test.ogg";
break;
/* case TYP_MPC2K: */
/* O->outfilename = ""; */
/* break; */
default:
O->outfilename = "test";
break;
}
}
STA(sfoutname) = fName = O->outfilename;
if (strcmp(fName, "stdout") == 0) {
STA(pipdevout) = 1;
}
#ifdef PIPES
else if (fName[0] == '|') {
STA(pout) = _popen(fName+1, "w");
osfd = fileno(STA(pout));
STA(pipdevout) = 1;
if (O->filetyp == TYP_AIFF || O->filetyp == TYP_WAV) {
char fmt_name[6];
if (O->sfsampsize == 8) {
strcpy(fmt_name, "AU");
O->filetyp = TYP_AU;
}
else {
strcpy(fmt_name, "IRCAM");
O->filetyp = TYP_IRCAM;
}
csound->Message(csound, Str("Output file type changed to %s "
"for use in pipe\n"), fmt_name);
}
}
#endif
else {
csRtAudioParams parm;
/* check for real time audio output, and get device name/number */
parm.devNum = check_rtaudio_name(fName, &(parm.devName), 1);
if (parm.devNum >= 0) {
/* set device parameters */
parm.bufSamp_SW = (unsigned int) O->outbufsamps / csound->nchnls;
parm.bufSamp_HW = O->oMaxLag;
parm.nChannels = csound->nchnls;
parm.sampleFormat = O->outformat;
parm.sampleRate = (float) csound->esr;
csound->spoutran = spoutsf;
/* open devaudio for output */
if (UNLIKELY(csound->playopen_callback(csound, &parm) != 0))
csoundDie(csound, Str("Failed to initialise real time audio output"));
/* & redirect audio puts */
csound->audtran = csound->rtplay_callback;
STA(outbufrem) = parm.bufSamp_SW * parm.nChannels;
STA(pipdevout) = 2; /* no backward seeks ! */
if (O->realtime == 1) /* set realtime priority mode */
csound->realtime_audio_flag = 1;
goto outset; /* no header needed */
}
else if (strcmp(fName, "null") == 0) {
STA(outfile) = NULL;
if (csound->dither_output && csound->oparms->outformat!=AE_FLOAT &&
csound->oparms->outformat!=AE_DOUBLE) {
if (csound->oparms->outformat==AE_SHORT)
if (csound->dither_output==1)
csound->audtran = writesf_dither_16;
else
csound->audtran = writesf_dither_u16;
else if (csound->oparms->outformat==AE_CHAR)
if (csound->dither_output==1)
csound->audtran = writesf_dither_8;
else
csound->audtran = writesf_dither_u8;
else
csound->audtran = writesf;
}
else
csound->audtran = writesf;
goto outset;
}
}
/* set format parameters */
memset(&sfinfo, 0, sizeof(SF_INFO));
//sfinfo.frames = 0;
sfinfo.samplerate = (int) MYFLT2LRND(csound->esr);
sfinfo.channels = csound->nchnls;
sfinfo.format = TYPE2SF(O->filetyp) | FORMAT2SF(O->outformat);
/* open file */
if (STA(pipdevout)) {
STA(outfile) = sf_open_fd(osfd, SFM_WRITE, &sfinfo, 0);
#ifdef PIPES
if (STA(outfile) == NULL) {
char fmt_name[6];
if (O->sfsampsize == 8) {
if (UNLIKELY(O->filetyp == TYP_AU))
csoundDie(csound, Str("sfinit: cannot open fd %d\n%s"), osfd,
Str(sf_strerror(NULL)));
strcpy(fmt_name, "AU");
O->filetyp = TYP_AU;
}
else {
if (UNLIKELY(O->filetyp == TYP_IRCAM))
csoundDie(csound, Str("sfinit: cannot open fd %d\n%s"), osfd,
Str(sf_strerror(NULL)));
strcpy(fmt_name, "IRCAM");
O->filetyp = TYP_IRCAM;
}
csound->Message(csound, Str("Output file type changed to %s "
"for use in pipe\n"), fmt_name);
sfinfo.format = TYPE2SF(O->filetyp) | FORMAT2SF(O->outformat);
STA(outfile) = sf_open_fd(osfd, SFM_WRITE, &sfinfo, 0);
}
#endif
if (UNLIKELY(STA(outfile) == NULL))
csoundDie(csound, Str("sfinit: cannot open fd %d\n%s"), osfd,
Str(sf_strerror(NULL)));
sf_command(STA(outfile), SFC_SET_VBR_ENCODING_QUALITY,
&O->quality, sizeof(double));
}
else {
fullName = csoundFindOutputFile(csound, fName, "SFDIR");
if (UNLIKELY(fullName == NULL))
csoundDie(csound, Str("sfinit: cannot open %s"), fName);
STA(sfoutname) = fullName;
STA(outfile) = sf_open(fullName, SFM_WRITE, &sfinfo);
if (UNLIKELY(STA(outfile) == NULL))
csoundDie(csound, Str("sfinit: cannot open %s\n%s"),
fullName, sf_strerror (NULL));
sf_command(STA(outfile), SFC_SET_VBR_ENCODING_QUALITY,
&O->quality, sizeof(double));
/* only notify the host if we opened a real file, not stdout or a pipe */
csoundNotifyFileOpened(csound, fullName,
type2csfiletype(O->filetyp, O->outformat), 1, 0);
}
/* IV - Feb 22 2005: clip integer formats */
if (O->outformat != AE_FLOAT && O->outformat != AE_DOUBLE)
sf_command(STA(outfile), SFC_SET_CLIPPING, NULL, SF_TRUE);
sf_command(STA(outfile), SFC_SET_ADD_PEAK_CHUNK,
NULL, (csound->peakchunks ? SF_TRUE : SF_FALSE));
#ifdef SOME_FINE_DAY
if (csound->dither_output) { /* This may not be written yet!! */
SF_DITHER_INFO ditherInfo;
memset(&ditherInfo, 0, sizeof(SF_DITHER_INFO));
ditherInfo.type = SFD_TRIANGULAR_PDF | SFD_DEFAULT_LEVEL;
ditherInfo.level = 1.0;
ditherInfo.name = (char*) NULL;
sf_command(STA(outfile), SFC_SET_DITHER_ON_WRITE,
&ditherInfo, sizeof(SF_DITHER_INFO));
}
#endif
if (!(O->outformat == AE_FLOAT || O->outformat == AE_DOUBLE) ||
(O->filetyp == TYP_WAV || O->filetyp == TYP_AIFF ||
O->filetyp == TYP_W64))
csound->spoutran = spoutsf; /* accumulate output */
else
csound->spoutran = spoutsf_noscale;
if (csound->dither_output && csound->oparms->outformat!=AE_FLOAT &&
csound->oparms->outformat!=AE_DOUBLE) {
if (csound->oparms->outformat==AE_SHORT)
csound->audtran = writesf_dither_16;
else if (csound->oparms->outformat==AE_CHAR)
csound->audtran = writesf_dither_8;
else
csound->audtran = writesf;
}
else
csound->audtran = writesf;
/* Write any tags. */
if ((s = csound->SF_id_title) != NULL && *s != '\0')
sf_set_string(STA(outfile), SF_STR_TITLE, s);
if ((s = csound->SF_csd_licence) == NULL || *s == '\0')
s = csound->SF_id_copyright;
if (s != NULL && *s != '\0')
sf_set_string(STA(outfile), SF_STR_COPYRIGHT, s);
else if (csound->SF_id_scopyright>=0) {
char buff[256];
time_t tt = time(NULL);
strftime(buff, 256, "Copyright %Y: ", gmtime(&tt));
strncat(buff,copyrightcode(csound->SF_id_scopyright), 255);
buff[255] = '\0';
sf_set_string(STA(outfile), SF_STR_COPYRIGHT, buff);
}
if ((s = csound->SF_id_software) != NULL && *s != '\0')
sf_set_string(STA(outfile), SF_STR_SOFTWARE, s);
if ((s = csound->SF_id_artist) != NULL && *s != '\0')
sf_set_string(STA(outfile), SF_STR_ARTIST, s);
if ((s = csound->SF_id_comment) != NULL && *s != '\0')
sf_set_string(STA(outfile), SF_STR_COMMENT, s);
if ((s = csound->SF_id_date) != NULL && *s != '\0')
sf_set_string(STA(outfile), SF_STR_DATE, s);
/* file is now open */
STA(osfopen) = 1;
outset:
O->sfsampsize = (int) sfsampsize(FORMAT2SF(O->outformat));
/* calc outbuf size & alloc bufspace */
STA(outbufsiz) = O->outbufsamps * sizeof(MYFLT);
STA(outbufp) = STA(outbuf) = csound->Malloc(csound, STA(outbufsiz));
if (STA(pipdevout) == 2)
csound->Message(csound,
Str("writing %d sample blks of %lu-bit floats to %s\n"),
O->outbufsamps, (unsigned long) sizeof(MYFLT)*8,
STA(sfoutname));
else {
csound->Message(csound, Str("writing %d-byte blks of %s to %s"),
O->outbufsamps * O->sfsampsize,
getstrformat(O->outformat), STA(sfoutname));
if (O->sfheader == 0)
csound->Message(csound, Str(" (raw)\n"));
else
csound->Message(csound, " (%s)\n", type2string(O->filetyp));
}
STA(osfopen) = 1;
STA(outbufrem) = O->outbufsamps;
}
void sfopenin(CSOUND *csound) /* init for continuous soundin */
{
OPARMS *O = csound->oparms;
char *sfname, *fullName;
SF_INFO sfinfo;
int fileType = (int) TYP_RAW;
int isfd = 0; /* stdin */
alloc_globals(csound);
STA(inbufrem) = (uint32) 0; /* start with empty buffer */
sfname = O->infilename;
if (UNLIKELY(sfname == NULL || sfname[0] == '\0'))
csound->Die(csound, Str("error: no input file name"));
if (strcmp(sfname, "stdin") == 0) {
STA(pipdevin) = 1;
}
#ifdef PIPES
else if (sfname[0] == '|') {
STA(pin) = _popen(sfname + 1, "r");
isfd = fileno(STA(pin));
STA(pipdevin) = 1;
}
#endif
else {
csRtAudioParams parm;
/* check for real time audio input, and get device name/number */
parm.devNum = check_rtaudio_name(sfname, &(parm.devName), 0);
if (parm.devNum >= 0) {
/* set device parameters */
parm.bufSamp_SW =
(unsigned int) O->inbufsamps / (unsigned int) csound->inchnls;
parm.bufSamp_HW = O->oMaxLag;
parm.nChannels = csound->inchnls;
parm.sampleFormat = O->informat;
parm.sampleRate = (float) csound->esr;
/* open devaudio for input */
if (UNLIKELY(csound->recopen_callback(csound, &parm) != 0))
csoundDie(csound, Str("Failed to initialise real time audio input"));
/* & redirect audio gets */
csound->audrecv = csound->rtrecord_callback;
STA(pipdevin) = 2; /* no backward seeks ! */
goto inset; /* no header processing */
}
}
/* open file */
memset(&sfinfo, 0, sizeof(SF_INFO));
if (STA(pipdevin)) {
STA(infile) = sf_open_fd(isfd, SFM_READ, &sfinfo, 0);
if (UNLIKELY(STA(infile) == NULL)) {
/* open failed: possibly raw file, but cannot seek back to try again */
const char *sfError = Str(sf_strerror(NULL));
csoundDie(csound, Str("isfinit: cannot open %s -- %s"), sfname, sfError);
}
}
else {
fullName = csoundFindInputFile(csound, sfname, "SFDIR;SSDIR");
if (UNLIKELY(fullName == NULL)) /* if not found */
csoundDie(csound, Str("isfinit: cannot open %s"), sfname);
STA(infile) = sf_open(fullName, SFM_READ, &sfinfo);
if (STA(infile) == NULL) {
/* open failed: maybe raw file ? */
memset(&sfinfo, 0, sizeof(SF_INFO));
sfinfo.samplerate = (int) MYFLT2LRND(csound->esr);
sfinfo.channels = csound->nchnls;
/* FIXME: assumes input sample format is same as output */
sfinfo.format = TYPE2SF(TYP_RAW) | FORMAT2SF(O->outformat);
STA(infile) = sf_open(fullName, SFM_READ, &sfinfo); /* try again */
}
if (UNLIKELY(STA(infile) == NULL)) {
const char *sfError = Str(sf_strerror(NULL));
csoundDie(csound, Str("isfinit: cannot open %s -- %s"), fullName, sfError);
}
/* only notify the host if we opened a real file, not stdin or a pipe */
csoundNotifyFileOpened(csound, fullName,
sftype2csfiletype(sfinfo.format), 0, 0);
sfname = fullName;
}
/* chk the hdr codes */
if (sfinfo.samplerate != (int) MYFLT2LRND(csound->esr)) {
csound->Warning(csound, Str("audio_in %s has sr = %d, orch sr = %d"),
sfname, (int) sfinfo.samplerate,
(int) MYFLT2LRND(csound->esr));
}
if (sfinfo.channels != csound->inchnls) {
csound->Warning(csound, Str("audio_in %s has %d chnls, orch %d chnls_i"),
sfname, (int) sfinfo.channels, csound->inchnls);
}
/* Do we care about the format? Can assume float?? */
O->informat = SF2FORMAT(sfinfo.format);
fileType = (int) SF2TYPE(sfinfo.format);
csound->audrecv = readsf; /* will use standard audio gets */
if ((O->informat == AE_FLOAT || O->informat == AE_DOUBLE) &&
!(fileType == TYP_WAV || fileType == TYP_AIFF || fileType == TYP_W64)) {
/* do not scale "raw" floating point files */
csound->spinrecv = sndfilein_noscale;
}
inset:
/* calc inbufsize reqd */
STA(inbufsiz) = (unsigned) (O->inbufsamps * sizeof(MYFLT));
STA(inbuf) = (MYFLT*) csound->Calloc(csound,
STA(inbufsiz)); /* alloc inbuf space */
if (STA(pipdevout) == 2)
csound->Message(csound,
Str("reading %d sample blks of %lu-bit floats from %s\n"),
O->inbufsamps * O->sfsampsize,
(unsigned long) sizeof(MYFLT)*8, sfname);
else {
csound->Message(csound,
Str("reading %d-byte blks of %s from %s (%s)\n"),
O->inbufsamps * (int) sfsampsize(FORMAT2SF(O->informat)),
getstrformat(O->informat), sfname, type2string(fileType));
}
STA(isfopen) = 1;
}
static int OSC_list(CSOUND *csound, OSCLISTEN *p)
{
OSC_PAT *m;
/* quick check for empty queue */
if (p->patterns == NULL) {
*p->kans = 0;
return OK;
}
csound->LockMutex(p->port->mutex_);
m = p->patterns;
/* check again for thread safety */
if (m != NULL) {
int i;
/* unlink from queue */
p->patterns = m->next;
/* copy arguments */
//printf("copying args\n");
for (i = 0; p->saved_types[i] != '\0'; i++) {
//printf("%d: type %c\n", i, p->saved_types[i]);
if (p->saved_types[i] == 's') {
char *src = m->args[i].string.data;
char *dst = ((STRINGDAT*) p->args[i])->data;
if (src != NULL) {
if (((STRINGDAT*) p->args[i])->size <= (int) strlen(src)){
if (dst != NULL) csound->Free(csound, dst);
dst = csound->Strdup(csound, src);
((STRINGDAT*) p->args[i])->size = strlen(dst) + 1;
((STRINGDAT*) p->args[i])->data = dst;
}
else
strcpy(dst, src);
}
}
else if (p->saved_types[i]=='b') {
char c = p->type->data[i];
int len = lo_blob_datasize(m->args[i].blob);
//printf("blob found %p type %c\n", m->args[i].blob, c);
//printf("length = %d\n", lo_blob_datasize(m->args[i].blob));
int *idata = lo_blob_dataptr(m->args[i].blob);
if (c == 'A') { /* Decode an numeric array */
int j;
MYFLT* data = (MYFLT*)(&idata[1+idata[0]]);
int size = 1;
ARRAYDAT* foo = (ARRAYDAT*)p->args[i];
foo->dimensions = idata[0];
csound->Free(csound, foo->sizes);
foo->sizes = (int*)csound->Malloc(csound, sizeof(int)*idata[0]);
#ifdef JPFF
printf("dimension=%d\n", idata[0]);
#endif
for (j=0; j<idata[0]; j++) {
foo->sizes[j] = idata[j+1];
#ifdef JPFF
printf("sizes[%d] = %d\n", j, idata[j+1]);
#endif
size*=idata[j+1];
}
#ifdef JPFF
printf("idata = %i %i %i %i %i %i %i ...\n",
idata[0], idata[1], idata[2], idata[3],
idata[4], idata[5], idata[6]);
printf("data = %f, %f, %f...\n", data[0], data[1], data[2]);
#endif
foo->data = (MYFLT*)csound->Malloc(csound, sizeof(MYFLT)*size);
memcpy(foo->data, data, sizeof(MYFLT)*size);
//printf("data = %f %f ...\n", foo->data[0], foo->data[1]);
}
else if (c == 'a') {
MYFLT *data= (MYFLT*)idata;
unsigned int len = (int)data[0];
if (len>CS_KSMPS) len = CS_KSMPS;
memcpy(p->args[i], &data[1], len*sizeof(MYFLT));
}
else if (c == 'G') { /* ftable received */
FUNC* data = (FUNC*)idata;
int fno = MYFLT2LRND(*p->args[i]);
FUNC *ftp;
if (UNLIKELY(fno <= 0 /* ||
fno > csound->maxfnum */))
return csound->PerfError(csound, p->h.insdshead,
Str("Invalid ftable no. %d"), fno);
ftp = csound->FTFindP(csound, p->args[i]);
if (ftp==NULL) // need to allocate ***FIXME***
{}
memcpy(ftp, data, sizeof(FUNC)-sizeof(MYFLT*));
ftp->fno = fno;
ftp->ftable = (MYFLT*)csound->ReAlloc(csound, ftp->ftable,
len-sizeof(FUNC)+sizeof(MYFLT*));
{
MYFLT* dst = ftp->ftable;
MYFLT* src = (MYFLT*)(&(data->ftable));
#ifdef JPFF
//int j;
printf("copy data: from %p to %p length %d %d\n",
src, dst, len-sizeof(FUNC)+sizeof(MYFLT*), data->flen);
printf("was %f %f %f ...\n", dst[0], dst[1], dst[2]);
printf("will be %f %f %f ...\n", src[0],src[1], src[2]);
memcpy(dst, src, len-sizeof(FUNC)+sizeof(MYFLT*));
#endif
//for (j=0; j<data->flen;j++) dst[j]=src[j];
//printf("now %f %f %f ...\n", dst[0], dst[1], dst[2]);
}
}
else if (c == 'S') {
}
else return csound->PerfError(csound, p->h.insdshead, "Oh dear");
csound->Free(csound, m->args[i].blob);
}
else
*(p->args[i]) = m->args[i].number;
}
/* push to stack of free message structures */
m->next = p->freePatterns;
p->freePatterns = m;
*p->kans = 1;
}
else
*p->kans = 0;
csound->UnlockMutex(p->port->mutex_);
return OK;
}
static int osc_send(CSOUND *csound, OSCSEND *p)
{
/* Types I allow at present:
0) int
1) float
2) string
3) double
4) char
5) table as blob
*/
char port[8];
char *pp = port;
char *hh;
if (*p->port<0)
pp = NULL;
else
snprintf(port, 8, "%d", (int) MYFLT2LRND(*p->port));
hh = (char*) p->host->data;
if (*hh=='\0') hh = NULL;
if(p->addr != NULL)
lo_address_free(p->addr);
p->addr = lo_address_new(hh, pp);
if (p->cnt++ ==0 || *p->kwhen!=p->last) {
int i=0;
int msk = 0x20; /* First argument */
lo_message msg = lo_message_new();
char *type = (char*)p->type->data;
MYFLT **arg = p->arg;
p->last = *p->kwhen;
for (i=0; type[i]!='\0'; i++, msk <<=1) {
/* Need to add type checks */
switch (type[i]) {
case 'i':
lo_message_add_int32(msg, (int32_t) MYFLT2LRND(*arg[i]));
break;
case 'l':
case 'h':
lo_message_add_int64(msg, (int64_t) MYFLT2LRND(*arg[i]));
break;
case 'c':
lo_message_add_char(msg, (char) (*arg[i] + FL(0.5)));
break;
case 'm':
{
union a {
int32_t x;
uint8_t m[4];
} mm;
mm.x = *arg[i]+FL(0.5);
lo_message_add_midi(msg, mm.m);
break;
}
case 'f':
lo_message_add_float(msg, (float)(*arg[i]));
break;
case 'd':
lo_message_add_double(msg, (double)(*arg[i]));
break;
case 's':
lo_message_add_string(msg, ((STRINGDAT *)arg[i])->data);
break;
case 'b': /* Boolean */
if (*arg[i]==FL(0.0)) lo_message_add_true(msg);
else lo_message_add_false(msg);
break;
case 't': /* timestamp */
{
lo_timetag tt;
tt.sec = (uint32_t)(*arg[i]+FL(0.5));
msk <<= 1; i++;
if (UNLIKELY(type[i]!='t'))
return csound->PerfError(csound, p->h.insdshead,
Str("Time stamp is two values"));
tt.frac = (uint32_t)(*arg[i]+FL(0.5));
lo_message_add_timetag(msg, tt);
break;
}
//#ifdef SOMEFINEDAY
case 'G': /* fGen Table/blob */
{
lo_blob myblob;
int len, olen;
FUNC *ftp;
void *data;
/* make sure fn exists */
if (LIKELY((ftp=csound->FTnp2Find(csound,arg[i]))!=NULL)) {
len = ftp->flen; /* and set it up */
data = csound->Malloc(csound,
olen=sizeof(FUNC)-sizeof(MYFLT*)+
sizeof(MYFLT)*len);
memcpy(data, ftp, sizeof(FUNC)-sizeof(MYFLT*));
memcpy(data+sizeof(FUNC)-sizeof(MYFLT*),
ftp->ftable, sizeof(MYFLT)*len);
}
else {
return csound->PerfError(csound, p->h.insdshead,
Str("ftable %.2f does not exist"), *arg[i]);
}
myblob = lo_blob_new(olen, data);
lo_message_add_blob(msg, myblob);
csound->Free(csound, data);
lo_blob_free(myblob);
break;
}
//#endif
case 'a': /* Audio as blob */
{
lo_blob myblob;
MYFLT *data = csound->Malloc(csound, sizeof(MYFLT)*(CS_KSMPS+1));
data[0] = CS_KSMPS;
memcpy(&data[1], arg[i], data[0]);
myblob = lo_blob_new(sizeof(MYFLT)*(CS_KSMPS+1), data);
lo_message_add_blob(msg, myblob);
csound->Free(csound, data);
lo_blob_free(myblob);
break;
}
case 'A': /* Array/blob */
{
lo_blob myblob;
int len = 1;
ARRAYDAT *ss;
/* make sure fn exists */
if (LIKELY((ss = (ARRAYDAT*)arg[i]) !=NULL &&
ss->data != NULL)) {
int j, d;
for (j=0,d=ss->dimensions; d>0; j++, d--)
len *= ss->sizes[j];
len *= sizeof(MYFLT);
}
else {
return csound->PerfError(csound, p->h.insdshead,
Str("argument %d is not an array"), i);
}
// two parts needed
{
void *dd = malloc(len+sizeof(int)*(1+ss->dimensions));
memcpy(dd, &ss->dimensions, sizeof(int));
memcpy(dd+sizeof(int), ss->sizes, sizeof(int)*ss->dimensions);
memcpy(dd+sizeof(int)*(1+ss->dimensions), ss->data, len);
/* printf("dd length = %d dimensions = %d, %d %d %.8x %.8x %.8x %.8x\n", */
/* len+sizeof(int)*(1+ss->dimensions), ss->dimensions, */
/* ((int*)dd)[0], ((int*)dd)[1], ((int*)dd)[2], ((int*)dd)[3], */
/* ((int*)dd)[4], ((int*)dd)[5]); */
myblob = lo_blob_new(len, dd);
free(dd);
}
lo_message_add_blob(msg, myblob);
lo_blob_free(myblob);
break;
}
case 'S': csound->Warning(csound, "S unimplemented"); break;
//#endif
default:
csound->Warning(csound, Str("Unknown OSC type %c\n"), type[1]);
}
}
lo_send_message(p->addr, (char*)p->dest->data, msg);
lo_message_free(msg);
}
return OK;
}
static int32_t ftconv_init(CSOUND *csound, FTCONV *p)
{
FUNC *ftp;
int32_t i, j, k, n, nBytes, skipSamples;
//MYFLT FFTscale;
/* check parameters */
p->nChannels = (int32_t) p->OUTOCOUNT;
if (UNLIKELY(p->nChannels < 1 || p->nChannels > FTCONV_MAXCHN)) {
return csound->InitError(csound, Str("ftconv: invalid number of channels"));
}
/* partition length */
p->partSize = MYFLT2LRND(*(p->iPartLen));
if (UNLIKELY(p->partSize < 4 || (p->partSize & (p->partSize - 1)) != 0)) {
return csound->InitError(csound, Str("ftconv: invalid impulse response "
"partition length"));
}
ftp = csound->FTnp2Find(csound, p->iFTNum);
if (UNLIKELY(ftp == NULL))
return NOTOK; /* ftfind should already have printed the error message */
/* calculate total length / number of partitions */
n = (int32_t) ftp->flen / p->nChannels;
skipSamples = MYFLT2LRND(*(p->iSkipSamples));
n -= skipSamples;
if (MYFLT2LRND(*(p->iTotLen)) > 0 && n > MYFLT2LRND(*(p->iTotLen)))
n = MYFLT2LRND(*(p->iTotLen));
if (UNLIKELY(n <= 0)) {
return csound->InitError(csound,
Str("ftconv: invalid length, or insufficient"
" IR data for convolution"));
}
p->nPartitions = (n + (p->partSize - 1)) / p->partSize;
/* calculate the amount of aux space to allocate (in bytes) */
nBytes = buf_bytes_alloc(p->nChannels, p->partSize, p->nPartitions);
if (nBytes != (int32_t) p->auxData.size)
csound->AuxAlloc(csound, (int32) nBytes, &(p->auxData));
else if (p->initDone > 0 && *(p->iSkipInit) != FL(0.0))
return OK; /* skip initialisation if requested */
/* if skipping samples: check for possible truncation of IR */
/*
if (skipSamples > 0 && (csound->oparms->msglevel & WARNMSG)) {
n = skipSamples * p->nChannels;
if (n > (int32_t) ftp->flen)
n = (int32_t) ftp->flen;
for (i = 0; i < n; i++) {
if (UNLIKELY(ftp->ftable[i] != FL(0.0))) {
csound->Warning(csound,
Str("ftconv: skipped non-zero samples, "
"impulse response may be truncated\n"));
break;
}
}
}*/
/* initialise buffer pointers */
set_buf_pointers(p, p->nChannels, p->partSize, p->nPartitions);
/* clear ring buffer to zero */
n = (p->partSize << 1) * p->nPartitions;
memset(p->ringBuf, 0, n*sizeof(MYFLT));
/* for (i = 0; i < n; i++) */
/* p->ringBuf[i] = FL(0.0); */
/* initialise buffer index */
p->cnt = 0;
p->rbCnt = 0;
/* calculate FFT of impulse response partitions, in reverse order */
/* also apply FFT amplitude scale here */
//FFTscale = csound->GetInverseRealFFTScale(csound, (p->partSize << 1));
p->fwdsetup = csound->RealFFT2Setup(csound,(p->partSize << 1), FFT_FWD);
p->invsetup = csound->RealFFT2Setup(csound,(p->partSize << 1), FFT_INV);
for (j = 0; j < p->nChannels; j++) {
i = (skipSamples * p->nChannels) + j; /* table read position */
n = (p->partSize << 1) * (p->nPartitions - 1); /* IR write position */
do {
for (k = 0; k < p->partSize; k++) {
if (i >= 0 && i < (int32_t) ftp->flen)
p->IR_Data[j][n + k] = ftp->ftable[i];// * FFTscale;
else
p->IR_Data[j][n + k] = FL(0.0);
i += p->nChannels;
}
/* pad second half of IR to zero */
for (k = p->partSize; k < (p->partSize << 1); k++)
p->IR_Data[j][n + k] = FL(0.0);
/* calculate FFT */
csound->RealFFT2(csound, p->fwdsetup, &(p->IR_Data[j][n]));
n -= (p->partSize << 1);
} while (n >= 0);
}
/* clear output buffers to zero */
/*memset(p->outBuffers, 0, p->nChannels*(p->partSize << 1)*sizeof(MYFLT));*/
for (j = 0; j < p->nChannels; j++) {
for (i = 0; i < (p->partSize << 1); i++)
p->outBuffers[j][i] = FL(0.0);
}
p->initDone = 1;
return OK;
}
static int osc_send(CSOUND *csound, OSCSEND *p)
{
/* Types I allow at present:
0) int
1) float
2) string
3) double
4) char
5) table as blob
*/
if (p->cnt++ ==0 || *p->kwhen!=p->last) {
int i=0;
int msk = 0x20; /* First argument */
lo_message msg = lo_message_new();
char *type = (char*)p->type->data;
MYFLT **arg = p->arg;
p->last = *p->kwhen;
for (i=0; type[i]!='\0'; i++, msk <<=1) {
/* Need to add type checks */
switch (type[i]) {
case 'i':
lo_message_add_int32(msg, (int32_t) MYFLT2LRND(*arg[i]));
break;
case 'l':
lo_message_add_int64(msg, (int64_t) MYFLT2LRND(*arg[i]));
break;
case 'c':
lo_message_add_char(msg, (char) (*arg[i] + FL(0.5)));
break;
case 'm':
{
union a {
int32_t x;
uint8_t m[4];
} mm;
mm.x = *arg[i]+FL(0.5);
lo_message_add_midi(msg, mm.m);
break;
}
case 'f':
lo_message_add_float(msg, (float)(*arg[i]));
break;
case 'd':
lo_message_add_double(msg, (double)(*arg[i]));
break;
case 's':
lo_message_add_string(msg, ((STRINGDAT *)arg[i])->data);
break;
case 'b': /* Boolean */
if (*arg[i]==FL(0.0)) lo_message_add_true(msg);
else lo_message_add_false(msg);
break;
case 't': /* timestamp */
{
lo_timetag tt;
tt.sec = (uint32_t)(*arg[i]+FL(0.5));
msk <<= 1; i++;
if (UNLIKELY(type[i]!='t'))
return csound->PerfError(csound, p->h.insdshead,
Str("Time stamp is two values"));
tt.frac = (uint32_t)(*arg[i]+FL(0.5));
lo_message_add_timetag(msg, tt);
break;
}
//#ifdef SOMEFINEDAY
case 'T': /* Table/blob */
{
lo_blob myblob;
int len;
FUNC *ftp;
void *data;
/* make sure fn exists */
if (LIKELY((ftp=csound->FTnp2Find(csound,arg[i]))!=NULL)) {
data = ftp->ftable;
len = ftp->flen-1; /* and set it up */
}
else {
return csound->PerfError(csound, p->h.insdshead,
Str("ftable %.2f does not exist"), *arg[i]);
}
myblob = lo_blob_new(sizeof(MYFLT)*len, data);
lo_message_add_blob(msg, myblob);
lo_blob_free(myblob);
break;
}
//#endif
default:
csound->Warning(csound, Str("Unknown OSC type %c\n"), type[1]);
}
}
lo_send_message(p->addr, (char*)p->dest->data, msg);
lo_message_free(msg);
}
return OK;
}
static int32_t pvsfreadset_(CSOUND *csound, PVSFREAD *p, int32_t stringname)
{
PVOCEX_MEMFILE pp;
uint32 N;
char pvfilnam[MAXNAME];
if (stringname) strNcpy(pvfilnam, ((STRINGDAT*)p->ifilno)->data, MAXNAME-1);
else if (csound->ISSTRCOD(*p->ifilno))
strNcpy(pvfilnam, get_arg_string(csound, *p->ifilno), MAXNAME-1);
else csound->strarg2name(csound, pvfilnam, p->ifilno, "pvoc.", 0);
if (UNLIKELY(PVOCEX_LoadFile(csound, pvfilnam, &pp) != 0)) {
return csound->InitError(csound, Str("Failed to load PVOC-EX file"));
}
p->ptr = 0;
p->overlap = pp.overlap;
p->winsize = pp.winsize;
p->fftsize = pp.fftsize;
p->wintype = pp.wintype;
p->format = pp.format;
p->chans = pp.chans;
p->nframes = pp.nframes;
p->arate = csound->esr / (MYFLT) pp.overlap;
p->membase = (float*) pp.data;
if (UNLIKELY(p->overlap < (int32_t)CS_KSMPS || p->overlap < 10))
return csound->InitError(csound, Str("Sliding version not yet available"));
if (UNLIKELY(p->nframes <= 0))
return csound->InitError(csound, Str("pvsfread: file is empty!\n"));
/* special case if only one frame - it is an impulse response */
if (UNLIKELY(p->nframes == 1))
return csound->InitError(csound, Str("pvsfread: file has only one frame "
"(= impulse response).\n"));
if (UNLIKELY(p->overlap < (int32_t)CS_KSMPS))
return csound->InitError(csound, Str("pvsfread: analysis frame overlap "
"must be >= ksmps\n"));
p->blockalign = (p->fftsize+2) * p->chans;
if (UNLIKELY((*p->ichan) >= p->chans))
return csound->InitError(csound, Str("pvsfread: ichan value exceeds "
"file channel count.\n"));
if (UNLIKELY((int32_t) (*p->ichan) < 0))
return csound->InitError(csound,
Str("pvsfread: ichan cannot be negative.\n"));
N = p->fftsize;
/* setup output signal */
csound->AuxAlloc(csound, (N + 2) * sizeof(float), &p->fout->frame);
/* init sig with first frame from file,
regardless (always zero amps, but with bin freqs) */
p->chanoffset = (int32_t) MYFLT2LRND(*p->ichan) * (N + 2);
memcpy((float *) p->fout->frame.auxp, /* RWD MUST be 32bit */
(float *) pp.data + (int32_t) p->chanoffset, /* RWD MUST be 32bit */
(size_t) ((int32_t) (N + 2) * (int32_t) sizeof(float)));
p->membase += p->blockalign; /* move to 2nd frame in file, as startpoint */
p->nframes--;
p->fout->N = N;
p->fout->overlap = p->overlap;
p->fout->winsize = p->winsize;
p->fout->wintype = p->wintype;
p->fout->format = p->format;
p->fout->framecount = 1;
p->lastframe = 0;
return OK;
}
static int32_t linuxjoystick (CSOUND *csound, LINUXJOYSTICK *stick)
{
static int32_t read_pos = 0;
struct js_event js;
int32_t read_size;
int32_t getmore;
int32_t evtidx;
long long evtmask = 0;
char device[256];
if (UNLIKELY(stick->initme == 0)) {
stick->timeout = 0;
stick->devFD = -10;
stick->initme = 1;
}
if (UNLIKELY(*stick->ktable != stick->table)) {
if (UNLIKELY((void *)(stick->ftp = csound->FTnp2Find(csound, stick->ktable))
== NULL)) {
csound->Warning(csound, Str("linuxjoystick: No such table %f"),
*(float*)(stick->ktable));
return OK;
}
stick->table = *stick->ktable;
}
if (stick->devFD < 0 || *stick->kdev != stick->dev) {
if (stick->timeout > 0 && *stick->kdev == stick->dev) {
(stick->timeout)--;
return OK;
}
stick->dev = (int32_t)MYFLT2LRND(*stick->kdev);
snprintf(device, 256, "/dev/js%i", stick->dev);
if ((stick->devFD = open(device, O_RDONLY, O_NONBLOCK)) < 0) {
snprintf(device, 256, "/dev/input/js%i", stick->dev);
stick->devFD = open(device, O_RDONLY, O_NONBLOCK);
}
if (LIKELY(stick->devFD > 0)) {
fcntl(stick->devFD, F_SETFL, fcntl(stick->devFD, F_GETFL, 0)|O_NONBLOCK);
ioctl(stick->devFD, JSIOCGAXES, &stick->numk);
ioctl(stick->devFD, JSIOCGBUTTONS, &stick->numb);
if (UNLIKELY(stick->ftp->flen < 2u+(stick->numk)+(stick->numb))) {
csound->Warning
(csound,
Str("linuxjoystick: table %d of size %d too small for data size %d"),
(int32_t
)stick->table, stick->ftp->flen, 2+stick->numk+stick->numb);
return OK;
}
stick->ftp->ftable[ 0 ] = (MYFLT) stick->numk;
stick->ftp->ftable[ 1 ] = (MYFLT) stick->numb;
evtmask = 3;
}
else {
stick->timeout = 10000;
csound->Warning(csound,
Str("linuxjoystick: could not open device "
"/dev/input/js%d for reason: %s\n"),
stick->dev, strerror(errno));
csound->Warning(csound,
Str("linuxjoystick: could not open device "
"/dev/js%d for reason: %s\n"),
stick->dev, strerror(errno));
return OK;
}
}
getmore = 1;
while (getmore) {
read_size = read(stick->devFD, (void *) &js+read_pos,
sizeof(struct js_event)-read_pos);
if (read_size == -1 && errno == EAGAIN ) {
getmore = 0;
}
else if (UNLIKELY(read_size < 1)) {
csound->Warning(csound, Str("linuxjoystick: read %d closing joystick"),
read_size);
close(stick->devFD);
stick->devFD = -1;
getmore = 0;
}
else {
read_pos += read_size;
if (read_pos == sizeof(struct js_event)) {
read_pos = 0;
if (js.type & JS_EVENT_AXIS) {
evtidx = 2 + js.number;
}
else if (js.type & JS_EVENT_BUTTON) {
evtidx = 2 + stick->numk + js.number;
}
else {
csound->Warning(csound, Str("unknown joystick event type %i"),
js.type);
return OK;
}
evtmask = evtmask | (1 << evtidx);
stick->ftp->ftable[ evtidx ] = (MYFLT) js.value;
}
}
}
*stick->kresult = (MYFLT) evtmask;
return OK;
}
