void RTinit() /* set up Linebuf, Midibuf & ready the input files */
{ /* callable once from main.c */
extern int Linein, Midiin;
extern char *Linename, *Midiname;
if (Linein) {
Linevtblk = (EVTBLK *) mcalloc((long)sizeof(EVTBLK));
Linebuf = mcalloc((long)LBUFSIZ);
Linebufend = Linebuf + LBUFSIZ;
Linep = Linebuf;
if (strcmp(Linename,"stdin") == 0) {
#ifdef THINK_C
console_options.top += 10;
console_options.left += 10;
console_options.title = "\pRT Line_events";
console_options.nrows = 10;
console_options.ncols = 50;
Linecons = fopenc();
cshow(Linecons);
#else
if (fcntl(Linefd, F_SETFL, fcntl(Linefd, F_GETFL, 0) | O_NDELAY) < 0)
die("-R stdin fcntl failed");
#endif
}
else if ((Linefd = open(Linename, O_RDONLY | O_NDELAY)) < 0)
dies("cannot open %s", Linename);
}
if (Midiin) {
Midevtblk = (EVTBLK *) mcalloc((long)sizeof(EVTBLK));
Midibuf = mcalloc((long)MBUFSIZ);
Midibufend = Midibuf + MBUFSIZ;
Midip = Midibuf;
if (strcmp(Midiname,"stdin") == 0) {
#ifdef THINK_C
dieu("RT Midi_event Console not implemented");
#else
if (fcntl(Midifd, F_SETFL, fcntl(Midifd, F_GETFL, 0) | O_NDELAY) < 0)
die("-M stdin fcntl failed");
#endif
}
else if ((Midifd = open(Midiname, O_RDONLY | O_NDELAY)) < 0)
dies("cannot open %s", Midiname);
}
}
static int srconv(CSOUND *csound, int argc, char **argv)
{
MYFLT
*input, /* pointer to start of input buffer */
*output, /* pointer to start of output buffer */
*nextIn, /* pointer to next empty word in input */
*nextOut, /* pointer to next empty word in output */
*fxval = 0, /* pointer to start of time-array for time-vary function */
*fyval = 0, /* pointer to start of P-scale-array for time-vary func */
*i0, /* pointer */
*i1; /* pointer */
float
*window, /* pointer to center of analysis window */
*wj, /* pointer to window */
*wj1; /* pointer to window */
int
M = 2401, /* length of window impulse response */
N = 120, /* length of sinc period */
L = 120, /* internal sample rate is L*Rin */
m, /* current input sample in buffer */
o, /* current input at L*Rin mod L */
del, /* increment */
WinLen, /* half-length of window at L*Rin */
wLen, /* half-length of window at Rin */
jMin, /* initial offset in window */
mMax; /* maximum valid m */
long
n, /* current input sample */
nMax = 2000000000; /* last input sample (unless EOF) */
MYFLT
beta = FL(6.8), /* parameter for Kaiser window */
sum, /* scale factor for renormalizing windows */
fdel, /* float del */
idel, /* float del */
fo, /* float o */
of, /* fractional o */
fL = (MYFLT) L, /* float L */
iw, /* interpolated window */
tvx0 = 0, /* current x value of time-var function */
tvx1 = 0, /* next x value of time-var function */
tvdx, /* tvx1 - tvx0 */
tvy0 = 0, /* current y value of time-var function */
tvy1 = 0, /* next y value of time-var function */
tvdy, /* tvy1 - tvy0 */
tvslope = 0, /* tvdy / tvdx */
time, /* n / Rin */
invRin, /* 1. / Rin */
P = FL(0.0), /* Rin / Rout */
Rin = FL(0.0), /* input sampling rate */
Rout = FL(0.0); /* output sample rate */
int
i,k, /* index variables */
nread, /* number of bytes read */
tvflg = 0, /* flag for time-varying time-scaling */
tvnxt = 0, /* counter for stepping thru time-var func */
tvlen, /* length of time-varying function */
Chans = 1, /* number of channels */
chan, /* current channel */
Q = 2; /* quality factor */
FILE *tvfp = NULL; /* time-vary function file */
SOUNDIN *p;
int channel = ALLCHNLS;
MYFLT beg_time = FL(0.0), input_dur = FL(0.0), sr = FL(0.0);
char *infile = NULL, *bfile = NULL;
SNDFILE *inf = NULL;
char c, *s;
const char *envoutyp;
char outformch = 's';
unsigned outbufsiz = 0U;
SNDFILE *outfd = NULL;
OPARMS O;
int block = 0;
char err_msg[256];
O.outformat = AE_SHORT;
/* csound->e0dbfs = csound->dbfs_to_float = FL(1.0);*/
if ((envoutyp = csound->GetEnv(csound, "SFOUTYP")) != NULL) {
if (strcmp(envoutyp, "AIFF") == 0)
O.filetyp = TYP_AIFF;
else if (strcmp(envoutyp, "WAV") == 0)
O.filetyp = TYP_WAV;
else if (strcmp(envoutyp, "IRCAM") == 0)
O.filetyp = TYP_IRCAM;
else {
snprintf(err_msg, 256, Str("%s not a recognized SFOUTYP env setting"),
envoutyp);
dieu(csound, err_msg);
return -1;
}
}
/* call getopt to interpret commandline */
++argv;
while (--argc > 0) {
s = *argv++;
if (*s++ == '-') { /* read all flags: */
while ((c = *s++) != '\0') {
switch (c) {
case 'o':
FIND(Str("no outfilename"))
O.outfilename = s; /* soundout name */
for ( ; *s != '\0'; s++) ;
if (strcmp(O.outfilename, "stdin") == 0) {
csound->ErrorMsg(csound, Str("-o cannot be stdin"));
return -1;
}
#if defined WIN32
if (strcmp(O.outfilename, "stdout") == 0) {
csound->ErrorMsg(csound, Str("stdout audio not supported"));
return -1;
}
#endif
break;
case 'A':
O.filetyp = TYP_AIFF; /* AIFF output request*/
break;
case 'J':
O.filetyp = TYP_IRCAM; /* IRCAM output request */
break;
case 'W':
O.filetyp = TYP_WAV; /* WAV output request */
break;
case 'h':
O.filetyp = TYP_RAW; /* skip sfheader */
break;
case 'c':
case '8':
case 'a':
case 'u':
case 's':
case 'l':
case '3':
case 'f':
outformch = set_output_format(csound, c, outformch, &O);
break;
case 'R':
O.rewrt_hdr = 1;
break;
case 'H':
if (isdigit(*s)) {
int n;
sscanf(s, "%d%n", &O.heartbeat, &n);
s += n;
}
else O.heartbeat = 1;
break;
case 'N':
O.ringbell = 1; /* notify on completion */
break;
case 'Q':
FIND(Str("No Q argument"))
sscanf(s,"%d", &Q);
while (*++s);
break;
case 'P':
FIND(Str("No P argument"))
#if defined(USE_DOUBLE)
csound->sscanf(s,"%lf", &P);
#else
csound->sscanf(s,"%f", &P);
#endif
while (*++s);
break;
case 'r':
FIND(Str("No r argument"))
#if defined(USE_DOUBLE)
csound->sscanf(s,"%lf", &Rout);
#else
csound->sscanf(s,"%f", &Rout);
#endif
while (*++s);
break;
case 'i':
FIND(Str("No break file"))
tvflg = 1;
bfile = s;
while ((*s++)) {}; s--;
break;
default:
csound->Message(csound, Str("Looking at %c\n"), c);
usage(csound); /* this exits with error */
return -1;
}
}
}
else if (infile == NULL) {
infile = --s;
csound->Message(csound, Str("Infile set to %s\n"), infile);
}
else {
csound->Message(csound, Str("End with %s\n"), s);
usage(csound);
return -1;
}
}
if (infile == NULL) {
csound->Message(csound, Str("No input given\n"));
usage(csound);
return -1;
}
if ((inf = csound->SAsndgetset(csound, infile, &p, &beg_time,
&input_dur, &sr, channel)) == NULL) {
csound->ErrorMsg(csound, Str("error while opening %s"), infile);
return -1;
}
if (Rin == FL(0.0))
Rin = (MYFLT)p->sr;
if (Chans == 0)
Chans = (int) p->nchanls;
if (Chans == 0)
Chans = 1;
if ((P != FL(0.0)) && (Rout != FL(0.0))) {
strncpy(err_msg, Str("srconv: cannot specify both -r and -P"), 256);
goto err_rtn_msg;
}
if (P != FL(0.0))
Rout = Rin / P;
else if (Rout == FL(0.0))
Rout = Rin;
if (tvflg) {
P = FL(0.0); /* will be reset to max in time-vary function */
if ((tvfp = fopen(bfile, "r")) == NULL) {
strncpy(err_msg,
Str("srconv: cannot open time-vary function file"), 256);
goto err_rtn_msg;
}
/* register file to be closed by csoundReset() */
(void) csound->CreateFileHandle(csound, &tvfp, CSFILE_STD, bfile);
if (UNLIKELY(fscanf(tvfp, "%d", &tvlen) != 1))
csound->Message(csound, Str("Read failure\n"));
if(tvlen <= 0) {
strncpy(err_msg, Str("srconv: tvlen <= 0 "), 256);
goto err_rtn_msg;
}
fxval = (MYFLT*) csound->Malloc(csound, tvlen * sizeof(MYFLT));
fyval = (MYFLT*) csound->Malloc(csound, tvlen * sizeof(MYFLT));
i0 = fxval;
i1 = fyval;
for (i = 0; i < tvlen; i++, i0++, i1++) {
#ifdef USE_DOUBLE
if ((fscanf(tvfp, "%lf %lf", i0, i1)) != 2)
#else
if ((fscanf(tvfp, "%f %f", i0, i1)) != 2)
#endif
{
strncpy(err_msg, Str("srconv: too few x-y pairs "
"in time-vary function file"), 256);
goto err_rtn_msg;
}
if (*i1 > P)
P = *i1;
}
Rout = Rin / P; /* this is min Rout */
tvx0 = fxval[0];
tvx1 = fxval[1];
tvy0 = fyval[0];
tvy1 = fyval[1];
tvdx = tvx1 - tvx0;
if (tvx0 != FL(0.0)) {
strncpy(err_msg, Str("srconv: first x value "
"in time-vary function must be 0"), 256);
goto err_rtn_msg;
}
if (tvy0 <= FL(0.0)) {
strncpy(err_msg, Str("srconv: invalid initial y value "
"in time-vary function"),256);
goto err_rtn_msg;
}
if (tvdx <= FL(0.0)) {
strncpy(err_msg,
Str("srconv: invalid x values in time-vary function"),
256);
goto err_rtn_msg;
}
tvdy = tvy1 - tvy0;
tvslope = tvdy / tvdx;
tvnxt = 1;
}
/* This is not right ********* */
if (P != FL(0.0)) {
csound->SetUtilSr(csound,Rin);
}
if (P == FL(0.0)) {
csound->SetUtilSr(csound,Rout);
}
if (O.outformat == 0)
O.outformat = AE_SHORT;//p->format;
O.sfsampsize = csound->sfsampsize(FORMAT2SF(O.outformat));
if (O.filetyp == TYP_RAW) {
O.sfheader = 0;
O.rewrt_hdr = 0;
}
else
O.sfheader = 1;
#ifdef NeXT
if (O.outfilename == NULL && !O.filetyp)
O.outfilename = "test.snd";
else if (O.outfilename == NULL)
O.outfilename = "test";
#else
if (O.outfilename == NULL) {
if (O.filetyp == TYP_WAV)
O.outfilename = "test.wav";
else if (O.filetyp == TYP_AIFF)
O.outfilename = "test.aif";
else
O.outfilename = "test";
}
#endif
{
SF_INFO sfinfo;
char *name;
memset(&sfinfo, 0, sizeof(SF_INFO));
sfinfo.samplerate = (int) ((double) Rout + 0.5);
sfinfo.channels = (int) p->nchanls;
//printf("filetyp=%x outformat=%x\n", O.filetyp, O.outformat);
sfinfo.format = TYPE2SF(O.filetyp) | FORMAT2SF(O.outformat);
if (strcmp(O.outfilename, "stdout") != 0) {
name = csound->FindOutputFile(csound, O.outfilename, "SFDIR");
if (name == NULL) {
snprintf(err_msg, 256, Str("cannot open %s."), O.outfilename);
goto err_rtn_msg;
}
outfd = sf_open(name, SFM_WRITE, &sfinfo);
if (outfd != NULL)
csound->NotifyFileOpened(csound, name,
csound->type2csfiletype(O.filetyp,
O.outformat),
1, 0);
else {
snprintf(err_msg, 256, Str("libsndfile error: %s\n"), sf_strerror(NULL));
goto err_rtn_msg;
}
csound->Free(csound, name);
}
else
outfd = sf_open_fd(1, SFM_WRITE, &sfinfo, 1);
if (outfd == NULL) {
snprintf(err_msg, 256, Str("cannot open %s."), O.outfilename);
goto err_rtn_msg;
}
/* register file to be closed by csoundReset() */
(void) csound->CreateFileHandle(csound, &outfd, CSFILE_SND_W,
O.outfilename);
sf_command(outfd, SFC_SET_CLIPPING, NULL, SF_TRUE);
}
csound->SetUtilSr(csound, (MYFLT)p->sr);
csound->SetUtilNchnls(csound, Chans = p->nchanls);
outbufsiz = OBUF * O.sfsampsize; /* calc outbuf size */
csound->Message(csound, Str("writing %d-byte blks of %s to %s"),
outbufsiz, csound->getstrformat(O.outformat),
O.outfilename);
csound->Message(csound, " (%s)\n", csound->type2string(O.filetyp));
/* this program performs arbitrary sample-rate conversion
with high fidelity. the method is to step through the
input at the desired sampling increment, and to compute
the output points as appropriately weighted averages of
the surrounding input points. there are two cases to
consider: 1) sample rates are in a small-integer ratio -
weights are obtained from table, 2) sample rates are in
a large-integer ratio - weights are linearly
interpolated from table. */
/* calculate increment: if decimating, then window is impulse response of low-
pass filter with cutoff frequency at half of Rout; if interpolating,
then window is ipulse response of lowpass filter with cutoff frequency
at half of Rin. */
fdel = ((MYFLT) (L * Rin) / Rout);
del = (int) ((double) fdel + 0.5);
idel = (MYFLT) del;
if (del > L)
N = del;
if ((Q >= 1) && (Q <= 8))
M = Q * N * 10 + 1;
if (tvflg)
fdel = tvy0 * L;
invRin = FL(1.0) / Rin;
/* make window: the window is the product of a kaiser and a sin(x)/x */
window = (float*) csound->Calloc(csound, (size_t) (M + 2) * sizeof(float));
WinLen = (M-1)/2;
window += WinLen;
wLen = (M/2 - L) / L;
kaiser(M, window, WinLen, 1, (double) beta);
for (i = 1; i <= WinLen; i++) {
double tmp = (double) N;
tmp = tmp * sin(PI * (double) i / tmp) / (PI * (double) i);
window[i] = (float) ((double) window[i] * tmp);
}
if (Rout < Rin) {
#if 0
sum = (MYFLT) window[0];
for (i = L-1; i <= WinLen; i += L)
sum += (MYFLT) window[i];
sum = FL(2.0) / sum;
#else
sum = Rout / (Rin * (MYFLT) window[0]);
#endif
}
else
sum = FL(1.0) / (MYFLT) window[0];
window[0] = (float) ((double) window[0] * (double) sum);
for (i = 1; i <= WinLen; i++) {
window[i] = (float) ((double) window[i] * (double) sum);
*(window - i) = window[i];
}
window[WinLen + 1] = 0.0f;
/* set up input buffer: nextIn always points to the next empty
word in the input buffer. If the buffer is full, then
nextIn jumps back to the beginning, and the old values
are written over. */
input = (MYFLT*) csound->Calloc(csound, (size_t) IBUF * sizeof(MYFLT));
/* set up output buffer: nextOut always points to the next empty
word in the output buffer. If the buffer is full, then
it is flushed, and nextOut jumps back to the beginning. */
output = (MYFLT*) csound->Calloc(csound, (size_t) OBUF * sizeof(MYFLT));
nextOut = output;
/* initialization: */
nread = csound->getsndin(csound, inf, input, IBUF2, p);
for(i=0; i < nread; i++)
input[i] *= 1.0/csound->Get0dBFS(csound);
nMax = (long)(input_dur * p->sr);
nextIn = input + nread;
for (i = nread; i < IBUF2; i++)
*(nextIn++) = FL(0.0);
jMin = -(wLen + 1) * L;
mMax = IBUF2;
o = n = m = 0;
fo = FL(0.0);
/* main loop: If nMax is not specified it is assumed to be very large
and then readjusted when read detects the end of input. */
while (n < nMax) {
time = n * invRin;
/* case 1: (Rin / Rout) * 120 = integer */
if ((tvflg == 0) && (idel == fdel)) {
/* apply window (window is sampled at L * Rin) */
for (chan = 0; chan < Chans; chan++) {
*nextOut = FL(0.0);
k = Chans * (m - wLen) + chan - Chans;
if (k < 0)
k += IBUF;
wj = window + jMin - o;
for (i = -wLen; i <= wLen+1; i++){
wj += L;
k += Chans;
if (k >= IBUF)
k -= IBUF;
*nextOut += (MYFLT) *wj * *(input + k);
}
nextOut++;
if (nextOut >= (output + OBUF)) {
nextOut = output;
writebuffer(csound, output, &block, outfd, OBUF, &O);
}
}
/* move window (window advances by del samples at L*Rin sample rate) */
o += del;
while (o >= L) {
o -= L;
n++;
m++;
if ((Chans * (m + wLen + 1)) >= mMax) {
if (!csound->CheckEvents(csound))
csound->LongJmp(csound, 1);
mMax += IBUF2;
if (nextIn >= (input + IBUF))
nextIn = input;
nread = csound->getsndin(csound, inf, nextIn, IBUF2, p);
for(i=0; i < nread; i++)
input[i] *= 1.0/csound->Get0dBFS(csound);
nextIn += nread;
if (nread < IBUF2)
nMax = n + wLen + (nread / Chans) + 1;
for (i = nread; i < IBUF2; i++)
*(nextIn++) = FL(0.0);
}
if ((Chans * m) >= IBUF) {
m = 0;
mMax = IBUF2;
}
}
}
/* case 2: (Rin / Rout) * 120 = non-integer constant */
else {
/* apply window (window values are linearly interpolated) */
for (chan = 0; chan < Chans; chan++) {
*nextOut = FL(0.0);
o = (int)fo;
of = fo - o;
wj = window + jMin - o;
wj1 = wj + 1;
k = Chans * (m - wLen) + chan - Chans;
if (k < 0)
k += IBUF;
for (i = -wLen; i <= wLen+1; i++) {
wj += L;
wj1 += L;
k += Chans;
if (k >= IBUF)
k -= IBUF;
iw = (MYFLT) *wj + of * ((MYFLT) *wj1 - (MYFLT) *wj);
*nextOut += iw * *(input + k);
}
nextOut++;
if (nextOut >= (output + OBUF)) {
nextOut = output;
writebuffer(csound, output, &block, outfd, OBUF, &O);
}
}
/* move window */
fo += fdel;
while (fo >= fL) {
fo -= fL;
n++;
m++;
if ((Chans * (m + wLen + 1)) >= mMax) {
if (!csound->CheckEvents(csound))
csound->LongJmp(csound, 1);
mMax += IBUF2;
if (nextIn >= (input + IBUF))
nextIn = input;
nread = csound->getsndin(csound, inf, nextIn, IBUF2, p);
for(i=0; i < nread; i++)
input[i] *= 1.0/csound->Get0dBFS(csound);
nextIn += nread;
if (nread < IBUF2)
nMax = n + wLen + (nread / Chans) + 1;
for (i = nread; i < IBUF2; i++)
*(nextIn++) = FL(0.0);
}
if ((Chans * m) >= IBUF) {
m = 0;
mMax = IBUF2;
}
}
if (tvflg && (time > FL(0.0))) {
while (tvflg && (time >= tvx1)) {
if (++tvnxt >= tvlen)
tvflg = 0;
else {
tvx0 = tvx1;
tvx1 = fxval[tvnxt];
tvy0 = tvy1;
tvy1 = fyval[tvnxt];
tvdx = tvx1 - tvx0;
if (tvdx <= FL(0.0)) {
strncpy(err_msg, Str("srconv: invalid x values "
"in time-vary function"), 256);
goto err_rtn_msg;
}
tvdy = tvy1 - tvy0;
tvslope = tvdy / tvdx;
}
}
P = tvy0 + tvslope * (time - tvx0);
fdel = (MYFLT) L * P;
}
}
}
nread = nextOut - output;
writebuffer(csound, output, &block, outfd, nread, &O);
csound->Message(csound, "\n\n");
if (O.ringbell)
csound->MessageS(csound, CSOUNDMSG_REALTIME, "\a");
return 0;
err_rtn_msg:
csound->ErrorMsg(csound, err_msg);
return -1;
}
PUBLIC int csoundCompileArgs(CSOUND *csound, int argc, char **argv)
{
OPARMS *O = csound->oparms;
char *s;
FILE *xfile = NULL;
int n;
int csdFound = 0;
char *fileDir;
if ((n = setjmp(csound->exitjmp)) != 0) {
return ((n - CSOUND_EXITJMP_SUCCESS) | CSOUND_EXITJMP_SUCCESS);
}
if(csound->engineStatus & CS_STATE_COMP){
csound->Message(csound, Str("Csound is already started, call csoundReset()\n"
"before starting again \n"));
return CSOUND_ERROR;
}
if (--argc <= 0) {
dieu(csound, Str("insufficient arguments"));
}
/* command line: allow orc/sco/csd name */
csound->orcname_mode = 0; /* 0: normal, 1: ignore, 2: fail */
if (argdecode(csound, argc, argv) == 0)
csound->LongJmp(csound, 1);
/* do not allow orc/sco/csd name in .csound6rc */
csound->orcname_mode = 2;
checkOptions(csound);
if (csound->delayederrormessages) {
if (O->msglevel>8)
csound->Warning(csound, csound->delayederrormessages);
free(csound->delayederrormessages);
csound->delayederrormessages = NULL;
}
/* check for CSD file */
if (csound->orchname == NULL) {
if(csound->info_message_request) {
csound->info_message_request = 0;
csound->LongJmp(csound, 1);
}
else if(csound->oparms->daemon == 0)
dieu(csound, Str("no orchestra name"));
}
else if (csound->use_only_orchfile == 0
&& (csound->scorename == NULL || csound->scorename[0] == (char) 0)
&& csound->orchname[0] != '\0') {
/* FIXME: allow orc/sco/csd name in CSD file: does this work ? */
csound->orcname_mode = 0;
csound->Message(csound, "UnifiedCSD: %s\n", csound->orchname);
/* Add directory of CSD file to search paths before orchname gets
* replaced with temp orch name if default paths is enabled */
if (!O->noDefaultPaths) {
fileDir = csoundGetDirectoryForPath(csound, csound->orchname);
csoundAppendEnv(csound, "SADIR", fileDir);
csoundAppendEnv(csound, "SSDIR", fileDir);
csoundAppendEnv(csound, "INCDIR", fileDir);
csoundAppendEnv(csound, "MFDIR", fileDir);
csound->Free(csound, fileDir);
}
if(csound->orchname != NULL) {
csound->csdname = csound->orchname; /* save original CSD name */
if (!read_unified_file(csound, &(csound->orchname),
&(csound->scorename))) {
csound->Die(csound, Str("Reading CSD failed ... stopping"));
}
csdFound = 1;
}
}
/* IV - Feb 19 2005: run a second pass of argdecode so that */
/* command line options override CSD options */
/* this assumes that argdecode is safe to run multiple times */
csound->orcname_mode = 1; /* ignore orc/sco name */
argdecode(csound, argc, argv); /* should not fail this time */
/* some error checking */
if (csound->stdin_assign_flg &&
(csound->stdin_assign_flg & (csound->stdin_assign_flg - 1)) != 0) {
csound->Die(csound, Str("error: multiple uses of stdin"));
}
if (csound->stdout_assign_flg &&
(csound->stdout_assign_flg & (csound->stdout_assign_flg - 1)) != 0) {
csound->Die(csound, Str("error: multiple uses of stdout"));
}
/* done parsing csound6rc, CSD, and command line options */
if (csound->scorename == NULL && csound->scorestr==NULL) {
/* No scorename yet */
csound->scorestr = corfile_create_r("f0 800000000000.0\n");
corfile_flush(csound->scorestr);
if (O->RTevents)
csound->Message(csound, Str("realtime performance using dummy "
"numeric scorefile\n"));
}
else if (!csdFound && !O->noDefaultPaths){
/* Add directory of SCO file to search paths*/
fileDir = csoundGetDirectoryForPath(csound, csound->scorename);
csoundAppendEnv(csound, "SADIR", fileDir);
csoundAppendEnv(csound, "SSDIR", fileDir);
csoundAppendEnv(csound, "MFDIR", fileDir);
csound->Free(csound, fileDir);
}
/* Add directory of ORC file to search paths*/
if (!csdFound && !O->noDefaultPaths) {
fileDir = csoundGetDirectoryForPath(csound, csound->orchname);
csoundAppendEnv(csound, "SADIR", fileDir);
csoundAppendEnv(csound, "SSDIR", fileDir);
csoundAppendEnv(csound, "MFDIR", fileDir);
csound->Free(csound, fileDir);
}
if (csound->orchstr==NULL && csound->orchname) {
/* does not deal with search paths */
csound->Message(csound, Str("orchname: %s\n"), csound->orchname);
csound->orchstr = copy_to_corefile(csound, csound->orchname, NULL, 0);
if (csound->orchstr==NULL)
csound->Die(csound,
Str("Failed to open input file - %s\n"), csound->orchname);
corfile_puts("\n#exit\n", csound->orchstr);
corfile_putc('\0', csound->orchstr);
corfile_putc('\0', csound->orchstr);
//csound->orchname = NULL;
}
if (csound->xfilename != NULL)
csound->Message(csound, "xfilename: %s\n", csound->xfilename);
csoundLoadExternals(csound); /* load plugin opcodes */
/* VL: added this also to csoundReset() in csound.c */
if (csoundInitModules(csound) != 0)
csound->LongJmp(csound, 1);
if(csoundCompileOrc(csound, NULL) != 0){
if(csound->oparms->daemon == 0)
csoundDie(csound, Str("cannot compile orchestra"));
else {
/* VL -- 21-10-13 Csound does not need to die on
failure to compile. It can carry on, because new
instruments can be compiled again */
csound->Warning(csound, Str("cannot compile orchestra."));
csound->Warning(csound, Str("Csound will start with no instruments"));
}
}
csound->modules_loaded = 1;
s = csoundQueryGlobalVariable(csound, "_RTMIDI");
if (csound->enableHostImplementedMIDIIO == 1) {
if (s == NULL) {
s = "hostbased";
} else {
strcpy(s, "hostbased");
}
csoundSetConfigurationVariable(csound,"rtmidi", s);
}
/* IV - Jan 28 2005 */
print_benchmark_info(csound, Str("end of orchestra compile"));
if (!csoundYield(csound))
return -1;
/* IV - Oct 31 2002: now we can read and sort the score */
if (csound->scorename != NULL &&
(n = strlen(csound->scorename)) > 4 && /* if score ?.srt or ?.xtr */
(!strcmp(csound->scorename + (n - 4), ".srt") ||
!strcmp(csound->scorename + (n - 4), ".xtr"))) {
csound->Message(csound, Str("using previous %s\n"), csound->scorename);
//playscore = sortedscore = csound->scorename; /* use that one */
csound->scorestr = NULL;
csound->scorestr = copy_to_corefile(csound, csound->scorename, NULL, 1);
}
else {
//sortedscore = NULL;
if (csound->scorestr==NULL) {
csound->scorestr = copy_to_corefile(csound, csound->scorename, NULL, 1);
if (csound->scorestr==NULL)
csoundDie(csound, Str("cannot open scorefile %s"), csound->scorename);
}
csound->Message(csound, Str("sorting score ...\n"));
scsortstr(csound, csound->scorestr);
if (csound->keep_tmp) {
FILE *ff = fopen("score.srt", "w");
fputs(corfile_body(csound->scstr), ff);
fclose(ff);
}
}
if (csound->xfilename != NULL) { /* optionally extract */
if (!(xfile = fopen(csound->xfilename, "r")))
csoundDie(csound, Str("cannot open extract file %s"),csound->xfilename);
csoundNotifyFileOpened(csound, csound->xfilename,
CSFTYPE_EXTRACT_PARMS, 0, 0);
csound->Message(csound, Str(" ... extracting ...\n"));
scxtract(csound, csound->scstr, xfile);
fclose(xfile);
csound->tempStatus &= ~csPlayScoMask;
}
csound->Message(csound, Str("\t... done\n"));
/* copy sorted score name */
O->playscore = csound->scstr;
/* IV - Jan 28 2005 */
print_benchmark_info(csound, Str("end of score sort"));
if (O->syntaxCheckOnly) {
csound->Message(csound, Str("Syntax check completed.\n"));
return CSOUND_EXITJMP_SUCCESS;
}
/* open MIDI output (moved here from argdecode) */
if (O->Midioutname != NULL && O->Midioutname[0] == (char) '\0')
O->Midioutname = NULL;
if (O->FMidioutname != NULL && O->FMidioutname[0] == (char) '\0')
O->FMidioutname = NULL;
if (O->Midioutname != NULL || O->FMidioutname != NULL)
openMIDIout(csound);
return CSOUND_SUCCESS;
}
PUBLIC int csoundStart(CSOUND *csound) // DEBUG
{
OPARMS *O = csound->oparms;
int n;
/* if a CSD was not used, check options */
if(csound->csdname == NULL)
checkOptions(csound);
if(csound->engineStatus & CS_STATE_COMP){
csound->Message(csound, "Csound is already started, call csoundReset()\n"
"before starting again \n");
return CSOUND_ERROR;
}
{ /* test for dummy module request */
char *s;
if((s = csoundQueryGlobalVariable(csound, "_RTAUDIO")) != NULL)
if(strcmp(s, "null") == 0 || strcmp(s, "Null") == 0 ||
strcmp(s, "NULL") == 0) {
csound->Message(csound, Str("setting dummy interface\n"));
csound->SetPlayopenCallback(csound, playopen_dummy);
csound->SetRecopenCallback(csound, recopen_dummy);
csound->SetRtplayCallback(csound, rtplay_dummy);
csound->SetRtrecordCallback(csound, rtrecord_dummy);
csound->SetRtcloseCallback(csound, rtclose_dummy);
csound->SetAudioDeviceListCallback(csound, audio_dev_list_dummy);
}
/* and midi */
if(csound->enableHostImplementedMIDIIO == 0){
if((s = csoundQueryGlobalVariable(csound, "_RTMIDI")) != NULL)
if(strcmp(s, "null") == 0 || strcmp(s, "Null") == 0 ||
strcmp(s, "NULL") == 0) {
csound->SetMIDIDeviceListCallback(csound, midi_dev_list_dummy);
csound->SetExternalMidiInOpenCallback(csound, DummyMidiInOpen);
csound->SetExternalMidiReadCallback(csound, DummyMidiRead);
csound->SetExternalMidiInCloseCallback(csound, NULL);
csound->SetExternalMidiOutOpenCallback(csound, DummyMidiOutOpen);
csound->SetExternalMidiWriteCallback(csound, DummyMidiWrite);
csound->SetExternalMidiOutCloseCallback(csound, NULL);
}
}
else {
s = csoundQueryGlobalVariable(csound, "_RTMIDI");
strcpy(s, "hostbased");
csoundSetConfigurationVariable(csound,"rtmidi", s);
}
}
/* VL 30-12-12 csoundInitModules is always called here now to enable
Csound to start without calling csoundCompile, but directly from
csoundCompileOrc() and csoundReadSco()
*/
if(csound->modules_loaded == 0){
csoundLoadExternals(csound); /* load plugin opcodes */
if (csoundInitModules(csound) != 0)
csound->LongJmp(csound, 1);
csound->modules_loaded = 1;
}
if (csound->instr0 == NULL) { /* compile dummy instr0 to allow csound to
start with no orchestra */
csoundCompileOrc(csound, "idummy = 0 \n");
}
if ((n = setjmp(csound->exitjmp)) != 0) {
return ((n - CSOUND_EXITJMP_SUCCESS) | CSOUND_EXITJMP_SUCCESS);
}
/* if sound file type is still not known, check SFOUTYP */
if (O->filetyp <= 0) {
const char *envoutyp;
envoutyp = csoundGetEnv(csound, "SFOUTYP");
if (envoutyp != NULL && envoutyp[0] != '\0') {
if (strcmp(envoutyp, "AIFF") == 0)
O->filetyp = TYP_AIFF;
else if (strcmp(envoutyp, "WAV") == 0 || strcmp(envoutyp, "WAVE") == 0)
O->filetyp = TYP_WAV;
else if (strcmp(envoutyp, "IRCAM") == 0)
O->filetyp = TYP_IRCAM;
else if (strcmp(envoutyp, "RAW") == 0)
O->filetyp = TYP_RAW;
else {
dieu(csound, Str("%s not a recognised SFOUTYP env setting"),
envoutyp);
}
}
else
#if !defined(__MACH__)
O->filetyp = TYP_WAV; /* default to WAV if even SFOUTYP is unset */
#else
O->filetyp = TYP_AIFF; /* ... or AIFF on the Mac */
#endif
}
/* everything other than a raw sound file has a header */
O->sfheader = (O->filetyp == TYP_RAW ? 0 : 1);
if (O->Linein || O->Midiin || O->FMidiin)
O->RTevents = 1;
if (!O->sfheader)
O->rewrt_hdr = 0; /* cannot rewrite header of headerless file */
/* VL 9 04 15: these not need occur jointly anymore */
/*
if (O->sr_override || O->kr_override) {
if (!O->sr_override || !O->kr_override)
dieu(csound, Str("srate and krate overrides must occur jointly"));
} */
if (!O->outformat) /* if no audioformat yet */
O->outformat = AE_SHORT; /* default to short_ints */
O->sfsampsize = sfsampsize(FORMAT2SF(O->outformat));
O->informat = O->outformat; /* informat default */
if (O->numThreads > 1) {
void csp_barrier_alloc(CSOUND *, pthread_barrier_t **, int);
int i;
THREADINFO *current = NULL;
csound->multiThreadedBarrier1 = csound->CreateBarrier(O->numThreads);
csound->multiThreadedBarrier2 = csound->CreateBarrier(O->numThreads);
csp_barrier_alloc(csound, &(csound->barrier1), O->numThreads);
csp_barrier_alloc(csound, &(csound->barrier2), O->numThreads);
csound->multiThreadedComplete = 0;
for (i = 1; i < O->numThreads; i++) {
THREADINFO *t = csound->Malloc(csound, sizeof(THREADINFO));
t->threadId = csound->CreateThread(&kperfThread, (void *)csound);
t->next = NULL;
if (current == NULL) {
csound->multiThreadedThreadInfo = t;
}
else {
current->next = t;
}
current = t;
}
csound->WaitBarrier(csound->barrier2);
}
csound->engineStatus |= CS_STATE_COMP;
if(csound->oparms->daemon > 1)
UDPServerStart(csound,csound->oparms->daemon);
return musmon(csound);
}
