/* add some randomness to texture data */
static void SpeckleTexture(void)
{
int i,j;
int speck;
float t;
for (i=2;i<30;i++)
{
for (j=2;j<30;j++)
{
speck = 1;
while (speck <= 32 && random() % 2)
{
t = (float) MIN_(255,smallTextureArray[i][j]+speck);
smallTextureArray[i][j] = (GLubyte) t;
speck+=speck;
}
speck = 1;
while (speck <= 32 && random() % 2)
{
t = (float) MAX_(0,smallTextureArray[i][j]-speck);
smallTextureArray[i][j] = (GLubyte) t;
speck+=speck;
}
}
}
}
void mrutils::GuiEditBox::redraw() {
box((WINDOW*)win, 0, 0);
mvwaddch((WINDOW*)win, 2, 0, ACS_LTEE);
mvwhline((WINDOW*)win, 2, 1, ACS_HLINE, winCols - 2);
mvwaddch((WINDOW*)win, 2, winCols - 1, ACS_RTEE);
wmove((WINDOW*)win, 1, MAX_(3,(int)(winCols - title.size())/2));
waddnstr((WINDOW*)win, title.c_str(), winCols-2);
}
void BetaMultiple::add(const std::vector<double> &x, double y, double weight) {
if (weight != 1) weight = sqrt(weight);
M.resize((n+1)*(maxCols+2),0);
for (unsigned c = 0; c < x.size(); ++c) {
M(n,c+1) = x[c] * weight;
if (storeData) xs[c].push_back(x[c] * weight);
}
y *= weight;
M(n,0) = weight;
Y(n) = y;
if (storeData) ys.push_back(y);
dirty = true;
Sy += y; Syy += y*y;
++n;
cols = MAX_(cols, (int)x.size());
if (col > 0) col = -1;
}
//================================================================
int process(jack_nframes_t nframes, void *arg)
{
//fprintf(stderr,".");
//return 0;
//if shutting down fill buffers with 0 and return
if(shutdown_in_progress==1)
{
int i;
for(i=0; i < output_port_count; i++)
{
sample_t *o1;
o1=(sample_t*)jack_port_get_buffer(ioPortArray[i], nframes);
//memset(o1, 0, bytes_per_sample*nframes);
//always 4 bytes, 32 bit float
memset(o1, 0, 4*nframes);
}
return 0;
}
if(process_enabled==1)
{
//if no data for this cycle(all channels)
//is available(!), fill buffers with 0 or re-use old buffers and return
if(jack_ringbuffer_read_space(rb) < port_count * bytes_per_sample*nframes)
{
int i;
for(i=0; i < output_port_count; i++)
{
if(shutdown_in_progress==1 || process_enabled!=1)
{
return 0;
}
if(zero_on_underflow==1)
{
sample_t *o1;
o1=(sample_t*)jack_port_get_buffer(ioPortArray[i], nframes);
//memset(o1, 0, bytes_per_sample*nframes);
//always 4 bytes, 32 bit float
memset(o1, 0, 4*nframes);
}
print_info();
}
multi_channel_drop_counter++;
if(rebuffer_on_underflow==1)
{
pre_buffer_counter=0;
process_enabled=0;
}
//reset avg calculation
time_interval_avg=0;
msg_received_counter=0;
fscs_avg_counter=0;
return 0;
}//end not enough data available in ringbuffer
process_cycle_counter++;
if(process_cycle_counter>receive_max-1 && test_mode==1)
{
last_test_cycle=1;
}
//init to 0. increment before use
fscs_avg_counter++;
frames_since_cycle_start_sum+=frames_since_cycle_start;
frames_since_cycle_start_avg=frames_since_cycle_start_sum/fscs_avg_counter;
//check and reset after use
if(fscs_avg_calc_interval>=fscs_avg_counter)
{
fscs_avg_counter=0;
frames_since_cycle_start_sum=0;
}
//if sender sends more channels than we have output channels, ignore them
int i;
for(i=0; i<port_count; i++)
{
if(shutdown_in_progress==1 || process_enabled!=1)
{
return 0;
}
sample_t *o1;
o1=(sample_t*)jack_port_get_buffer(ioPortArray[i], nframes);
int16_t *o1_16;
if(bytes_per_sample==2)
{
o1_16=malloc(bytes_per_sample*nframes);
}
//32 bit float
if(bytes_per_sample==4)
{
jack_ringbuffer_read(rb, (char*)o1, bytes_per_sample*nframes);
}
//16 bit pcm
else
{
jack_ringbuffer_read(rb, (char*)o1_16, bytes_per_sample*nframes);
int x;
for(x=0;x<nframes;x++)
{
o1[x]=(float)MIN_(MAX_((float)o1_16[x]/32760,-1.0f),1.0f);
}
free(o1_16);
}
/*
fprintf(stderr,"\rreceiving from %s:%s",
sender_host,sender_port
);
*/
print_info();
}//end for i < port_count
//requested via /buffer, for test purposes (make buffer "tight")
if(requested_drop_count>0)
{
uint64_t drop_bytes_count=requested_drop_count
*port_count*period_size*bytes_per_sample;
jack_ringbuffer_read_advance(rb,drop_bytes_count);
requested_drop_count=0;
multi_channel_drop_counter=0;
}
}//end if process_enabled==1
else //if process_enabled==0
{
int i;
for(i=0; i<port_count; i++)
{
if(shutdown_in_progress==1 || process_enabled!=1)
{
return 0;
}
sample_t *o1;
o1=(sample_t*)jack_port_get_buffer(ioPortArray[i], nframes);
//this is per channel, not per cycle. *port_count
if(relaxed_display_counter>=update_display_every_nth_cycle*port_count
|| last_test_cycle==1
)
{
//only for init
if((int)message_number<=0 && starting_transmission==0)
{
if(shutup==0 && quiet==0)
{
fprintf(stderr,"\rwaiting for audio input data...");
}
io_simple("/wait_for_input");
}
else
{
if(shutup==0 && quiet==0)
{
fprintf(stderr,"\r# %" PRId64 " buffering... mc periods to go: %" PRId64 "%s",
message_number,
pre_buffer_size-pre_buffer_counter,
"\033[0J"
);
}
if(io_())
{
lo_message msgio=lo_message_new();
lo_message_add_int64(msgio,message_number);
lo_message_add_int64(msgio,pre_buffer_size-pre_buffer_counter);
lo_send_message(loio, "/buffering", msgio);
lo_message_free(msgio);
}
}
fflush(stderr);
relaxed_display_counter=0;
}
relaxed_display_counter++;
//set output buffer silent
//memset(o1, 0, port_count*bytes_per_sample*nframes);
//always 4 bytes, 32 bit float
memset(o1, 0, port_count*4*nframes);
}//end for i < port_count
}//end process_enabled==0
//tasks independent of process_enabled 0/1
//if sender sends less channels than we have output channels, wee need to fill them with 0
if(input_port_count < output_port_count)
{
int i;
for(i=0;i < (output_port_count-input_port_count);i++)
{
//sample_t *o1;
//o1=(sample_t*)
/////?
jack_port_get_buffer(ioPortArray[input_port_count+i], nframes);
}
}
if(last_test_cycle==1)
{
if(shutup==0)
{
fprintf(stderr,"\ntest finished after %" PRId64 " process cycles\n",process_cycle_counter);
fprintf(stderr,"(waiting and buffering cycles not included)\n");
}
io_simple_long("/test_finished",process_cycle_counter);
shutdown_in_progress=1;
}
//simulate long cycle process duration
//usleep(1000);
frames_since_cycle_start=jack_frames_since_cycle_start(client);
return 0;
} //end process()
