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;
}
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);
}
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 *sndgetset(CSOUND *csound, void *p_)
{
SOUNDIN *p = (SOUNDIN*) p_;
int n;
int framesinbuf, skipframes;
char *sfname;
SF_INFO sfinfo;
sfname = &(p->sfname[0]);
/* IV - Feb 26 2005: should initialise sfinfo structure */
memset(&sfinfo, 0, sizeof(SF_INFO));
sfinfo.format = (p->format ? /* store default sample format, */
((int) FORMAT2SF(p->format) | SF_FORMAT_RAW) : 0);
sfinfo.channels = 1; /* number of channels, */
if (p->analonly) /* and sample rate */
sfinfo.samplerate = (int) p->sr;
else
sfinfo.samplerate = (int) ((double) csound->esr + 0.5);
if (sfinfo.samplerate < 1)
sfinfo.samplerate = (int) ((double) DFLT_SR + 0.5);
/* open with full dir paths */
p->fd = csound->FileOpen2(csound, &(p->sinfd), CSFILE_SND_R,
sfname, &sfinfo, "SFDIR;SSDIR",
CSFTYPE_UNKNOWN_AUDIO, 0);
if (UNLIKELY(p->fd == NULL)) {
csound->ErrorMsg(csound, Str("soundin cannot open %s"), sfname);
goto err_return;
}
/* & record fullpath filnam */
sfname = csound->GetFileName(p->fd);
/* copy type from headata */
p->format = SF2FORMAT(sfinfo.format);
p->sampframsiz = (int) sfsampsize(sfinfo.format) * (int) sfinfo.channels;
p->nchanls = sfinfo.channels;
framesinbuf = (int) SNDINBUFSIZ / (int) p->nchanls;
p->bufsmps = framesinbuf * p->nchanls;
p->endfile = 0;
p->filetyp = SF2TYPE(sfinfo.format);
if (p->analonly) { /* anal: if sr param val */
if (p->sr != 0 && p->sr != sfinfo.samplerate) { /* use it */
csound->Warning(csound, Str("-s %d overriding soundfile sr %d"),
(int) p->sr, (int) sfinfo.samplerate);
sfinfo.samplerate = p->sr;
}
}
else if (sfinfo.samplerate != (int) ((double) csound->esr + 0.5)) {
csound->Warning(csound, /* non-anal: cmp w. esr */
"%s sr = %d, orch sr = %7.1f",
sfname, (int) sfinfo.samplerate, csound->esr);
}
if (UNLIKELY(p->channel != ALLCHNLS && p->channel > sfinfo.channels)) {
csound->ErrorMsg(csound, Str("error: req chan %d, file %s has only %d"),
(int) p->channel, sfname, (int) sfinfo.channels);
goto err_return;
}
p->sr = (int) sfinfo.samplerate;
if (csound->oparms_.msglevel & 3) {
csound->Message(csound, Str("audio sr = %d, "), (int) p->sr);
switch (p->nchanls) {
case 1: csound->Message(csound, Str("monaural")); break;
case 2: csound->Message(csound, Str("stereo")); break;
case 4: csound->Message(csound, Str("quad")); break;
case 6: csound->Message(csound, Str("hex")); break;
case 8: csound->Message(csound, Str("oct")); break;
default: csound->Message(csound, Str("%d-channels"), (int) p->nchanls);
}
if (p->nchanls > 1) {
if (p->channel == ALLCHNLS)
csound->Message(csound, Str(", reading %s channels"),
(p->nchanls == 2 ? Str("both") : Str("all")));
else
csound->Message(csound, Str(", reading channel %d"),
(int) p->channel);
}
csound->Message(csound, Str("\nopening %s infile %s\n"),
type2string(p->filetyp), sfname);
}
p->audrem = (int64_t) sfinfo.frames * (int64_t) sfinfo.channels;
p->framesrem = (int64_t) sfinfo.frames; /* find frames rem */
skipframes = (int) ((double) p->skiptime * (double) p->sr
+ (p->skiptime >= FL(0.0) ? 0.5 : -0.5));
if (skipframes < 0) {
n = -skipframes;
if (UNLIKELY(n > framesinbuf)) {
csound->ErrorMsg(csound, Str("soundin: invalid skip time"));
goto err_return;
}
n *= (int) sfinfo.channels;
p->inbufp = &(p->inbuf[0]);
p->bufend = p->inbufp;
do {
*(p->bufend++) = FL(0.0);
} while (--n);
}
else if (skipframes < framesinbuf) { /* if sound within 1st buf */
n = sreadin(csound, p->sinfd, p->inbuf, p->bufsmps, p);
p->bufend = &(p->inbuf[0]) + n;
p->inbufp = &(p->inbuf[0]) + (skipframes * (int) sfinfo.channels);
if (p->inbufp >= p->bufend) {
p->inbufp = p->bufend;
p->audrem = (int64_t) 0;
p->endfile = 1;
}
}
else if ((int64_t) skipframes >= p->framesrem) {
n = framesinbuf * (int) sfinfo.channels;
p->inbufp = &(p->inbuf[0]);
p->bufend = p->inbufp;
do {
*(p->bufend++) = FL(0.0);
} while (--n);
p->audrem = (int64_t) 0;
p->endfile = 1;
}
else { /* for greater skiptime: */
/* else seek to bndry */
if (UNLIKELY(sf_seek(p->sinfd, (sf_count_t) skipframes, SEEK_SET) < 0)) {
csound->ErrorMsg(csound, Str("soundin seek error"));
goto err_return;
}
/* now rd fulbuf */
if ((n = sreadin(csound, p->sinfd, p->inbuf, p->bufsmps, p)) == 0)
p->endfile = 1;
p->inbufp = p->inbuf;
p->bufend = p->inbuf + n;
}
if (p->framesrem != (int64_t) -1)
p->framesrem -= (int64_t) skipframes; /* sampleframes to EOF */
return p->sinfd; /* return the active fd */
err_return:
if (p->fd != NULL)
csound->FileClose(csound, p->fd);
p->sinfd = NULL;
p->fd = NULL;
return NULL;
}
