bool BackupDevice::save_state(EMUFILE* os)
{
u32 savePos = fpMC->ftell();
std::vector<u8> data(fsize);
fpMC->fseek(0, SEEK_SET);
fread((char*)&data[0], 1, fsize, fpMC->get_fp());
u32 version = 5;
//v0
write32le(version,os);
write32le(write_enable,os);
write32le(com,os);
write32le(addr_size,os);
write32le(addr_counter,os);
write32le((u32)state,os);
writebuffer(data,os);
writebuffer(data_autodetect,os);
//v1
write32le(addr,os);
//v2
write8le(motionInitState,os);
write8le(motionFlag,os);
//v3
writebool(reset_command_state,os);
//v4
write8le(write_protect,os);
//v5
write32le(savePos,os);
fpMC->fseek(savePos, SEEK_SET);
data.clear();
return true;
}
void printlines(int fd, char* argv, int argc)
{
int lines = 0;
char buffer[2] = {0};
int status = 0;
if(argc > 2)
{
writebuffer(STDOUT_FILENO, "==>");
writebuffer(STDOUT_FILENO, argv);
writebuffer(STDOUT_FILENO, "<==\n");
}
while(status = read(fd, (void*)buffer, 1) > 0 && lines < 10)
{
if(status < 0)
{
perror("Read");
break;
}
if(buffer[0] == '\n')
lines++;
writebuffer(STDOUT_FILENO, buffer);
}
if(lines < 10)
{
buffer[0] = '\n';
writebuffer(STDOUT_FILENO, buffer);
}
}
bool BackupDevice::save_state(std::ostream* os)
{
int version = 0;
write32le(version,os);
write32le(write_enable,os);
write32le(com,os);
write32le(addr_size,os);
write32le(addr_counter,os);
write32le((u32)state,os);
writebuffer(data,os);
writebuffer(data_autodetect,os);
return true;
}
/**
* writes a block of data to the char buffer. The size of buf need
* not actually be a full block size. In such cases, the remainder of
* the block is filled with null characters
* @param tar tar to be written to
* @param buf source block to read write from
* @param size size of the buf
* @return -1 on error
*/
int writeblock( TAR* tar, char * buf, int size )
{
errno = 0;
if( size > TAR_BLOCK )
{
errno = EINVAL;
return -1;
}
if( tar->eof || tar->err )
{
return -1;
}
if( tar->blockpos + TAR_BLOCK > TAR_BUFFER )
{
if( writebuffer( tar ) == -1 )
{
return -1;
}
}
memset( tar->buffer + tar->blockpos, 0, TAR_BLOCK );
memcpy( tar->buffer + tar->blockpos, buf, size );
tar->blockpos +=TAR_BLOCK;
return 0;
}
bool BackupDevice::save_state(EMUFILE* os)
{
size_t elements_read;
u32 version = 5;
u32 savePos = fpMC->ftell();
std::vector<u8> data(fsize);
fpMC->fseek(0, SEEK_SET);
if (data.size() != 0)
elements_read = fread(&data[0], 1, fsize, fpMC->get_fp());
if (elements_read != fsize)
printf(
"Expected %u bytes from saved state but read %lu.\n",
fsize,
elements_read
);
//v0
write32le(version,os);
write32le(write_enable,os);
write32le(com,os);
write32le(addr_size,os);
write32le(addr_counter,os);
write32le((u32)state,os);
writebuffer(data,os);
writebuffer(data_autodetect,os);
//v1
write32le(addr,os);
//v2
write8le(motionInitState,os);
write8le(motionFlag,os);
//v3
writebool(reset_command_state,os);
//v4
write8le(write_protect,os);
//v5
write32le(savePos,os);
fpMC->fseek(savePos, SEEK_SET);
data.clear();
return true;
}
bool BackupDevice::save_state(EMUFILE* os)
{
u32 version = 2;
//v0
write32le(version,os);
write32le(write_enable,os);
write32le(com,os);
write32le(addr_size,os);
write32le(addr_counter,os);
write32le((u32)state,os);
writebuffer(data,os);
writebuffer(data_autodetect,os);
//v1
write32le(addr,os);
//v2
write8le(motionInitState,os);
write8le(motionFlag,os);
return true;
}
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;
}
int sendcommand(int fd,char cmd,void *databuf)
{
int fd1=-1;
int i=0;
char lenb[7];
mcudev_t *mcuinfo=(mcudev_t *)databuf;
char byte=0;
memset(lenb,0,6);
strncpy(lenb,"732\r\n",6);
sbuf[0]=0;
switch(cmd)
{
case 'g':
case 'i':
case 'G':
case 'I':
byte='g';
writebuffer(fd,&byte,1);
usleep(300);
readbuffer(fd,sbuf,MAXBUFLEN);
break;
case 'r':
case 'R':
byte='r';
writebuffer(fd,&byte,1);
byte='h';
writebuffer(fd,&byte,1);
usleep(30);
readbuffer(fd,sbuf,MAXBUFLEN);
break;
case 's':
case 'S':
byte='s';
writebuffer(fd,&byte,1);
usleep(20);
for(i=0;i<5;i++)
{
writebuffer(fd,&lenb[i],1);
usleep(20);
}
usleep(300);
fprintf(stderr,"The code has been released\n");
break;
case 't':
case 'T':
byte='t';
writebuffer(fd,&byte,1);
usleep(100);
break;
case 'e':
case 'E':
byte='e';
writebuffer(fd,&byte,1);
usleep(260000L);
break;
case 'w':
case 'W':
if(mcuinfo == NULL) break;
fd1=fd;
byte='s';
writebuffer(fd1,&byte,1);
usleep(20);
for(i=0;i<5;i++)
{
writebuffer(fd1,&lenb[i],1);
usleep(30);
}
printf("writing file\n\r");
fprintf(stderr,"The code has been released\n");
byte='t';
writebuffer(fd1,&byte,1);
usleep(10);
fprintf(stderr,"Writting counters\n");
byte='e';
writebuffer(fd1,&byte,1);
usleep(250000L);
fprintf(stderr,"Erased\n");
byte='w';
writebuffer(fd1,&byte,1);
usleep(40);
usleep(100000L);
byte=0;
sendihx(fd1,&mcuinfo->image->Filename[0]);
usleep(100000L);
break;
default:
break;
}
}
static int dnoise(CSOUND *csound, int argc, char **argv)
{
OPARMS O;
csound->GetOParms(csound, &O);
MYFLT beg = -FL(1.0), end = -FL(1.0);
long Beg = 0, End = 99999999;
MYFLT
*ibuf1, /* pointer to start of input buffer */
*ibuf2, /* pointer to start of input buffer */
*obuf1, /* pointer to start of output buffer */
*obuf2, /* pointer to start of output buffer */
*fbuf, /* pointer to start of FFT buffer */
*aWin, /* pointer to center of analysis window */
*sWin, /* pointer to center of synthesis window */
*i0, /* pointer to real channels */
*i1, /* pointer to imaginary channels */
*j0, /* pointer to real channels */
*j1, /* pointer to imaginary channels */
*f, /* pointer to FFT buffer */
*f0, /* pointer to real channels */
*f1, /* pointer to imaginary channels */
*w, /* pointer to window */
*mbuf, /* m most recent frames of FFT */
*nbuf, /* m most recent frames of FFT */
*nref, /* noise reference buffer */
*rsum, /* running sum of magnitude-squared spectrum */
*ssum, /* running sum of magnitude-squared spectrum */
*ibp, /* pointer to next input to be read */
*ib0, /* pointer to output buffer */
*ib1, /* pointer to output buffer */
*ib2, /* pointer to output buffer */
*obp, /* pointer to next output to be read */
*ob0, /* pointer to output buffer */
*ob1, /* pointer to output buffer */
*ob2; /* pointer to output buffer */
int
N = 0, /* number of phase vocoder channels (bands) */
Np2, /* N+2 */
M = 0, /* length of aWin impulse response */
L = 0, /* length of sWin impulse response */
D = 0, /* decimation factor (default will be M/8) */
I = 0, /* interpolation factor (default will be I=D)*/
W = -1, /* filter overlap factor (determines M, L) */
ibuflen, /* size of ibuf */
obuflen, /* size of obuf */
aLen, /* half-length of analysis window */
sLen; /* half-length of synthesis window */
long
oCnt = 0L, /* number of samples written to output */
nI, /* current input (analysis) sample */
nO, /* current output (synthesis) sample */
nImodR, /* current input sample mod R */
nMaxOut, /* last output (synthesis) sample */
nMin, /* first input (analysis) sample */
nMax, /* last input sample (unless EOF) */
lnread, /* total input samples read */
lj, /* to satisfy lame Microsoft compiler */
lk; /* to satisfy lame Microsoft compiler */
SNDFILE *fp = NULL; /* noise reference file */
MYFLT
Ninv, /* 1. / N */
//RoverTwoPi, /* R/D divided by 2*Pi */
//TwoPioverR, /* 2*Pi divided by R/I */
sum, /* scale factor for renormalizing windows */
//rIn, /* decimated sampling rate */
//rOut, /* pre-interpolated sampling rate */
invR, /* 1. / srate */
time, /* nI / srate */
gain, /* gain of noise gate */
g0 = -FL(40.0),/* minimum gain for noise gate */
g0m, /* 1. - g0 */
th = FL(30.0), /* threshold above noise reference (dB) */
avg, /* average square energy */
fac, /* factor in gain computation */
minv, /* 1 / m */
R = -FL(1.0); /* input sampling rate */
int i,j,k, /* index variables */
ibs, /* current starting location in input buffer */
ibc, /* current location in input buffer */
obs, /* current starting location in output buffer */
obc, /* current location in output buffer */
m = 5, /* number of frames to save in mbuf */
mi = 0, /* frame offset index in mbuf */
mj, /* delayed offset index in mbuf */
md, /* number of frames of delay in mbuf (m/2) */
mp, /* mi * Np2 */
sh = 1, /* sharpness control for noise gate gain */
nread, /* number of bytes read */
N2, /* N/2 */
Meven = 0, /* flag for even M */
Leven = 0, /* flag for even L */
Verbose = 0,/* flag for verbose output to stderr */
Chans = -1, /* number of audio input channels (stereo = 2) */
chan, /* channel counter */
flag = 1, /* end-of-input flag */
first = 0; /* first-time-thru flag */
SOUNDIN *p, *pn;
char *infile = NULL, *nfile = NULL;
SNDFILE *inf = NULL, *outfd = NULL;
char c, *s;
int channel = ALLCHNLS;
MYFLT beg_time = FL(0.0), input_dur = FL(0.0), sr = FL(0.0);
MYFLT beg_ntime = FL(0.0), input_ndur = FL(0.0), srn = FL(0.0);
const char *envoutyp = NULL;
unsigned int outbufsiz = 0U;
int nrecs = 0;
/* audio is now normalised after call to getsndin */
/* 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 {
csound->Message(csound, Str("%s not a recognised SFOUTYP env setting"),
envoutyp);
return -1;
}
}
{
++argv;
while (--argc>0) {
s = *argv++;
if (*s++ == '-') { /* read all flags: */
while ((c = *s++) != '\0') {
switch (c) {
case 'o':
FIND("no outfilename");
O.outfilename = s; /* soundout name */
for ( ; *s != '\0'; s++) ;
if (strcmp(O.outfilename, "stdin") == 0) {
csound->Message(csound, Str("-o cannot be stdin\n"));
return -1;
}
break;
case 'i':
FIND("no noisefilename");
nfile = s;
for ( ; *s != '\0'; s++) ;
break;
case 'A':
if (O.filetyp == TYP_WAV)
csound->Warning(csound,
Str("-A overriding local default WAV out"));
O.filetyp = TYP_AIFF; /* AIFF output request*/
break;
case 'J':
if (O.filetyp == TYP_AIFF || O.filetyp == TYP_WAV)
csound->Warning(csound, Str("-J overriding local default "
"AIFF/WAV out"));
O.filetyp = TYP_IRCAM; /* IRCAM output request */
break;
case 'W':
if (O.filetyp == TYP_AIFF)
csound->Warning(csound,
Str("-W overriding local default AIFF out"));
O.filetyp = TYP_WAV; /* WAV output request */
break;
case 'h':
O.filetyp = TYP_RAW;
O.sfheader = 0; /* skip sfheader */
break;
case 'c':
O.outformat = AE_CHAR; /* 8-bit char soundfile */
break;
case '8':
O.outformat = AE_UNCH; /* 8-bit unsigned char file */
break;
case 'a':
O.outformat = AE_ALAW; /* a-law soundfile */
break;
case 'u':
O.outformat = AE_ULAW; /* mu-law soundfile */
break;
case 's':
O.outformat = AE_SHORT; /* short_int soundfile */
break;
case 'l':
O.outformat = AE_LONG; /* long_int soundfile */
break;
case 'f':
O.outformat = AE_FLOAT; /* float soundfile */
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 't':
FIND(Str("no t argument"));
#if defined(USE_DOUBLE)
csound->sscanf(s,"%lf",&th);
#else
csound->sscanf(s,"%f",&th);
#endif
while (*++s);
break;
case 'S':
FIND("no s arg");
sscanf(s,"%d", &sh);
while (*++s);
break;
case 'm':
FIND("no m arg");
#if defined(USE_DOUBLE)
csound->sscanf(s,"%lf",&g0);
#else
csound->sscanf(s,"%f",&g0);
#endif
while (*++s);
break;
case 'n':
FIND(Str("no n argument"));
sscanf(s,"%d", &m);
while (*++s);
break;
case 'b':
FIND(Str("no b argument"));
#if defined(USE_DOUBLE)
csound->sscanf(s,"%lf",&beg);
#else
csound->sscanf(s,"%f",&beg);
#endif
while (*++s);
break;
case 'B': FIND(Str("no B argument"));
sscanf(s,"%ld", &Beg);
while (*++s);
break;
case 'e': FIND("no e arg");
#if defined(USE_DOUBLE)
csound->sscanf(s,"%lf",&end);
#else
csound->sscanf(s,"%f",&end);
#endif
while (*++s);
break;
case 'E': FIND(Str("no E argument"));
sscanf(s,"%ld", &End);
while (*++s);
break;
case 'N': FIND(Str("no N argument"));
sscanf(s,"%d", &N);
while (*++s);
break;
case 'M': FIND(Str("no M argument"));
sscanf(s,"%d", &M);
while (*++s);
break;
case 'L': FIND(Str("no L argument"));
sscanf(s,"%d", &L);
while (*++s);
break;
case 'w': FIND(Str("no w argument"));
sscanf(s,"%d", &W);
while (*++s);
break;
case 'D': FIND(Str("no D argument"));
sscanf(s,"%d", &D);
while (*++s);
break;
case 'V':
Verbose = 1; break;
default:
csound->Message(csound, Str("Looking at %c\n"), c);
return dnoise_usage(csound, -1); /* this exits with error */
}
}
}
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);
return dnoise_usage(csound, -1);
}
}
}
if (infile == NULL) {
csound->Message(csound, Str("dnoise: no input file\n"));
return dnoise_usage(csound, -1);
}
if (nfile == NULL) {
csound->Message(csound, Str("Must have an example noise file (-i name)\n"));
return -1;
}
if ((inf = csound->SAsndgetset(csound, infile, &p, &beg_time,
&input_dur, &sr, channel)) == NULL) {
csound->Message(csound, Str("error while opening %s"), infile);
return -1;
}
if (O.outformat == 0) O.outformat = 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;
if (O.outfilename == NULL)
O.outfilename = "test";
{
SF_INFO sfinfo;
char *name;
memset(&sfinfo, 0, sizeof(SF_INFO));
sfinfo.samplerate = (int) p->sr;
sfinfo.channels = (int) p->nchanls;
sfinfo.format = TYPE2SF(O.filetyp) | FORMAT2SF(O.outformat);
if (strcmp(O.outfilename, "stdout") != 0) {
name = csound->FindOutputFile(csound, O.outfilename, "SFDIR");
if (name == NULL) {
csound->Message(csound, Str("cannot open %s.\n"), O.outfilename);
return -1;
}
outfd = sf_open(name, SFM_WRITE, &sfinfo);
if (outfd != NULL)
csound->NotifyFileOpened(csound, name,
csound->type2csfiletype(O.filetyp, O.outformat), 1, 0);
csound->Free(csound, name);
}
else
outfd = sf_open_fd(1, SFM_WRITE, &sfinfo, 1);
if (outfd == NULL) {
csound->Message(csound, Str("cannot open %s."), O.outfilename);
return -1;
}
/* 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);
/* read header info */
if (R < FL(0.0))
R = (MYFLT)p->sr;
if (Chans < 0)
Chans = (int) p->nchanls;
p->nchanls = Chans;
if (Chans > 2) {
csound->Message(csound, Str("dnoise: input MUST be mono or stereo\n"));
return -1;
}
/* read noise reference file */
if ((fp = csound->SAsndgetset(csound, nfile, &pn, &beg_ntime,
&input_ndur, &srn, channel)) == NULL) {
csound->Message(csound, Str("dnoise: cannot open noise reference file\n"));
return -1;
}
if (sr != srn) {
csound->Message(csound, Str("Incompatible sample rates\n"));
return -1;
}
/* calculate begin and end times in NOISE file */
if (beg >= FL(0.0)) Beg = (long) (beg * R);
if (end >= FL(0.0)) End = (long) (end * R);
else if (End == 99999999) End = (long) (input_ndur * R);
nMin = Beg * Chans; /* total number of samples to skip */
nMax = End - Beg; /* number of samples per channel to process */
/* largest valid FFT size is 8192 */
if (N == 0)
N = 1024;
for (i = 1; i < 4096; i *= 2)
if (i >= N)
break;
if (i != N)
csound->Message(csound,
Str("dnoise: warning - N not a valid power of two; "
"revised N = %d\n"),i);
N = i;
N2 = N / 2;
Np2 = N + 2;
Ninv = FL(1.0) / N;
if (W != -1) {
if (M != 0)
csound->Message(csound,
Str("dnoise: warning - do not specify both M and W\n"));
else if (W == 0)
M = 4*N;
else if (W == 1)
M = 2*N;
else if (W == 2)
M = N;
else if (W == 3)
M = N2;
else
csound->Message(csound, Str("dnoise: warning - invalid W ignored\n"));
}
if (M == 0)
M = N;
if ((M%2) == 0)
Meven = 1;
if (L == 0)
L = M;
if ((L%2) == 0)
Leven = 1;
if (M < 7) {
csound->Message(csound, Str("dnoise: warning - M is too small\n"));
exit(~1);
}
if (D == 0)
D = M / 8;
I = D;
lj = (long) M + 3 * (long) D;
lj *= (long) Chans;
if (lj > 32767) {
csound->Message(csound, Str("dnoise: M too large\n"));
return -1;
}
lj = (long) L + 3 * (long) I;
lj *= (long) Chans;
if (lj > 32767) {
csound->Message(csound, Str("dnoise: L too large\n"));
return -1;
}
ibuflen = Chans * (M + 3 * D);
obuflen = Chans * (L + 3 * I);
outbufsiz = obuflen * sizeof(MYFLT); /* calc outbuf size */
#if 0
outbuf = csound->Malloc(csound, (size_t) outbufsiz); /* & alloc bufspace */
#endif
csound->Message(csound, Str("writing %u-byte blks of %s to %s"),
outbufsiz, csound->getstrformat(O.outformat),
O.outfilename);
csound->Message(csound, " (%s)\n", csound->type2string(O.filetyp));
/* spoutran = spoutsf; */
minv = FL(1.0) / (MYFLT)m;
md = m / 2;
g0 = (MYFLT) pow(10.0,(double)(0.05*(double)g0));
g0m = FL(1.0) - g0;
th = (MYFLT) pow(10.0,(double)(0.05*(double)th));
/* set up analysis window: The window is assumed to be symmetric
with M total points. After the initial memory allocation,
aWin always points to the midpoint of the window (or one
half sample to the right, if M is even); aLen is half the
true window length (rounded down). If the window duration
is longer than the transform (M > N), then the window is
multiplied by a sin(x)/x function to meet the condition:
aWin[Ni] = 0 for i != 0. In either case, the
window is renormalized so that the phase vocoder amplitude
estimates are properly scaled. */
if ((aWin = (MYFLT*) csound->Calloc(csound,
(M+Meven) * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
aLen = M/2;
aWin += aLen;
hamming(aWin, aLen, Meven);
for (i = 1; i <= aLen; i++) {
aWin[-i] = aWin[i-1];
}
if (M > N) {
if (Meven)
*aWin *= (MYFLT)N * (MYFLT) sin(PI*0.5/(double)N) /( PI_F*FL(0.5));
for (i = 1; i <= aLen; i++)
aWin[i] *= (MYFLT) (N * sin(PI * ((double) i + 0.5 * (double) Meven)
/ (double) N)
/ (PI * (i + 0.5 * (double) Meven)));
for (i = 1; i <= aLen; i++)
aWin[-i] = aWin[i - Meven];
}
sum = FL(0.0);
for (i = -aLen; i <= aLen; i++)
sum += aWin[i];
sum = FL(2.0) / sum; /* factor of 2 comes in later in trig identity */
for (i = -aLen; i <= aLen; i++)
aWin[i] *= sum;
/* set up synthesis window: For the minimal mean-square-error
formulation (valid for N >= M), the synthesis window
is identical to the analysis window (except for a
scale factor), and both are even in length. If N < M,
then an interpolating synthesis window is used. */
if ((sWin = (MYFLT*) csound->Calloc(csound,
(L+Leven) * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
sLen = L/2;
sWin += sLen;
if (M <= N) {
hamming(sWin, sLen, Leven);
for (i = 1; i <= sLen; i++)
sWin[-i] = sWin[i - Leven];
for (i = -sLen; i <= sLen; i++)
sWin[i] *= sum;
sum = FL(0.0);
for (i = -sLen; i <= sLen; i+=I)
sum += sWin[i] * sWin[i];
sum = FL(1.0) / sum;
for (i = -sLen; i <= sLen; i++)
sWin[i] *= sum;
}
else {
hamming(sWin, sLen, Leven);
for (i = 1; i <= sLen; i++)
sWin[-i] = sWin[i - Leven];
if (Leven)
*sWin *= (MYFLT) (I * sin(PI*0.5/(double) I) / (PI*0.5));
for (i = 1; i <= sLen; i++)
sWin[i] *= (MYFLT)(I * sin(PI * ((double) i + 0.5 * (double) Leven)
/ (double) I)
/ (PI * ((double) i + 0.5 * (double) Leven)));
for (i = 1; i <= sLen; i++)
sWin[i] = sWin[i - Leven];
sum = FL(1.0) / sum;
for (i = -sLen; i <= sLen; i++)
sWin[i] *= sum;
}
/* set up input buffer: nextIn always points to the next empty
word in the input buffer (i.e., the sample following
sample number (n + aLen)). If the buffer is full,
then nextIn jumps back to the beginning, and the old
values are written over. */
if ((ibuf1 = (MYFLT *) csound->Calloc(csound,
ibuflen * sizeof(MYFLT))) == NULL) {
ERR("dnoise: insufficient memory\n");
}
if ((ibuf2 = (MYFLT *) csound->Calloc(csound,
ibuflen * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
/* set up output buffer: nextOut always points to the next word
to be shifted out. The shift is simulated by writing the
value to the standard output and then setting that word
of the buffer to zero. When nextOut reaches the end of
the buffer, it jumps back to the beginning. */
if ((obuf1 = (MYFLT*) csound->Calloc(csound,
obuflen * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
if ((obuf2 = (MYFLT*) csound->Calloc(csound,
obuflen * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
/* set up analysis buffer for (N/2 + 1) channels: The input is real,
so the other channels are redundant. */
if ((fbuf = (MYFLT*) csound->Calloc(csound, Np2 * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
/* noise reduction: calculate noise reference by taking as many
consecutive FFT's as possible in noise soundfile, and
averaging them all together. Multiply by th*th to
establish threshold for noise-gating in each bin. */
if ((nref = (MYFLT*) csound->Calloc(csound,
(N2 + 1) * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
if ((mbuf = (MYFLT*) csound->Calloc(csound,
(m * Np2) * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
if ((nbuf = (MYFLT*) csound->Calloc(csound,
(m * Np2) * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
if ((rsum = (MYFLT*) csound->Calloc(csound,
(N2 + 1) * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
if ((ssum = (MYFLT*) csound->Calloc(csound,
(N2 + 1) * sizeof(MYFLT))) == NULL) {
ERR(Str("dnoise: insufficient memory\n"));
}
/* skip over nMin samples */
while (nMin > (long)ibuflen) {
if (!csound->CheckEvents(csound))
csound->LongJmp(csound, 1);
nread = csound->getsndin(csound, fp, ibuf1, ibuflen, pn);
for(i=0; i < nread; i++)
ibuf1[i] *= 1.0/csound->Get0dBFS(csound);
if (nread < ibuflen) {
ERR(Str("dnoise: begin time is greater than EOF of noise file!"));
}
nMin -= (long) ibuflen;
}
if (!csound->CheckEvents(csound))
csound->LongJmp(csound, 1);
i = (int) nMin;
nread = csound->getsndin(csound, fp, ibuf1, i, pn);
for(i=0; i < nread; i++)
ibuf1[i] *= 1.0/csound->Get0dBFS(csound);
if (nread < i) {
ERR(Str("dnoise: begin time is greater than EOF of noise file!"));
}
k = 0;
lj = Beg; /* single channel only */
while (lj < End) {
if (!csound->CheckEvents(csound))
csound->LongJmp(csound, 1);
lj += (long) N;
nread = csound->getsndin(csound, fp, fbuf, N, pn);
for(i=0; i < nread; i++)
fbuf[i] *= 1.0/csound->Get0dBFS(csound);
if (nread < N)
break;
fbuf[N] = FL(0.0);
fbuf[N + 1] = FL(0.0);
fast(csound, fbuf, N);
f = fbuf;
for (i = 0; i <= N+1; i++, f++)
*f *= Ninv;
f = nref;
i0 = fbuf;
i1 = i0 + 1;
for (i = 0; i <= N2; i++, f++, i0 += 2, i1 += 2) {
fac = *i0 * *i0; /* fac = fbuf[2*i] * fbuf[2*i]; */
fac += *i1 * *i1; /* fac += fbuf[2*i+1] * fbuf[2*i+1]; */
*f += fac; /* nref[i] += fac; */
}
k++;
}
if (k == 0) {
ERR(Str("dnoise: not enough samples of noise reference\n"));
}
fac = th * th / k;
f = nref;
for (i = 0; i <= N2; i++, f++)
*f *= fac; /* nref[i] *= fac; */
/* initialization: input time starts negative so that the rightmost
edge of the analysis filter just catches the first non-zero
input samples; output time equals input time. */
/* zero ibuf1 to start */
f = ibuf1;
for (i = 0; i < ibuflen; i++, f++)
*f = FL(0.0);
if (!csound->CheckEvents(csound))
csound->LongJmp(csound, 1);
/* fill ibuf2 to start */
nread = csound->getsndin(csound, inf, ibuf2, ibuflen, p);
/* nread = read(inf, ibuf2, ibuflen*sizeof(MYFLT)); */
/* nread /= sizeof(MYFLT); */
for(i=0; i < nread; i++)
ibuf2[i] *= 1.0/csound->Get0dBFS(csound);
lnread = nread;
f = ibuf2 + nread;
for (i = nread; i < ibuflen; i++, f++)
*f = FL(0.0);
//rIn = ((MYFLT) R / D);
//rOut = ((MYFLT) R / I);
invR = FL(1.0) / R;
nI = -(aLen / D) * D; /* input time (in samples) */
nO = nI; /* output time (in samples) */
ibs = ibuflen + Chans * (nI - aLen - 1); /* starting position in ib1 */
ib1 = ibuf1; /* filled with zeros to start */
ib2 = ibuf2; /* first buffer of speech */
obs = Chans * (nO - sLen - 1); /* starting position in ob1 */
while (obs < 0) {
obs += obuflen;
first++;
}
ob1 = obuf1; /* filled with garbage to start */
ob2 = obuf2; /* first output buffer */
nImodR = nI; /* for reporting progress */
mi = 0;
mj = m - md;
if (mj >= m)
mj = 0;
mp = mi * Np2;
nMax = (long)(input_dur * R); /* Do it all */
nMaxOut = (long) (nMax * Chans);
while (nI < (nMax + aLen)) {
time = nI * invR;
for (chan = 0; chan < Chans; chan++) {
/* prepare for analysis: always begin reading from ib1 */
/* always begin writing to ob1 */
if (ibs >= ibuflen) { /* done reading from ib1 */
if (!csound->CheckEvents(csound))
csound->LongJmp(csound, 1);
/* swap buffers */
ib0 = ib1;
ib1 = ib2;
ib2 = ib0;
ibs -= ibuflen;
/* fill ib2 */
nread = csound->getsndin(csound, inf, ib2, ibuflen, p);
for(i=0; i < nread; i++)
ibuf2[i] *= 1.0/csound->Get0dBFS(csound);
lnread += nread;
f = ib2 + nread;
for (i = nread; i < ibuflen; i++, f++)
*f = FL(0.0);
}
ibc = ibs + chan;
ibp = ib1 + ibs + chan;
if (obs >= obuflen) { /* done writing to ob1 */
/* dump ob1 (except at beginning) */
if (first > 0) {
first--;
}
else {
if ((oCnt + obuflen) < nMaxOut) {
oCnt += writebuffer(csound, outfd, ob1, obuflen, &nrecs, &O);
}
else {
i = (int) (nMaxOut - oCnt);
oCnt += writebuffer(csound, outfd, ob1, i, &nrecs, &O);
}
}
/* zero ob1 */
f = ob1;
for (i = 0; i < obuflen; i++, f++)
*f = FL(0.0);
/* swap buffers */
ob0 = ob1;
ob1 = ob2;
ob2 = ob0;
obs -= obuflen;
}
obc = obs + chan;
obp = ob1 + obs + chan;
/* analysis: The analysis subroutine computes the complex output at
time n of (N/2 + 1) of the phase vocoder channels. It operates
on input samples (n - aLen) thru (n + aLen).
It expects aWin to point to the center of a
symmetric window of length (2 * aLen + 1). It is the
responsibility of the main program to ensure that these values
are correct. The results are returned in fbuf as succesive
pairs of real and imaginary values for the lowest (N/2 + 1)
channels. The subroutine fast implements an
efficient FFT call for a real input sequence. */
f = fbuf;
for (i = 0; i < N+2; i++, f++)
*f = FL(0.0);
lk = nI - (long) aLen - 1; /*time shift*/
while ((long) lk < 0L)
lk += (long) N;
k = (int) (lk % (long) N);
f = fbuf + k;
w = aWin - aLen;
for (i = -aLen; i <= aLen; i++, k++, f++, w++) {
ibp += Chans;
ibc += Chans;
if (ibc >= ibuflen) {
ibc = chan;
ibp = ib2 + chan;
}
if (k >= N) {
k = 0;
f = fbuf;
}
*f += *w * *ibp;
}
fast(csound, fbuf, N);
/* noise reduction: for each bin, calculate average magnitude-squared
and calculate corresponding gain. Apply this gain to delayed
FFT values in mbuf[mj*Np2 + i?]. */
if (chan == 0) {
f = rsum;
i0 = mbuf + mp;
i1 = i0 + 1;
j0 = mbuf + mj * Np2;
j1 = j0 + 1;
f0 = fbuf;
f1 = f0 + 1;
for (i = 0; i <= N2;
i++, f++, i0+=2, i1+=2, f0+=2, f1+=2, j0+=2, j1+=2) {
/*
* ii0 = 2 * i;
* ii1 = ii0 + 1;
*
* rsum[i] -= mbuf[mp + ii0] * mbuf[mp + ii0];
* rsum[i] -= mbuf[mp + ii1] * mbuf[mp + ii1];
* rsum[i] += fbuf[ii0] * fbuf[ii0];
* rsum[i] += fbuf[ii1] * fbuf[ii1];
*/
*f -= *i0 * *i0;
*f -= *i1 * *i1;
*f += *f0 * *f0;
*f += *f1 * *f1;
avg = minv * *f; /* avg = minv * rsum[i]; */
if (avg < FL(0.0))
avg = FL(0.0);
if (avg == FL(0.0))
fac = FL(0.0);
else
fac = avg / (avg + nref[i]);
for (j = 1; j < sh; j++)
fac *= fac;
gain = g0m * fac + g0;
/*
* mbuf[mp + ii0] = fbuf[ii0];
* mbuf[mp + ii1] = fbuf[ii1];
* fbuf[ii0] = gain * mbuf[mj*Np2 + ii0];
* fbuf[ii1] = gain * mbuf[mj*Np2 + ii1];
*/
*i0 = *f0;
*i1 = *f1;
*f0 = gain * *j0;
*f1 = gain * *j1;
}
}
else {
f = ssum;
i0 = nbuf + mp;
i1 = i0 + 1;
j0 = nbuf + mj * Np2;
j1 = j0 + 1;
f0 = fbuf;
f1 = f0 + 1;
for (i = 0; i <= N2;
i++, f++, i0+=2, i1+=2, f0+=2, f1+=2, j0+=2, j1+=2) {
/*
* ii0 = 2 * i;
* ii1 = ii0 + 1;
*
* ssum[i] -= nbuf[mp + ii0] * nbuf[mp + ii0];
* ssum[i] -= nbuf[mp + ii1] * nbuf[mp + ii1];
* ssum[i] += fbuf[ii0] * fbuf[ii0];
* ssum[i] += fbuf[ii1] * fbuf[ii1];
*/
*f -= *i0 * *i0;
*f -= *i1 * *i1;
*f += *f0 * *f0;
*f += *f1 * *f1;
avg = minv * *f; /* avg = minv * ssum[i]; */
if (avg < FL(0.0))
avg = FL(0.0);
if (avg == FL(0.0))
fac = FL(0.0);
else
fac = avg / (avg + nref[i]);
for (j = 1; j < sh; j++)
fac *= fac;
gain = g0m * fac + g0;
/*
* nbuf[mp + ii0] = fbuf[ii0];
* nbuf[mp + ii1] = fbuf[ii1];
* fbuf[ii0] = gain * nbuf[mj*Np2 + ii0];
* fbuf[ii1] = gain * nbuf[mj*Np2 + ii1];
*/
*i0 = *f0;
*i1 = *f1;
*f0 = gain * *j0;
*f1 = gain * *j1;
}
}
if (chan == (Chans - 1)) {
if (++mi >= m)
mi = 0;
if (++mj >= m)
mj = 0;
mp = mi * Np2;
}
/* synthesis: The synthesis subroutine uses the Weighted Overlap-Add
technique to reconstruct the time-domain signal. The (N/2 + 1)
phase vocoder channel outputs at time n are inverse Fourier
transformed, windowed, and added into the output array. */
fsst(csound, fbuf, N);
lk = nO - (long) sLen - 1; /*time shift*/
while (lk < 0)
lk += (long) N;
k = (int) (lk % (long) N);
f = fbuf + k;
w = sWin - sLen;
for (i = -sLen; i <= sLen; i++, k++, f++, w++) {
obp += Chans;
obc += Chans;
if (obc >= obuflen) {
obc = chan;
obp = ob2 + chan;
}
if (k >= N) {
k = 0;
f = fbuf;
}
*obp += *w * *f;
}
if (flag) {
if (nread < ibuflen) { /* EOF detected */
flag = 0;
if ((lnread / Chans) < nMax)
nMax = (lnread / Chans);
}
}
}
ibs += (Chans * D); /* starting point in ibuf */
obs += (Chans * I); /* starting point in obuf */
nI += (long) D; /* increment time */
nO += (long) I;
if (Verbose) {
nImodR += D;
if (nImodR > (long) R) {
nImodR -= (long) R;
csound->Message(csound,
Str("%5.1f seconds of input complete\n"),(time+D*invR));
}
}
}
nMaxOut = (long) (nMax * Chans);
i = (int) (nMaxOut - oCnt);
if (i > obuflen) {
writebuffer(csound, outfd, ob1, obuflen, &nrecs, &O);
i -= obuflen;
ob1 = ob2;
}
if (i > 0)
writebuffer(csound, outfd, ob1, i, &nrecs, &O);
/* csound->rewriteheader(outfd); */
csound->Message(csound, "\n\n");
if (Verbose) {
csound->Message(csound, Str("processing complete\n"));
csound->Message(csound, "N = %d\n", N);
csound->Message(csound, "M = %d\n", M);
csound->Message(csound, "L = %d\n", L);
csound->Message(csound, "D = %d\n", D);
}
return 0;
}
/* Get MMS messages. */
gn_error getmms(int argc, char *argv[], gn_data *data, struct gn_statemachine *state)
{
int i, del = 0;
gn_sms_folder folder;
gn_sms_folder_list folderlist;
gn_mms *message;
char *memory_type_string;
int start_message, end_message, count;
gnokii_app_mode mode = GNOKII_APP_MODE_Ask;
char filename[64];
gn_error error = GN_ERR_NONE;
gn_mms_format output_format_type = GN_MMS_FORMAT_TEXT;
struct option options[] = {
{ "mime", required_argument, NULL, GN_MMS_FORMAT_MIME},
{ "pdu", required_argument, NULL, GN_MMS_FORMAT_PDU},
{ "raw", required_argument, NULL, GN_MMS_FORMAT_RAW},
{ "delete", no_argument, NULL, 'd' },
{ "overwrite", no_argument, NULL, 'o' },
{ NULL, 0, NULL, 0 }
};
/* Handle command line args that set type, start and end locations. */
memory_type_string = optarg;
if (gn_str2memory_type(memory_type_string) == GN_MT_XX) {
fprintf(stderr, _("Unknown memory type %s (use ME, SM, IN, OU, ...)!\n"), optarg);
fprintf(stderr, _("Run gnokii --showsmsfolderstatus for a list of supported memory types.\n"));
return GN_ERR_INVALIDMEMORYTYPE;
}
start_message = gnokii_atoi(argv[optind]);
if (errno || start_message < 0)
return getmms_usage(stderr, -1);
end_message = parse_end_value_option(argc, argv, optind + 1, start_message);
if (errno || end_message < 0)
return getmms_usage(stderr, -1);
*filename = '\0';
/* parse all options (beginning with '-') */
while ((i = getopt_long(argc, argv, "1:2:3:do", options, NULL)) != -1) {
switch (i) {
case 'd':
del = 1;
break;
/* force mode -- don't ask to overwrite */
case 'o':
mode = GNOKII_APP_MODE_Overwrite;
break;
case GN_MMS_FORMAT_MIME:
/* FALL THROUGH */
case GN_MMS_FORMAT_PDU:
/* FALL THROUGH */
case GN_MMS_FORMAT_RAW:
/* output formats are mutually exclusive */
if (output_format_type != GN_MMS_FORMAT_TEXT) {
return getmms_usage(stderr, -1);
}
output_format_type = i;
if (!optarg) {
return getsms_usage(stderr, -1);
}
snprintf(filename, sizeof(filename), "%s", optarg);
fprintf(stderr, _("Saving into %s\n"), filename);
break;
default:
return getmms_usage(stderr, -1);
}
}
if (argc - optind > 3) {
/* There are too many arguments that don't start with '-' */
return getmms_usage(stderr, -1);
}
folder.folder_id = 0;
data->sms_folder = &folder;
data->sms_folder_list = &folderlist;
/* Now retrieve the requested entries. */
for (count = start_message; count <= end_message; count++) {
error = gn_mms_alloc(&message);
if (error != GN_ERR_NONE)
break;
message->memory_type = gn_str2memory_type(memory_type_string);
message->number = count;
message->buffer_format = output_format_type;
data->mms = message;
error = gn_mms_get(data, state);
switch (error) {
case GN_ERR_NONE:
if (*filename) {
/* writebuffer() will set mode to "append" */
mode = writebuffer(filename, data->mms->buffer, data->mms->buffer_length, mode);
} else {
error = fprint_mms(stdout, message);
fprintf(stdout, "\n");
}
if (del && mode != GNOKII_APP_MODE_Cancel) {
if (GN_ERR_NONE != gn_mms_delete(data, state))
fprintf(stderr, _("(delete failed)\n"));
else
fprintf(stderr, _("(message deleted)\n"));
}
break;
default:
if ((error == GN_ERR_INVALIDLOCATION) && (end_message == INT_MAX) && (count > start_message)) {
error = GN_ERR_NONE;
/* Force exit */
mode = GNOKII_APP_MODE_Cancel;
break;
}
fprintf(stderr, _("Getting MMS failed (location %d from memory %s)! (%s)\n"), count, memory_type_string, gn_error_print(error));
if (error == GN_ERR_INVALIDMEMORYTYPE) {
fprintf(stderr, _("Unknown memory type %s (use ME, SM, IN, OU, ...)!\n"), optarg);
fprintf(stderr, _("Run gnokii --showsmsfolderstatus for a list of supported memory types.\n"));
}
if (error == GN_ERR_EMPTYLOCATION)
error = GN_ERR_NONE;
break;
}
gn_mms_free(message);
if (mode == GNOKII_APP_MODE_Cancel)
break;
}
return error;
}
// execution begins here
int UltraMain(void) {
struct display_context * dc;
struct controller_data cd;
int lasty=0,lastx=0;
int d=0;
// buffer for rendering text strings (only sprintf works at the moment)
char buf[1024];
// offset for the scrolling waveform
float offs=0;
// used to keep track of how many cycles various processes take
unsigned long time,rendertime,lastrendertime,waittime,lastwaittime;
// enable MI interrupts (on the CPU)
set_MI_interrupt(1);
initDisplay();
initAudio();
registerAIhandler(AIcallback);
registerVIhandler(VIcallback);
while (1) {
short * sb;
int sbsize;
// Mark the value of the COUNT register (increments at half the CPU
// rate) at the start of the main loop.
time=read_count();
while (! (dc=lockDisplay())) ;
// Mark the time after waiting.
waittime=time;
waittime=((time=read_count())-waittime)*2;
sb=getbuf();
sbsize=getbufsize();
for (int c=0;c<sbsize;c++,d++) {
sb[c*2]=sin((d%22050)/22050.0*M_TWOPI*1000.0)*100*((cd.c[0].y-lasty)*c/sbsize+lasty)*(((cd.c[0].x-lastx)*c/sbsize+lastx)/128.0-1.0);
sb[c*2+1]=sin((d%22050)/22050.0*M_TWOPI*1000.0)*100*((cd.c[0].y-lasty)*c/sbsize+lasty)*(((cd.c[0].x-lastx)*c/sbsize+lastx)/128.0+1.0);
}
writebuffer(sb);
lastx=cd.c[0].x;
lasty=cd.c[0].y;
// this is what really marks the beginning of the current frame
// read controller data
controller_Read(&cd);
// start drawing on the other frame buffer, clear the screen (uses red
// when the start button on controller 1 is pressed, black otherwise)
VI_FillScreen(&dc->conf,cd.c[0].err?0:(cd.c[0].start?0xf800:0));
// print a little info for each controller
for (int c=0; c < 4; c++) {
if (cd.c[c].err) // if controller not present
sprintf(buf,"controller %d not present",c+1);
else {
sprintf(buf,"controller %d present\nbuttons=0x%04X x=%4d y=%4d",c+1,
cd.c[c].buttons,
cd.c[c].x,
cd.c[c].y);
}
VI_DrawText(&dc->conf,50,58+2*8*c,buf);
}
// draw a waveform
for (float x=50; x < 250; x++) {
VI_DrawPixel(&dc->conf,x,cbrt(sin((x-50)/200*M_TWOPI*4+offs))*250.0/8+175,0x7c0);
}
// the waveform can be scrolled by the x axis of the first controller
if (!cd.c[0].err) offs-=(cd.c[0].x/2*2)/32.0;
// print up some informative text, and report how long we waited for
// this frame, and how long the last frame took to render
sprintf(buf,"buffers: %5d frames: %5d\n%8lu cycles last frame\n%8lu cycles waiting\n%4.2f FPS",buffercount,framecount,lastrendertime,lastwaittime,100000000.0/(lastwaittime+lastrendertime));
VI_DrawText(&dc->conf,50,26,buf);
// calculate how many cycles this frame took to render
rendertime=(read_count()-time)*2;
lastwaittime=waittime;
lastrendertime=rendertime;
showDisplay(dc);
dc=0;
}
return 0;
}
