void sfnopenout(CSOUND *csound)
{
alloc_globals(csound);
csound->Message(csound, Str("not writing to sound disk\n"));
/* init counter, though not writing */
STA(outbufrem) = csound->oparms->outbufsamps;
}
static int osc_listener_init(CSOUND *csound, OSCINIT *p)
{
OSC_GLOBALS *pp;
OSC_PORT *ports;
char buff[32];
int n;
/* allocate and initialise the globals structure */
pp = alloc_globals(csound);
n = pp->nPorts;
ports = (OSC_PORT*) csound->ReAlloc(csound, pp->ports,
sizeof(OSC_PORT) * (n + 1));
ports[n].csound = csound;
ports[n].mutex_ = csound->Create_Mutex(0);
ports[n].oplst = NULL;
snprintf(buff, 32, "%d", (int) *(p->port));
ports[n].thread = lo_server_thread_new(buff, OSC_error);
if (ports[n].thread==NULL)
return csound->InitError(csound,
Str("cannot start OSC listener on port %s\n"),
buff);
///if (lo_server_thread_start(ports[n].thread)<0)
/// return csound->InitError(csound,
/// Str("cannot start OSC listener on port %s\n"),
/// buff);
lo_server_thread_start(ports[n].thread);
pp->ports = ports;
pp->nPorts = n + 1;
csound->Warning(csound, Str("OSC listener #%d started on port %s\n"), n, buff);
*(p->ihandle) = (MYFLT) n;
csound->RegisterDeinitCallback(csound, p,
(int (*)(CSOUND *, void *)) OSC_deinit);
return OK;
}
void iotranset(CSOUND *csound)
{
OPARMS *O;
csound->spinrecv = sndfilein;
csound->spoutran = spoutsf;
if (!csound->enableHostImplementedAudioIO)
return;
alloc_globals(csound);
O = csound->oparms;
csound->audrecv = audrecv_dummy;
csound->audtran = audtran_dummy;
STA(inbufrem) = (unsigned int) O->inbufsamps;
STA(outbufrem) = (unsigned int) O->outbufsamps;
if (!csound->hostRequestedBufferSize) {
O->sfread = 0;
O->sfwrite = 0;
STA(osfopen) = 0;
return;
}
STA(inbufsiz) = (unsigned int) (O->inbufsamps * (int) sizeof(MYFLT));
STA(inbuf) = (MYFLT*) csound->Calloc(csound, STA(inbufsiz));
STA(outbufsiz) = (unsigned int) (O->outbufsamps * (int) sizeof(MYFLT));
STA(outbuf) = (MYFLT*) csound->Calloc(csound, STA(outbufsiz));
STA(outbufp) = STA(outbuf);
O->sfread = 1;
O->sfwrite = 1;
STA(osfopen) = 1;
}
void extended_kalman_init( uFloat **P, uFloat *x )
{
#ifdef PRINT_DEBUG
printf( "ekf: Initializing filter\n" );
#endif
alloc_globals( STATE_SIZE, MEAS_SIZE );
sys_transfer = matrix( 1, STATE_SIZE, 1, STATE_SIZE );
mea_transfer = matrix( 1, MEAS_SIZE, 1, STATE_SIZE );
/* Init the global variables using the arguments. */
vecCopy( x, state_post, STATE_SIZE );
vecCopy( x, state_pre, STATE_SIZE );
matCopy( P, cov_post, STATE_SIZE, STATE_SIZE );
matCopy( P, cov_pre, STATE_SIZE, STATE_SIZE );
covarianceSet( sys_noise_cov, mea_noise_cov );
#ifdef PRINT_DEBUG
printf( "ekf: Completed Initialization\n" );
#endif
}
void readxfil(CSOUND *csound, EXTRACT_STATICS* extractStatics,
FILE *xfp) /* read the extract control file */
{
int flag, all;
char s[82];
alloc_globals(csound, extractStatics);
all = 1;
flag = 'i'; /* default -i flag supplied */
STA(onsect) = 1; STA(onbeat) = FL(0.0); /* other default vals */
STA(offsect) = 999; STA(offbeat) = FL(0.0);
// while (fscanf(xfp, s) != EOF) {
while (fgets(s, 82, xfp) != NULL) {
char *c = s;
int i;
switch (*c) {
case 'i':
all = 0;
// intended no break here
case 'f':
case 't':
flag = *c++;
break;
default:
switch (flag) {
case 'i':
sscanf(s, "%d", &i);
if (i>=0 && i < INSMAX) STA(inslst)[i] = 1;
else csound->Die(csound, Str("instrument number out of range"));
all = 0;
break;
case 'f':
#if defined(USE_DOUBLE)
CS_SSCANF(s, "%d:%lf", &STA(onsect), &STA(onbeat));
#else
CS_SSCANF(s, "%d:%f", &STA(onsect), &STA(onbeat));
#endif
break;
case 't':
STA(offsect) = STA(onsect); /* default offsect */
#if defined(USE_DOUBLE)
CS_SSCANF(s, "%d:%lf", &STA(offsect), &STA(offbeat));
#else
CS_SSCANF(s, "%d:%f", &STA(offsect), &STA(offbeat));
#endif
}
}
}
if (all) {
char *ip;
for (ip = &STA(inslst)[0]; ip < &STA(inslst)[INSMAX]; *ip++ = 1);
}
STA(ontime) = STA(a0).newp3 = STA(a0).p3val = STA(onbeat);
STA(offtime) = STA(f0).newp2 = STA(f0).p2val = STA(offbeat);
}
void sfcloseout(CSOUND *csound)
{
OPARMS *O = csound->oparms;
int nb;
alloc_globals(csound);
if (!STA(osfopen))
return;
if ((nb = (O->outbufsamps - STA(outbufrem)) * sizeof(MYFLT)) > 0) {
/* flush outbuffer */
csound->nrecs++;
csound->audtran(csound, STA(outbuf), nb);
}
if (STA(pipdevout) == 2 && (!STA(isfopen) || STA(pipdevin) != 2)) {
/* close only if not open for input too */
csound->rtclose_callback(csound);
}
if (STA(pipdevout) == 2)
goto report;
if (STA(outfile) != NULL) {
if (!STA(pipdevout) && O->outformat != AE_VORBIS)
sf_command(STA(outfile), SFC_UPDATE_HEADER_NOW, NULL, 0);
sf_close(STA(outfile));
STA(outfile) = NULL;
}
#ifdef PIPES
if (STA(pout) != NULL) {
_pclose(STA(pout));
STA(pout) = NULL;
}
#endif
report:
if (STA(pipdevout) == 2) {
csound->Message(csound,
"%"PRIi32" %d %s%lu%s%s\n",
csound->nrecs, O->outbufsamps, Str("sample blks of "),
(unsigned long)sizeof(MYFLT)*8,Str("-bit floats written to "),
STA(sfoutname));
}
else {
csound->Message(csound, Str("%"PRIi32" %d sample blks of %s written to %s"),
O->outbufsamps, 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) = 0;
}
static int OSC_deinit(CSOUND *csound, OSCINIT *p)
{
int n = (int)*p->ihandle;
OSC_GLOBALS *pp = alloc_globals(csound);
OSC_PORT *ports = pp->ports;
csound->Message(csound, "handle=%d\n", n);
csound->DestroyMutex(ports[n].mutex_);
ports[n].mutex_ = NULL;
lo_server_thread_stop(ports[n].thread);
lo_server_thread_free(ports[n].thread);
ports[n].thread = NULL;
csound->Message(csound, Str("OSC deinitiatised\n"));
return OK;
}
void kalman_init( m_elem **GQGt, m_elem **Phi, m_elem **H, m_elem **R,
m_elem **P, m_elem *x, int num_state, int num_measurement )
{
alloc_globals( num_state, num_measurement );
/* Init the global variables using the arguments. */
vec_copy( x, state_post, state_size );
mat_copy( P, cov_post, state_size, state_size );
sys_noise_cov = GQGt;
mea_noise_cov = R;
sys_transfer = Phi;
mea_transfer = H;
/***************** Gain Loop *****************/
estimate_prob( cov_post, sys_transfer, sys_noise_cov, cov_pre );
update_prob( cov_pre, mea_noise_cov, mea_transfer, cov_post, kalman_gain );
}
void sfclosein(CSOUND *csound)
{
alloc_globals(csound);
if (!STA(isfopen))
return;
if (STA(pipdevin) == 2 && (!STA(osfopen) || STA(pipdevout) != 2)) {
/* close only if not open for output too */
csound->rtclose_callback(csound);
}
else if (STA(pipdevin) != 2) {
if (STA(infile) != NULL)
sf_close(STA(infile));
#ifdef PIPES
if (STA(pin) != NULL) {
_pclose(STA(pin));
STA(pin) = NULL;
}
#endif
STA(infile) = NULL;
}
STA(isfopen) = 0;
}
void extended_kalman_init( m_elem **GQGt, m_elem **R, m_elem **P, m_elem *x,
int num_state, int num_measurement )
{
#ifdef PRINT_DEBUG
printf( "ekf: Initializing filter\n" );
#endif
alloc_globals( num_state, num_measurement );
sys_transfer = matrix( 1, num_state, 1, num_state );
mea_transfer = matrix( 1, num_measurement, 1, num_state );
/* Init the global variables using the arguments. */
vec_copy( x, state_post, state_size );
vec_copy( x, state_pre, state_size );
mat_copy( P, cov_post, state_size, state_size );
mat_copy( P, cov_pre, state_size, state_size );
sys_noise_cov = GQGt;
mea_noise_cov = R;
}
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;
}
void extract(CSOUND *csound, EXTRACT_STATICS* extractStatics)
/* extract instr events within the time period */
{
SRTBLK *bp;
MYFLT turnoff, anticip;
int warped;
alloc_globals(csound, extractStatics);
if ((bp = csound->frstbp) == NULL) /* if null file */
return;
if (++STA(sectno) > STA(offsect)) { /* or later section, */
csound->frstbp = NULL;
return; /* return */
}
STA(frstout) = STA(prvout) = NULL;
if (STA(sectno) < STA(onsect)) { /* for sects preceding, */
do {
switch (bp->text[0]) {
case 'f': /* include f's at time 0 */
bp->p2val = bp->newp2 = FL(1.0); /* time 1 for now!! */
include(csound, extractStatics, bp);
break;
case 'w':
case 's':
case 'e':
include(csound, extractStatics, bp); /* incl w,s,e verbatim */
break;
case 't':
case 'i':
case 'a':
break; /* but skip all t,i,a */
}
} while ((bp = bp->nxtblk) != NULL);
}
else { /* for sections in timespan: */
do {
switch(bp->text[0]) {
case 'w':
warped = realtset(csound, bp);
if (STA(sectno) == STA(onsect) && warped)
STA(ontime) = STA(a0).newp3 = realt(csound, STA(onbeat));
if (STA(sectno) == STA(offsect) && warped)
STA(offtime) = STA(f0).newp2 = realt(csound, STA(offbeat));
include(csound, extractStatics, bp);
break;
case 't':
include(csound, extractStatics, bp);
break;
case 'f':
casef: if (STA(sectno) == STA(onsect) && bp->newp2 < STA(ontime))
bp->newp2 = STA(ontime);
else if (STA(sectno) == STA(offsect) && bp->newp2 > STA(offtime))
break;
if (STA(sectno) == STA(onsect) && !STA(a0done)) {
if (STA(onbeat) > 0)
include(csound, extractStatics, &STA(a0));
STA(a0done)++;
}
include(csound, extractStatics, bp);
break;
case 'i':
if (!STA(inslst)[bp->insno]) /* skip insnos not required */
break;
if (bp->newp3 < 0) /* treat indef dur like f */
goto casef;
case 'a':turnoff = bp->newp2 + bp->newp3; /* i and a: */
if (STA(sectno) == STA(onsect)) {
if (turnoff < STA(ontime))
break;
if ((anticip = STA(ontime) - bp->newp2) > 0) {
if ((bp->newp3 -= anticip) < FL(0.001))
break;
bp->p3val -= STA(onbeat) - bp->p2val;
bp->newp2 = STA(ontime);
bp->p2val = STA(onbeat);
}
}
if (STA(sectno) == STA(offsect)) {
if (bp->newp2 >= STA(offtime))
break;
if (turnoff > STA(offtime)) {
bp->newp3 = STA(offtime) - bp->newp2;
bp->p3val = STA(offbeat) - bp->p2val;
}
}
if (STA(sectno) == STA(onsect) && !STA(a0done)) {
if (STA(onbeat) > 0)
include(csound, extractStatics, &STA(a0));
STA(a0done)++;
}
include(csound, extractStatics, bp);
break;
case 's':
case 'e':
if (STA(sectno) == STA(offsect)) {
include(csound, extractStatics, &STA(f0));
include(csound, extractStatics, &STA(e));
}
else include(csound, extractStatics, bp);
break;
}
} while ((bp = bp->nxtblk) != NULL);
}
csound->frstbp = STA(frstout);
if (STA(prvout) != NULL)
STA(prvout)->nxtblk = NULL;
}
int
loadphotondata(char *filename, char *passfile) {
fitstable_t* tab;
qfits_header* hdr;
tfits_type flt = fitscolumn_float_type(), chtype = fitscolumn_char_type(), dbltype=fitscolumn_double_type();
float *localphotondata[NPHOTON_LOADDATA], *galdisrsp=NULL, *isodisrsp=NULL;
double *localphotontime;
char *conversion_type=NULL;
char buffer[255];
int i, j, ncurr, ndiff, nresp=0, conv_type, psf_cnt, psf_ind;
double rmax2, ehold, rad, r2hold;
if ( (tab = fitstable_open(filename))==NULL) {
printf("# Cannot open %s in loadphotondata() %s:%d\n",filename,__FILE__,__LINE__);
return -1;
}
hdr = fitstable_get_primary_header(tab);
hdr = fitstable_get_header(tab);
ncurr = fitstable_nrows(tab);
if (debug) printf("# filename= %s ncurr= %d\n",filename,ncurr);
/* load in the energy, theta, ra and dec */
for (i=0; i<NPHOTON_LOADDATA; i++) {
if ( (localphotondata[i]=
(float *) fitstable_read_column_array(tab,
photon_colname[i], flt))==NULL) {
printf("# vector for %s is NULL in loadphotondata() %s:%d\n",photon_colname[i],__FILE__,__LINE__);
for (j=0; j<i; j++) {
SAFEFREE( localphotondata[i]);
}
fitstable_close(tab);
return -1;
}
}
/* load in conversion type */
if ( (conversion_type= (char *) fitstable_read_column(tab, "CONVERSION_TYPE", chtype))==NULL) {
printf("# array for conversion_type is NULL in loadphotondata() %s:%d\n",__FILE__,__LINE__);
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE( localphotondata[i]);
}
fitstable_close(tab);
return -1;
}
/* load in photon arrival time */
if ( (localphotontime= (double *) fitstable_read_column(tab, "TIME", dbltype))==NULL) {
printf("# array for localphotontime is NULL in loadphotondata() %s:%d\n",__FILE__,__LINE__);
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE( localphotondata[i]);
}
SAFEFREE( conversion_type);
fitstable_close(tab);
return -1;
}
/* load in the diffuse response functions that match the passfile */
ndiff = qfits_header_getint(hdr, "NDIFRSP",-1);
for (i=0; i<ndiff; i++) {
sprintf(buffer,"DIFRSP%d",i);
char *respname = qfits_header_getstr(hdr, buffer);
if (debug) printf("# %d %s = %s\n",i,buffer,respname);
if (strcasestr(respname,passfile)) {
if (strcasestr(respname,"gll")) {
if (debug) printf("# galactic is %s\n",buffer);
if ( (galdisrsp=
(float *) fitstable_read_column_array(tab,
buffer, flt))==NULL) {
printf("# array for %s is NULL in loadphotondata() %s:%d\n",buffer,__FILE__,__LINE__);
for (j=0; j<i; j++) {
SAFEFREE( localphotondata[i]);
}
SAFEFREE( conversion_type);
SAFEFREE(localphotontime);
SAFEFREE( galdisrsp);
SAFEFREE( isodisrsp);
fitstable_close(tab);
return -1;
}
nresp++;
}
if (strcasestr(respname,"iso")) {
if (debug) printf("# iso is %s\n",buffer);
if ( (isodisrsp=
(float *) fitstable_read_column_array(tab,
buffer, flt))==NULL) {
printf("# array for %s is NULL in loadphotondata() %s:%d\n",buffer,__FILE__,__LINE__);
for (j=0; j<i; j++) {
SAFEFREE( localphotondata[i]);
}
SAFEFREE( conversion_type);
SAFEFREE(localphotontime);
SAFEFREE( galdisrsp);
SAFEFREE( isodisrsp);
fitstable_close(tab);
return -1;
}
nresp++;
}
}
}
if (nresp<2) {
printf("Could not find the matching response functions in loadphotondata() %s:%d.\n",__FILE__,__LINE__);
return -1;
}
if (alloc_globals(ncurr+ntot)) {
SAFEFREE(localphotontime);
SAFEFREE(conversion_type);
SAFEFREE(data);
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE(localphotondata[i]);
}
return -1;
}
fitstable_close(tab);
j=0;
for (i=0; i<ncurr; i++) {
ehold=localphotondata[ENERGY][i];
if (ehold>=e0 && ehold<=e1) {
double ra, dec;
__sincospi((ra=localphotondata[RA][i])/180.0,data+d*(j+ntot)+1,data+d*(j+ntot));
__sincospi((dec=localphotondata[DEC][i])/180.0,data+d*(j+ntot)+2,&rad);
data[d*(ntot+j)]*=rad;
data[d*(ntot+j)+1]*=rad;
if (ehold<energy_min) energy_min=ehold;
/* calculate RMAX2 for this photon */
conv_type=conversion_type[i];
rmax2=photondata[COSTHETA][j+ntot]=cos(localphotondata[THETA][i]*M_PI/180.0);
if (debug>3) printf("# costheta= %g\n",rmax2);
#if 1
/* fast way --- evenly spaced in log energy and costheta -- no interpolation */
// rmax2=psfds.psfdata[conv_type][RMAX2][(int) ((rmax2-psfds.mumin)/psfds.mustep)*psfds.nE + (int) ((log10(ehold)-psfds.lemin)/psfds.lestep)];
rmax2=rmax2_funk(psfds,conv_type,rmax2,ehold);
#else
/* slow way --- find the right bin -- no interpolation */
for (psf_cnt=0; psf_cnt<psfds.nE; psf_cnt++) {
if (ehold>psfds.psfdata[conv_type][ENERG_LO][psf_cnt] && ehold<=psfds.psfdata[conv_type][ENERG_HI][psf_cnt]) {
psf_ind=psf_cnt;
break;
}
}
for (psf_cnt=0; psf_cnt<psfds.nMu; psf_cnt++) {
if (rmax2>psfds.psfdata[conv_type][CTHETA_LO][psf_cnt] && rmax2<=psfds.psfdata[conv_type][CTHETA_HI][psf_cnt]) {
psf_ind+=psf_cnt*psfds.nE;
break;
}
}
rmax2=psfds.psfdata[conv_type][RMAX2][psf_ind];
#endif
if (debug>3) printf("# rmax2= %g\n",rmax2);
if (conv_type) {
/* back conversion */
r2hold=SPE_squared_back(ehold)*rmax2;
data[d*(ntot+j)+3]=-(r2hold>4 ? 4 : r2hold);
} else {
/* front conversion */
r2hold=SPE_squared_front(ehold)*rmax2;
data[d*(ntot+j)+3]=(r2hold>4 ? 4 : r2hold);
}
if (debug>3) printf("# %g rmax2= %g %g %g\n",ehold,data[d*(ntot+j)+3],SPE_squared_front(ehold),localphotondata[THETA][i]);
photondata[ENERGY][j+ntot]=ehold;
photondata[DIFRSP_GAL][j+ntot]=galdisrsp[i];
photondata[DIFRSP_ISO][j+ntot]=isodisrsp[i];
r2hold=aeffds.aeffdata[conv_type][AEFF_EFF_AREA]
[(int) ((photondata[COSTHETA][j+ntot]-aeffds.mumin)/aeffds.mustep)*aeffds.nE + (int) ((log10(ehold)-aeffds.lemin)/aeffds.lestep)];
if (r2hold<EFFAREAMIN) r2hold=EFFAREAMIN;
photondata[EFFAREA][j+ntot]=r2hold;
/* calculate the effective area integral */
r2hold=calcefft(ra,dec,ehold,&aeffds,<cubeds);
if (r2hold<EFFAREATMIN) r2hold=EFFAREATMIN;
photondata[EFFAREAT][j+ntot]=r2hold;
photontime[j+ntot]=localphotontime[i];
j++;
}
}
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE(localphotondata[i]);
}
SAFEFREE( galdisrsp);
SAFEFREE( isodisrsp);
SAFEFREE(conversion_type);
SAFEFREE(localphotontime);
ntot+=j;
if (debug) printf("# ntot= %d j= %d\n",ntot,j);
if (j!=ncurr) {
if (alloc_globals(ncurr+ntot)) {
SAFEFREE(data);
for (i=0; i<NPHOTON_LOADDATA; i++) {
SAFEFREE(localphotondata[i]);
}
return -1;
}
}
return 0;
}
void readxfil(CSOUND *csound, EXTRACT_STATICS* extractStatics,
FILE *xfp) /* read the extract control file */
{
int flag, all;
char s[128];
alloc_globals(extractStatics);
all = 1;
flag = 'i'; /* default -i flag supplied */
extractStatics->onsect = 1;
extractStatics->onbeat = FL(0.0); /* other default vals */
extractStatics->offsect = 999; extractStatics->offbeat = FL(0.0);
while (fscanf(xfp, "%100s", s) > 0) {
char *c = s;
int i;
//printf("string: %s\n", s);
switch (*c) {
case 'i':
all = 0;
// intended no break here
/* FALLTHRU */
case 'f':
case 't':
flag = *c++;
break;
default:
switch (flag) {
case 'i':
sscanf(s, "%d", &i);
//printf("i: %d\n", i);
if (LIKELY(i>=0 && i < INSMAX)) extractStatics->inslst[i] = 1;
else csound->Message(csound, Str("instrument number out of range"));
all = 0;
break;
case 'f':
//printf("f: %s\n", s);
#if defined(USE_DOUBLE)
CS_SSCANF(s, "%d:%lf", &extractStatics->onsect, &extractStatics->onbeat);
#else
CS_SSCANF(s, "%d:%f", &extractStatics->onsect, &extractStatics->onbeat);
#endif
break;
case 't':
//printf("t: %s\n");
extractStatics->offsect = extractStatics->onsect; /* default offsect */
#if defined(USE_DOUBLE)
CS_SSCANF(s, "%d:%lf", &extractStatics->offsect,&extractStatics->offbeat);
#else
CS_SSCANF(s, "%d:%f", &extractStatics->offsect, &extractStatics->offbeat);
#endif
}
}
}
//printf("extract read\n");
if (all) {
char *ip;
for (ip = &extractStatics->inslst[0];
ip < &extractStatics->inslst[INSMAX]; *ip++ = 1);
}
extractStatics->ontime = extractStatics->a0.newp3 =
extractStatics->a0.p3val = extractStatics->onbeat;
extractStatics->offtime = extractStatics->f0.newp2 =
extractStatics->f0.p2val = extractStatics->offbeat;
}
void extract(CSOUND *csound, EXTRACT_STATICS* extractStatics)
/* extract instr events within the time period */
{
SRTBLK *bp;
MYFLT turnoff, anticip;
int warped;
alloc_globals(extractStatics);
if ((bp = csound->frstbp) == NULL) /* if null file */
return;
if (++extractStatics->sectno > extractStatics->offsect) {
/* or later section, */
csound->frstbp = NULL;
return; /* return */
}
extractStatics->frstout = extractStatics->prvout = NULL;
if (extractStatics->sectno < extractStatics->onsect) {
/* for sects preceding, */
do {
switch (bp->text[0]) {
case 'f': /* include f's at time 0 */
bp->p2val = bp->newp2 = FL(1.0); /* time 1 for now!! */
include(extractStatics, bp);
break;
case 'w':
case 's':
case 'e':
include(extractStatics, bp); /* incl w,s,e verbatim */
break;
case 't':
case 'i':
case 'a':
break; /* but skip all t,i,a */
}
} while ((bp = bp->nxtblk) != NULL);
}
else { /* for sections in timespan: */
do {
switch(bp->text[0]) {
case 'w':
warped = realtset(csound, bp);
if (extractStatics->sectno == extractStatics->onsect && warped)
extractStatics->ontime = extractStatics->a0.newp3 =
realt(csound, extractStatics->onbeat);
if (extractStatics->sectno == extractStatics->offsect && warped)
extractStatics->offtime = extractStatics->f0.newp2 =
realt(csound, extractStatics->offbeat);
include(extractStatics, bp);
break;
case 't':
include(extractStatics, bp);
break;
case 'f':
casef: if (extractStatics->sectno == extractStatics->onsect &&
bp->newp2 < extractStatics->ontime)
bp->newp2 = extractStatics->ontime;
else if (extractStatics->sectno == extractStatics->offsect &&
bp->newp2 > extractStatics->offtime)
break;
if (extractStatics->sectno == extractStatics->onsect &&
!extractStatics->a0done) {
if (extractStatics->onbeat > 0)
include(extractStatics, &extractStatics->a0);
extractStatics->a0done++;
}
include(extractStatics, bp);
break;
case 'i':
if (!extractStatics->inslst[bp->insno]) /* skip insnos not required */
break;
if (bp->newp3 < 0) /* treat indef dur like f */
goto casef;
/* FALLTHRU */
case 'a':turnoff = bp->newp2 + bp->newp3; /* i and a: */
if (extractStatics->sectno == extractStatics->onsect) {
if (turnoff < extractStatics->ontime)
break;
if ((anticip = extractStatics->ontime - bp->newp2) > 0) {
if ((bp->newp3 -= anticip) < FL(0.001))
break;
bp->p3val -= extractStatics->onbeat - bp->p2val;
bp->newp2 = extractStatics->ontime;
bp->p2val = extractStatics->onbeat;
}
}
if (extractStatics->sectno == extractStatics->offsect) {
if (bp->newp2 >= extractStatics->offtime)
break;
if (turnoff > extractStatics->offtime) {
bp->newp3 = extractStatics->offtime - bp->newp2;
bp->p3val = extractStatics->offbeat - bp->p2val;
}
}
if (extractStatics->sectno == extractStatics->onsect &&
!extractStatics->a0done) {
if (extractStatics->onbeat > 0)
include(extractStatics, &extractStatics->a0);
extractStatics->a0done++;
}
include(extractStatics, bp);
break;
case 's':
case 'e':
if (extractStatics->sectno == extractStatics->offsect) {
include(extractStatics, &extractStatics->f0);
include(extractStatics, &extractStatics->e);
}
else include(extractStatics, bp);
break;
}
} while ((bp = bp->nxtblk) != NULL);
}
csound->frstbp = extractStatics->frstout;
if (extractStatics->prvout != NULL)
extractStatics->prvout->nxtblk = NULL;
}
