void oggamp_banana( void)
{
struct timeval timout;
timout.tv_sec = 0;
timout.tv_usec = 200000;
pute("banana1\n");
select(0, 0, 0, 0, &timout);
pute("banana2\n");
}
void solve(){
fscanf(fi,"%ld%ld",&n,&m);
long i;
g.s=n;
for(i=1;i<=n;++i){
index(g,i).s=0;
}
long u,v,c;
for(i=0;i<m;++i){
fscanf(fi,"%ld%ld%ld",&u,&v,&c);
pute(index(g,u),v,c);
printf("%ld %ld %ld\n",u,v ,c);
}
for(i=1;i<=n;++i){
dijkstra(i);
}
}
static void *oggamp_child_main(void *zz)
{
t_oggamp *x = zz;
pute("1\n");
pthread_mutex_lock(&x->x_mutex);
while (1)
{
int fd, fifohead;
char *buffer; /* Ogg Vorbis data */
float *buf; /* encoded PCM floats */
pute("0\n");
if (x->x_requestcode == REQUEST_NOTHING)
{
pute("wait 2\n");
oggamp_cond_signal(&x->x_answercondition);
oggamp_cond_wait(&x->x_requestcondition, &x->x_mutex);
pute("3\n");
}
// connect to Icecast2 server
else if (x->x_requestcode == REQUEST_CONNECT)
{
char boo[80];
int sysrtn, wantbytes;
/* copy connect stuff out of the data structure so we can
relinquish the mutex while we're in oggcast_child_connect(). */
char *hostname = x->x_hostname;
char *mountpoint = x->x_mountpoint;
t_int portno = x->x_port;
x->x_disconnect = 0;
/* alter the request code so that an ensuing "open" will get
noticed. */
pute("4\n");
x->x_requestcode = REQUEST_BUSY;
x->x_connecterror = 0;
/* if there's already a connection open, close it */
if (x->x_fd >= 0)
{
fd = x->x_fd;
pthread_mutex_unlock(&x->x_mutex);
oggamp_child_disconnect(fd);
pthread_mutex_lock(&x->x_mutex);
x->x_connectstate = 0;
clock_delay(x->x_clock, 0);
x->x_fd = -1;
if (x->x_requestcode != REQUEST_BUSY)
goto lost;
}
/* open the socket with the mutex unlocked */
pthread_mutex_unlock(&x->x_mutex);
fd = oggamp_child_connect(hostname, mountpoint, portno);
pthread_mutex_lock(&x->x_mutex);
pute("5\n");
/* copy back into the instance structure. */
x->x_connectstate = 1;
clock_delay(x->x_clock, 0);
x->x_fd = fd;
if (fd < 0)
{
x->x_connecterror = fd;
x->x_eof = 1;
x->x_connectstate = 0;
clock_delay(x->x_clock, 0);
pute("connect failed\n");
goto lost;
}
else
{
/* initialise the decoder */
if(oggamp_vorbis_init(x, fd) != -1)
{
post("oggamp~: decoder initialised");
oggamp_child_dographics(x);
}
else
{
post("oggamp~: could not init decoder");
oggamp_child_disconnect(fd);
post("oggamp~: connection closed due to bitstream error");
x->x_disconnect = 1;
x->x_fd = -1;
x->x_eof = 1;
x->x_connectstate = 0;
clock_delay(x->x_clock, 0);
pute("initialisation failed\n");
goto lost;
}
}
/* check if another request has been made; if so, field it */
if (x->x_requestcode != REQUEST_BUSY)
goto lost;
pute("6\n");
x->x_fifohead = fifohead = 0;
/* set fifosize from bufsize. fifosize must be a
multiple of the number of bytes eaten for each DSP
tick. We pessimistically assume MAXVECSIZE samples
per tick since that could change. There could be a
problem here if the vector size increases while a
stream is being played... */
x->x_fifosize = x->x_bufsize - (x->x_bufsize %
(x->x_streamchannels * 2));
/* arrange for the "request" condition to be signalled x->x_siginterval
times per buffer */
sprintf(boo, "fifosize %d\n",
x->x_fifosize);
pute(boo);
x->x_sigcountdown = x->x_sigperiod = (x->x_fifosize / (x->x_siginterval * x->x_noutlets * x->x_vecsize));
/* in a loop, wait for the fifo to get hungry and feed it */
while (x->x_requestcode == REQUEST_BUSY)
{
int fifosize = x->x_fifosize;
buf = x->x_buf;
pute("77\n");
if (x->x_eof)
break;
/* try to get new data from decoder whenever
there is some space at end of buffer */
if(x->x_fifobytes < fifosize - READSIZE)
{
sprintf(boo, "head %d, tail %d\n", x->x_fifohead, x->x_fifotail);
pute(boo);
/* we pass x on to the routine since we need the ogg vorbis stuff
to be presend. all other values should not be changed because
mutex is unlocked ! */
pute("decode... ");
pthread_mutex_unlock(&x->x_mutex);
sysrtn = oggamp_decode_input(x, buf, fifohead, fifosize, fd);
oggamp_child_updategraphics(x);
pthread_mutex_lock(&x->x_mutex);
if (x->x_requestcode != REQUEST_BUSY)
break;
if (sysrtn == 0)
{
if (x->x_eos && !x->x_disconnect) /* got end of stream */
{
pute("end of stream\n");
oggamp_vorbis_deinit(x);
if(oggamp_vorbis_init(x, fd) == -1) /* reinit stream */
{
x->x_state = STATE_IDLE;
x->x_disconnect = 1;
goto quit;
}
}
else if (x->x_eos && x->x_disconnect) /* we're disconnecting */
{
pute("end of stream: disconnecting\n");
break; /* go to disconnect */
}
}
else if (sysrtn < 0) /* got any other error from decoder */
{
pute("connecterror\n");
x->x_connecterror = sysrtn;
break;
}
x->x_fifohead = (fifohead + sysrtn) % fifosize;
x->x_fifobytes += sysrtn;
sprintf(boo, "after: head %d, tail %d\n",
x->x_fifohead, x->x_fifotail);
pute(boo);
/* check wether the buffer is filled enough to start streaming */
}
else /* there is enough data in the buffer :: do nothing */
{
x->x_state = STATE_STREAM;
pute("wait 7...\n");
oggamp_cond_signal(&x->x_answercondition);
oggamp_cond_wait(&x->x_requestcondition, &x->x_mutex);
pute("7 done\n");
continue;
}
pute("8\n");
fd = x->x_fd;
buf = x->x_buf;
fifohead = x->x_fifohead;
/* signal parent in case it's waiting for data */
oggamp_cond_signal(&x->x_answercondition);
}
lost:
if (x->x_requestcode == REQUEST_BUSY)
x->x_requestcode = REQUEST_NOTHING;
/* fell out of read loop: close connection if necessary,
set EOF and signal once more */
if (x->x_fd >= 0)
{
fd = x->x_fd;
pthread_mutex_unlock(&x->x_mutex);
oggamp_vorbis_deinit(x);
oggamp_child_disconnect(fd);
pthread_mutex_lock(&x->x_mutex);
x->x_fd = -1;
oggamp_child_delgraphics(x);
}
oggamp_cond_signal(&x->x_answercondition);
}
/* reconnect to server */
else if (x->x_requestcode == REQUEST_RECONNECT)
{
if (x->x_fd >= 0)
{
fd = x->x_fd;
pthread_mutex_unlock(&x->x_mutex);
oggamp_vorbis_deinit(x);
oggamp_child_disconnect(fd);
pthread_mutex_lock(&x->x_mutex);
oggamp_child_delgraphics(x);
x->x_fd = -1;
}
/* connect again */
x->x_requestcode = REQUEST_CONNECT;
x->x_connectstate = 0;
clock_delay(x->x_clock, 0);
oggamp_cond_signal(&x->x_answercondition);
}
/* close connection to server (disconnect) */
else if (x->x_requestcode == REQUEST_CLOSE)
{
quit:
if (x->x_fd >= 0)
{
fd = x->x_fd;
pthread_mutex_unlock(&x->x_mutex);
oggamp_vorbis_deinit(x);
oggamp_child_disconnect(fd);
pthread_mutex_lock(&x->x_mutex);
oggamp_child_delgraphics(x);
x->x_fd = -1;
}
if (x->x_requestcode == REQUEST_CLOSE)
x->x_requestcode = REQUEST_NOTHING;
else if (x->x_requestcode == REQUEST_BUSY)
x->x_requestcode = REQUEST_NOTHING;
else if (x->x_requestcode == REQUEST_CONNECT)
x->x_requestcode = REQUEST_NOTHING;
x->x_connectstate = 0;
clock_delay(x->x_clock, 0);
oggamp_cond_signal(&x->x_answercondition);
}
// quit everything
else if (x->x_requestcode == REQUEST_QUIT)
{
if (x->x_fd >= 0)
{
fd = x->x_fd;
pthread_mutex_unlock(&x->x_mutex);
oggamp_vorbis_deinit(x);
oggamp_child_disconnect(fd);
pthread_mutex_lock(&x->x_mutex);
x->x_fd = -1;
}
x->x_connectstate = 0;
clock_delay(x->x_clock, 0);
x->x_requestcode = REQUEST_NOTHING;
oggamp_cond_signal(&x->x_answercondition);
break;
}
else
{
pute("13\n");
}
}
pute("thread exit\n");
pthread_mutex_unlock(&x->x_mutex);
return (0);
}
void usage(char* msg) {
if (msg) {
printf("\nCommand line error: %s\n", msg);
}
pute(" ");
pute("NAME");
pute(" csvAppend - append all columns from csv files to the standard output");
pute(" ");
pute("SYNOPSIS");
pute(" csvAppend [OPTION] FILE ...");
pute(" ");
pute("DESCRIPTION");
pute(" Concatenate all columns in csv FILE(s) to standard output");
pute(" Assumes that the field separator is a comma");
pute(" ");
pute("EXAMPLE");
pute(" csvAppend SALE-AMOUNT.csv longitude-std.csv > combined.csv");
pute(" writes csv file on stdout containing columns from the 2 files");
exit(1);
}
t_int *readsfx_perform(t_int *w)
{
t_readsfx *x = (t_readsfx *)(w[1]);
int vecsize = x->x_vecsize, noutlets = x->x_noutlets, i, j,
bytespersample = x->x_bytespersample,
bigendian = x->x_bigendian;
t_sample *fp;
if (x->x_state == STATE_STREAM)
{
int wantbytes, sfchannels = x->x_sfchannels;
pthread_mutex_lock(&x->x_mutex);
wantbytes = sfchannels * vecsize * bytespersample;
while (
!x->x_eof && x->x_fifohead >= x->x_fifotail &&
x->x_fifohead < x->x_fifotail + wantbytes-1)
{
#ifdef DEBUG_SOUNDFILE
pute("wait...\n");
#endif
sfread_cond_signal(&x->x_requestcondition);
sfread_cond_wait(&x->x_answercondition, &x->x_mutex);
/* resync local cariables -- bug fix thanks to Shahrokh */
vecsize = x->x_vecsize;
bytespersample = x->x_bytespersample;
sfchannels = x->x_sfchannels;
wantbytes = sfchannels * vecsize * bytespersample;
bigendian = x->x_bigendian;
#ifdef DEBUG_SOUNDFILE
pute("done\n");
#endif
}
if (x->x_eof && x->x_fifohead >= x->x_fifotail &&
x->x_fifohead < x->x_fifotail + wantbytes-1)
{
int xfersize;
if (x->x_fileerror)
{
pd_error(x, "dsp: %s: %s", x->x_filename,
(x->x_fileerror == EIO ?
"unknown or bad header format" :
strerror(x->x_fileerror)));
}
clock_delay(x->x_clock, 0);
x->x_state = STATE_IDLE;
/* if there's a partial buffer left, copy it out. */
xfersize = (x->x_fifohead - x->x_fifotail + 1) /
(sfchannels * bytespersample);
if (xfersize)
{
soundfile_xferin_sample(sfchannels, noutlets, x->x_outvec, 0,
(unsigned char *)(x->x_buf + x->x_fifotail), xfersize,
bytespersample, bigendian, 1);
vecsize -= xfersize;
}
/* then zero out the (rest of the) output */
for (i = 0; i < noutlets; i++)
for (j = vecsize, fp = x->x_outvec[i] + xfersize; j--; )
*fp++ = 0;
sfread_cond_signal(&x->x_requestcondition);
pthread_mutex_unlock(&x->x_mutex);
return (w+2);
}
soundfile_xferin_sample(sfchannels, noutlets, x->x_outvec, 0,
(unsigned char *)(x->x_buf + x->x_fifotail), vecsize,
bytespersample, bigendian, 1);
x->x_fifotail += wantbytes;
if (x->x_fifotail >= x->x_fifosize)
x->x_fifotail = 0;
if ((--x->x_sigcountdown) <= 0)
{
sfread_cond_signal(&x->x_requestcondition);
x->x_sigcountdown = x->x_sigperiod;
}
pthread_mutex_unlock(&x->x_mutex);
}
else
{
for (i = 0; i < noutlets; i++)
for (j = vecsize, fp = x->x_outvec[i]; j--; )
*fp++ = 0;
}
return (w+2);
}
static void *readsfx_child_main(void *zz)
{
t_readsfx *x = zz;
void * reader_obj = sfxreader_new();
#ifdef DEBUG_SOUNDFILE
pute("1\n");
#endif
pthread_mutex_lock(&x->x_mutex);
int fd, fifohead;
char *buf;
while (1)
{
#ifdef DEBUG_SOUNDFILE
pute("0\n");
#endif
if (x->x_requestcode == REQUEST_NOTHING)
{
#ifdef DEBUG_SOUNDFILE
pute("wait 2\n");
#endif
sfread_cond_signal(&x->x_answercondition);
sfread_cond_wait(&x->x_requestcondition, &x->x_mutex);
#ifdef DEBUG_SOUNDFILE
pute("3\n");
#endif
}
else if (x->x_requestcode == REQUEST_OPEN)
{
#ifdef DEBUG_SOUNDFILE
char boo[80];
#endif
int sysrtn, wantbytes;
//---------START OPEN SOUNDFILE-------------------
/* copy file stuff out of the data structure so we can
relinquish the mutex while we're in open_soundfile(). */
long onsetframes = x->x_onsetframes;
long bytelimit = 0x7fffffff;
int bytespersample = x->x_bytespersample;
int sfchannels = x->x_sfchannels;
int bigendian = x->x_bigendian;
//void* reader_obj = x->x_reader_obj;
char *filename = x->x_filename;
char *dirname = canvas_getdir(x->x_canvas)->s_name;
#ifdef DEBUG_SOUNDFILE
pute("4\n");
#endif
/* alter the request code so that an ensuing "open" will get
noticed. */
x->x_requestcode = REQUEST_BUSY;
x->x_fileerror = 0;
/* if there's already a file open, close it */
if (x->x_fd >= 0)
{
fd = x->x_fd;
pthread_mutex_unlock(&x->x_mutex);
sfxreader_close(reader_obj);
pthread_mutex_lock(&x->x_mutex);
x->x_fd = -1;
if (x->x_requestcode != REQUEST_BUSY)
goto lost;
}
/* open the soundfile with the mutex unlocked */
pthread_mutex_unlock(&x->x_mutex);
#ifdef DEBUG_SOUNDFILE
pute("Pre-open\n");
#endif
fd = sfxreader_open(reader_obj, dirname, filename, &bytespersample, &bigendian,
&sfchannels, &bytelimit, onsetframes);
pthread_mutex_lock(&x->x_mutex);
#ifdef DEBUG_SOUNDFILE
pute("5\n");
#endif
/* copy back into the instance structure. */
x->x_bytespersample = bytespersample;
x->x_sfchannels = sfchannels;
x->x_bigendian = bigendian;
x->x_fd = fd;
x->x_bytelimit = bytelimit;
if (fd < 0)
{
x->x_fileerror = errno;
x->x_eof = 1;
#ifdef DEBUG_SOUNDFILE
pute("open failed\n");
pute(filename);
pute(dirname);
#endif
goto lost;
}
sfxreader_info(dirname, filename, &(x->x_data));
//---------END OPEN SOUNDFILE-------------------
/* check if another request has been made; if so, field it */
if (x->x_requestcode != REQUEST_BUSY)
goto lost;
#ifdef DEBUG_SOUNDFILE
pute("6\n");
#endif
x->x_fifohead = 0;
/* set fifosize from bufsize. fifosize must be a
multiple of the number of bytes eaten for each DSP
tick. We pessimistically assume MAXVECSIZE samples
per tick since that could change. There could be a
problem here if the vector size increases while a
soundfile is being played... */
x->x_fifosize = x->x_bufsize - (x->x_bufsize %
(x->x_bytespersample * x->x_sfchannels * MAXVECSIZE));
/* arrange for the "request" condition to be signalled 16
times per buffer */
#ifdef DEBUG_SOUNDFILE
sprintf(boo, "fifosize %d\n",
x->x_fifosize);
pute(boo);
#endif
x->x_sigcountdown = x->x_sigperiod =
(x->x_fifosize /
(16 * x->x_bytespersample * x->x_sfchannels *
x->x_vecsize));
/* in a loop, wait for the fifo to get hungry and feed it */
while (x->x_requestcode == REQUEST_BUSY)
{
int fifosize = x->x_fifosize;
#ifdef DEBUG_SOUNDFILE
pute("77\n");
#endif
if (x->x_eof)
break;
if (x->x_fifohead >= x->x_fifotail)
{
/* if the head is >= the tail, we can immediately read
to the end of the fifo. Unless, that is, we would
read all the way to the end of the buffer and the
"tail" is zero; this would fill the buffer completely
which isn't allowed because you can't tell a completely
full buffer from an empty one. */
if (x->x_fifotail || (fifosize - x->x_fifohead > READSIZE))
{
wantbytes = fifosize - x->x_fifohead;
if (wantbytes > READSIZE)
wantbytes = READSIZE;
if (wantbytes > x->x_bytelimit)
wantbytes = (int)x->x_bytelimit;
#ifdef DEBUG_SOUNDFILE
sprintf(boo, "head %d, tail %d, size %d\n",
x->x_fifohead, x->x_fifotail, wantbytes);
pute(boo);
#endif
}
else
{
#ifdef DEBUG_SOUNDFILE
pute("wait 7a ...\n");
#endif
sfread_cond_signal(&x->x_answercondition);
#ifdef DEBUG_SOUNDFILE
pute("signalled\n");
#endif
sfread_cond_wait(&x->x_requestcondition,
&x->x_mutex);
#ifdef DEBUG_SOUNDFILE
pute("7a done\n");
#endif
continue;
}
}
else
{
/* otherwise check if there are at least READSIZE
bytes to read. If not, wait and loop back. */
wantbytes = x->x_fifotail - x->x_fifohead - 1;
if (wantbytes < READSIZE)
{
#ifdef DEBUG_SOUNDFILE
pute("wait 7...\n");
#endif
sfread_cond_signal(&x->x_answercondition);
sfread_cond_wait(&x->x_requestcondition,
&x->x_mutex);
#ifdef DEBUG_SOUNDFILE
pute("7 done\n");
#endif
continue;
}
else wantbytes = READSIZE;
if (wantbytes > x->x_bytelimit)
wantbytes = (int)x->x_bytelimit;
}
#ifdef DEBUG_SOUNDFILE
pute("8\n");
#endif
fd = x->x_fd;
buf = x->x_buf;
fifohead = x->x_fifohead;
pthread_mutex_unlock(&x->x_mutex);
//Read from our file reader
sysrtn = sfxreader_read(reader_obj, buf + fifohead, wantbytes);
pthread_mutex_lock(&x->x_mutex);
if (x->x_requestcode != REQUEST_BUSY)
break;
if (sysrtn < 0)
{
#ifdef DEBUG_SOUNDFILE
pute("fileerror\n");
#endif
x->x_fileerror = errno;
break;
}
else if (sysrtn == 0)
{
x->x_eof = 1;
break;
}
else
{
x->x_fifohead += sysrtn;
x->x_bytelimit -= sysrtn;
if (x->x_fifohead == fifosize)
x->x_fifohead = 0;
if (x->x_bytelimit <= 0)
{
x->x_eof = 1;
break;
}
}
#ifdef DEBUG_SOUNDFILE
sprintf(boo, "after: head %d, tail %d\n",
x->x_fifohead, x->x_fifotail);
pute(boo);
#endif
/* signal parent in case it's waiting for data */
sfread_cond_signal(&x->x_answercondition);
}
lost:
if (x->x_requestcode == REQUEST_BUSY)
x->x_requestcode = REQUEST_NOTHING;
/* fell out of read loop: close file if necessary,
set EOF and signal once more */
if (x->x_fd >= 0)
{
fd = x->x_fd;
pthread_mutex_unlock(&x->x_mutex);
close (fd);
pthread_mutex_lock(&x->x_mutex);
x->x_fd = -1;
}
sfread_cond_signal(&x->x_answercondition);
}
else if (x->x_requestcode == REQUEST_CLOSE)
{
if (x->x_fd >= 0)
{
// void* reader_obj = x->x_reader_obj;
fd = x->x_fd;
pthread_mutex_unlock(&x->x_mutex);
sfxreader_close(reader_obj);
pthread_mutex_lock(&x->x_mutex);
x->x_fd = -1;
}
if (x->x_requestcode == REQUEST_CLOSE)
x->x_requestcode = REQUEST_NOTHING;
sfread_cond_signal(&x->x_answercondition);
}
else if (x->x_requestcode == REQUEST_QUIT)
{
if (x->x_fd >= 0)
{
// void* reader_obj = x->x_reader_obj;
fd = x->x_fd;
pthread_mutex_unlock(&x->x_mutex);
sfxreader_free(reader_obj);
pthread_mutex_lock(&x->x_mutex);
x->x_fd = -1;
}
x->x_requestcode = REQUEST_NOTHING;
sfread_cond_signal(&x->x_answercondition);
break;
}
else
{
#ifdef DEBUG_SOUNDFILE
pute("13\n");
#endif
}
}
#ifdef DEBUG_SOUNDFILE
pute("thread exit\n");
#endif
pthread_mutex_unlock(&x->x_mutex);
return (0);
}
