// This function should match SharkStack::CreateStackOverflowCheck
inline void ZeroStack::overflow_check(int required_words, TRAPS) {
// Check the Zero stack
if (available_words() < required_words) {
handle_overflow(THREAD);
return;
}
// Check the ABI stack
if (abi_stack_available(THREAD) < 0) {
handle_overflow(THREAD);
return;
}
}
bool rs_add_elem_new( remset_t *rs, word w )
{
word mask, *tbl, *b, *pooltop, *poollim, tblsize, h;
bool overflowed = FALSE;
remset_data_t *data = DATA(rs);
assert2(! rs_isremembered( rs, w ));
pooltop = data->curr_pool->top;
poollim = data->curr_pool->lim;
tbl = data->tbl_bot;
tblsize = data->tbl_lim - tbl;
mask = tblsize-1;
h = hash_object( w, mask );
if (pooltop == poollim) {
handle_overflow( rs, 0, pooltop );
pooltop = data->curr_pool->top;
poollim = data->curr_pool->lim;
overflowed = TRUE;
}
*pooltop = w;
*(pooltop+1) = tbl[h];
tbl[h] = (word)pooltop;
pooltop += 2;
data->curr_pool->top = pooltop;
data->curr_pool->lim = poollim;
data->stats.recorded += 1;
rs->live += 1;
return overflowed;
}
/* Adds w to remset rs. Returns true if rs overflowed when inserting w. */
bool rs_add_elem( remset_t *rs, word w )
{
word mask, *tbl, *b, *pooltop, *poollim, tblsize, h;
bool overflowed = FALSE;
remset_data_t *data = DATA(rs);
pooltop = data->curr_pool->top;
poollim = data->curr_pool->lim;
tbl = data->tbl_bot;
tblsize = data->tbl_lim - tbl;
mask = tblsize-1;
h = hash_object( w, mask );
b = (word*)tbl[ h ];
while (b != 0 && *b != w)
b = (word*)*(b+1);
if (b == 0) {
if (pooltop == poollim) {
handle_overflow( rs, 0, pooltop );
pooltop = data->curr_pool->top;
poollim = data->curr_pool->lim;
overflowed = TRUE;
}
*pooltop = w;
*(pooltop+1) = tbl[h];
tbl[h] = (word)pooltop;
pooltop += 2;
data->curr_pool->top = pooltop;
data->curr_pool->lim = poollim;
data->stats.recorded += 1;
rs->live += 1;
}
return overflowed;
}
static void *thread_func(void* data) {
(void) data;
while(1) {
mlock();
if(playa.thread_music_status == TS_STOPPING) {
playa.thread_music_status = TS_WAITING;
munlock();
msleep(1);
continue;
} else if(playa.thread_music_status == TS_DONE || playa.thread_music_status == TS_WAITING) {
munlock();
msleep(4);
continue;
}
munlock();
if(MUSIC_FINISHED()) {
mlock();
playa.thread_music_status = TS_DONE;
munlock();
continue;
}
GEN_MUSIC();
if(MUSIC_AVAIL()) {
//dprintf(2, "writing %zu bytes...\n", (size_t) playa.out_wave.pos);
slock();
if(playa.play_waveslot != -1) {
struct ByteArray* mine = &playa.wave_streams[playa.play_waveslot];
if(!mine->bytesAvailable(mine)) {
playa.play_waveslot = -1;
goto mixin_done;
}
struct ByteArray* out = &playa.out_wave;
off_t savepos = out->pos;
size_t avail = mine->bytesAvailable(mine);
size_t upsample_factor = 44100 / playa.wavhdr.wave_hdr.samplerate;
size_t processed_m = 0, processed_w = 0;
size_t readbytes = playa.wavhdr.wave_hdr.bitwidth == 8 ? 1 : 2;
int chan[2] = { 0, 0 };
int next[2];
ByteArray_set_position(out, 0);
while(processed_m < (size_t)savepos && processed_w < avail) {
size_t c, u;
for(c = 0; c < 2; c++) {
if(c < playa.wavhdr.wave_hdr.channels) {
if(readbytes == 1) next[c] = ((uint8_t) ByteArray_readByte(mine) - 128) * 256;
else next[c] = ByteArray_readShort(mine);
handle_overflow(&next[c]);
} else
next[c] = next[c - 1];
processed_w += readbytes;
}
for(u = 0; u < upsample_factor; u++) {
for(c = 0; c < 2; c++) {
int interpolated = u == 0 ? chan[c] :
chan[c] + ((next[c]-chan[c]) * ((float)u/(float)upsample_factor));
interpolated = (float) interpolated * 0.3; // decrease volume to avoid overflow
int music = GET_MUSIC_WORD();
int sample = music + interpolated;
if(handle_overflow(&sample)) dprintf(2, "overflow\n");
MUSIC_REWIND_WORD();
ByteArray_writeShort(out, sample);
processed_m += 2;
}
}
for (c=0; c<2; c++) chan[c] = next[c];
}
ByteArray_set_position(out, savepos);
}
mixin_done:
sunlock();
BACKEND_WRITE(&playa.writer.ao, playa.wave_buffer, playa.out_wave.pos);
//dprintf(2, "done\n");
playa.out_wave.pos = 0;
}
}
return 0;
}
