void cam_nplusone_decoder(struct decoder *d) {
timeval_t t0, t1;
int sync, trigger;
decoder_state oldstate = d->state;
disable_interrupts();
t0 = d->last_t0;
t1 = d->last_t1;
trigger = d->needs_decoding_t0;
d->needs_decoding_t0 = 0;
sync = d->needs_decoding_t1;
d->needs_decoding_t1 = 0;
enable_interrupts();
if (d->state == DECODER_NOSYNC && trigger) {
if (d->current_triggers_rpm >= d->required_triggers_rpm) {
d->state = DECODER_RPM;
} else {
d->current_triggers_rpm++;
}
}
if (trigger && sync) {
/* Which came first? */
if (time_in_range(t1, t0, current_time())) {
trigger_update(d, t0);
sync_update(d);
} else {
sync_update(d);
trigger_update(d, t0);
}
} else if (trigger) {
trigger_update(d, t0);
} else {
sync_update(d);
}
if (d->state == DECODER_SYNC) {
d->valid = 1;
d->last_trigger_time = t0;
} else {
if (oldstate == DECODER_SYNC) {
/* We lost sync */
invalidate_decoder();
}
}
}
/* Mark the log entry as committed and sync the memory mapped log to file. */
krb5_error_code
ulog_finish_update(krb5_context context, kdb_incr_update_t *upd)
{
krb5_error_code retval;
kdb_ent_header_t *indx_log;
unsigned int i;
kdb_log_context *log_ctx;
kdb_hlog_t *ulog = NULL;
uint32_t ulogentries;
INIT_ULOG(context);
ulogentries = log_ctx->ulogentries;
i = (upd->kdb_entry_sno - 1) % ulogentries;
indx_log = INDEX(ulog, i);
indx_log->kdb_commit = TRUE;
ulog->kdb_state = KDB_STABLE;
retval = sync_update(ulog, indx_log);
if (retval)
return retval;
ulog_sync_header(ulog);
return 0;
}
__interrupt void isr(void)
{
if (RCIF == 1) {
if (OERR == 1) {
TXREG = EOT;
temp = RCREG;
CREN = 0;
CREN = 1;
} else {
sync_update();
}
}
if (TMR1IF == 1) {
TMR1ON = 0;
TMR1IF = 0;
TMR1H = 0x00;
TMR1L = 0x00;
check_milk();
check_eggs();
check_fruit();
check_veg();
check_choc();
TMR1ON = 1;
}
}
static int rocket_update()
{
int row = 0;
if (audio_is_playing)
curtime_ms += 16; //...60hz or gtfo
#if !defined( SYNC_PLAYER )
row = ms_to_row_round(curtime_ms, rps);
if (sync_update(device, row, &cb, 0))
sync_connect(device, "localhost", SYNC_DEFAULT_PORT);
#endif
return 1;
}
/*
* Add an entry to the update log. The layout of the update log looks like:
*
* header log -> [ update header -> xdr(kdb_incr_update_t) ], ...
*/
krb5_error_code
ulog_add_update(krb5_context context, kdb_incr_update_t *upd)
{
XDR xdrs;
kdbe_time_t ktime;
kdb_ent_header_t *indx_log;
unsigned int i, recsize;
unsigned long upd_size;
krb5_error_code retval;
kdb_sno_t cur_sno;
kdb_log_context *log_ctx;
kdb_hlog_t *ulog = NULL;
uint32_t ulogentries;
int ulogfd;
INIT_ULOG(context);
ulogentries = log_ctx->ulogentries;
ulogfd = log_ctx->ulogfd;
if (upd == NULL)
return KRB5_LOG_ERROR;
time_current(&ktime);
upd_size = xdr_sizeof((xdrproc_t)xdr_kdb_incr_update_t, upd);
recsize = sizeof(kdb_ent_header_t) + upd_size;
if (recsize > ulog->kdb_block) {
retval = resize(ulog, ulogentries, ulogfd, recsize);
if (retval)
return retval;
}
/* If we have reached the last possible serial number, reinitialize the
* ulog and start over. Slaves will do a full resync. */
if (ulog->kdb_last_sno == (kdb_sno_t)-1)
reset_header(ulog);
/* Get the next serial number and save it for finish_update() to index. */
cur_sno = ulog->kdb_last_sno + 1;
upd->kdb_entry_sno = cur_sno;
i = (cur_sno - 1) % ulogentries;
indx_log = INDEX(ulog, i);
memset(indx_log, 0, ulog->kdb_block);
indx_log->kdb_umagic = KDB_ULOG_MAGIC;
indx_log->kdb_entry_size = upd_size;
indx_log->kdb_entry_sno = cur_sno;
indx_log->kdb_time = upd->kdb_time = ktime;
indx_log->kdb_commit = upd->kdb_commit = FALSE;
ulog->kdb_state = KDB_UNSTABLE;
xdrmem_create(&xdrs, (char *)indx_log->entry_data,
indx_log->kdb_entry_size, XDR_ENCODE);
if (!xdr_kdb_incr_update_t(&xdrs, upd))
return KRB5_LOG_CONV;
retval = sync_update(ulog, indx_log);
if (retval)
return retval;
if (ulog->kdb_num < ulogentries)
ulog->kdb_num++;
ulog->kdb_last_sno = cur_sno;
ulog->kdb_last_time = ktime;
if (cur_sno > ulogentries) {
/* Once we've circled, kdb_first_sno is the sno of the next entry. */
i = upd->kdb_entry_sno % ulogentries;
indx_log = INDEX(ulog, i);
ulog->kdb_first_sno = indx_log->kdb_entry_sno;
ulog->kdb_first_time = indx_log->kdb_time;
} else if (cur_sno == 1) {
/* This is the first update. */
ulog->kdb_first_sno = 1;
ulog->kdb_first_time = indx_log->kdb_time;
}
ulog_sync_header(ulog);
return 0;
}
/*
* Add an update to the log. The update's kdb_entry_sno and kdb_time fields
* must already be set. The layout of the update log looks like:
*
* header log -> [ update header -> xdr(kdb_incr_update_t) ], ...
*/
static krb5_error_code
store_update(kdb_log_context *log_ctx, kdb_incr_update_t *upd)
{
XDR xdrs;
kdb_ent_header_t *indx_log;
unsigned int i, recsize;
unsigned long upd_size;
krb5_error_code retval;
kdb_hlog_t *ulog = log_ctx->ulog;
uint32_t ulogentries = log_ctx->ulogentries;
upd_size = xdr_sizeof((xdrproc_t)xdr_kdb_incr_update_t, upd);
recsize = sizeof(kdb_ent_header_t) + upd_size;
if (recsize > ulog->kdb_block) {
retval = resize(ulog, ulogentries, log_ctx->ulogfd, recsize);
if (retval)
return retval;
}
ulog->kdb_state = KDB_UNSTABLE;
i = (upd->kdb_entry_sno - 1) % ulogentries;
indx_log = INDEX(ulog, i);
memset(indx_log, 0, ulog->kdb_block);
indx_log->kdb_umagic = KDB_ULOG_MAGIC;
indx_log->kdb_entry_size = upd_size;
indx_log->kdb_entry_sno = upd->kdb_entry_sno;
indx_log->kdb_time = upd->kdb_time;
indx_log->kdb_commit = FALSE;
xdrmem_create(&xdrs, (char *)indx_log->entry_data,
indx_log->kdb_entry_size, XDR_ENCODE);
if (!xdr_kdb_incr_update_t(&xdrs, upd))
return KRB5_LOG_CONV;
indx_log->kdb_commit = TRUE;
retval = sync_update(ulog, indx_log);
if (retval)
return retval;
/* Modify the ulog header to reflect the new update. */
ulog->kdb_last_sno = upd->kdb_entry_sno;
ulog->kdb_last_time = upd->kdb_time;
if (ulog->kdb_num == 0) {
ulog->kdb_num = 1;
ulog->kdb_first_sno = upd->kdb_entry_sno;
ulog->kdb_first_time = upd->kdb_time;
} else if (ulog->kdb_num < ulogentries) {
ulog->kdb_num++;
} else {
/* We are circling; set kdb_first_sno and time to the next update. */
i = upd->kdb_entry_sno % ulogentries;
indx_log = INDEX(ulog, i);
ulog->kdb_first_sno = indx_log->kdb_entry_sno;
ulog->kdb_first_time = indx_log->kdb_time;
}
ulog->kdb_state = KDB_STABLE;
sync_header(ulog);
return 0;
}
int main(int argc, char *argv[])
{
#ifndef SYNC_PLAYER
bool should_save = false; // whether to save tracks when done.
// don't save unless we actually connect.
#endif
HSTREAM stream;
const struct sync_track *clear_r, *clear_g, *clear_b;
const struct sync_track *cam_rot, *cam_dist;
setup_sdl();
/* init BASS */
if (!BASS_Init(-1, 44100, 0, 0, 0))
die("failed to init bass");
stream = BASS_StreamCreateFile(false, "tune.ogg", 0, 0,
BASS_STREAM_PRESCAN);
if (!stream)
die("failed to open tune");
sync_device *rocket = sync_create_device("sync");
if (!rocket)
die("out of memory?");
#ifndef SYNC_PLAYER
if (sync_connect(rocket, "localhost", SYNC_DEFAULT_PORT))
die("failed to connect to host");
#endif
/* get tracks */
clear_r = sync_get_track(rocket, "clear.r");
clear_g = sync_get_track(rocket, "clear.g");
clear_b = sync_get_track(rocket, "clear.b");
cam_rot = sync_get_track(rocket, "cam.rot"),
cam_dist = sync_get_track(rocket, "cam.dist");
/* let's roll! */
BASS_Start();
BASS_ChannelPlay(stream, false);
bool done = false;
while (!done) {
double row = bass_get_row(stream);
#ifndef SYNC_PLAYER
if (sync_update(rocket, (int)floor(row), &bass_cb, (void *)&stream)) {
if (sync_connect(rocket, "localhost", SYNC_DEFAULT_PORT) == 0)
should_save = true;
}
#endif
/* draw */
glClearColor(float(sync_get_val(clear_r, row)),
float(sync_get_val(clear_g, row)),
float(sync_get_val(clear_b, row)), 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
float rot = float(sync_get_val(cam_rot, row));
float dist = float(sync_get_val(cam_dist, row));
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, 4.0f / 3, 0.1f, 100.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
gluLookAt(sin(rot) * dist, 0, cos(rot) * dist,
0, 0, 0,
0, 1, 0);
glEnable(GL_DEPTH_TEST);
draw_cube();
glPopMatrix();
SDL_GL_SwapBuffers();
BASS_Update(0); /* decrease the chance of missing vsync */
SDL_Event e;
while (SDL_PollEvent(&e)) {
if (e.type == SDL_QUIT ||
(e.type == SDL_KEYDOWN &&
e.key.keysym.sym == SDLK_ESCAPE))
done = true;
}
}
#ifndef SYNC_PLAYER
if(should_save) //don't clobber if user just ran it then hit Esc
sync_save_tracks(rocket);
#endif
sync_destroy_device(rocket);
BASS_StreamFree(stream);
BASS_Free();
SDL_Quit();
return 0;
}
