static void _parse_root(config_t *config, xmlDocPtr doc, xmlNodePtr node)
{
do
{
if (node == NULL) break;
if (xmlIsBlankNode(node)) continue;
if (strcmp(node->name, "background") == 0)
SET_INT(config->background);
else if (strcmp(node->name, "logpath") == 0)
SET_STRING(config->logpath);
else if (strcmp(node->name, "logfile") == 0)
SET_STRING(config->logfile);
else if (strcmp(node->name, "loglevel") == 0)
SET_INT(config->loglevel);
else if (strcmp(node->name, "logsize") == 0)
SET_INT(config->logsize);
else if (strcmp(node->name, "consolelog") == 0)
SET_INT(config->log_stderr);
else if (strcmp(node->name, "pidfile") == 0)
SET_STRING(config->pidfile);
else if (strcmp(node->name, "stream") == 0)
_parse_stream(config, doc, node->xmlChildrenNode);
} while ((node = node->next));
}
/**
* CBitmapFont::createFontFromFile
* @date Modified Mar 30, 2006
*/
CBaseResource* CBitmapFont::createFontFromFile(const CString sFilename)
{
// Load font definition and image
CBitmapFont* pFont = new CBitmapFont;
CConfigFile cfgFont(sFilename);
CString sBuffer = cfgFont.GetValue("Font Info", "ImageFile");
if(sBuffer == CString::Blank)
return false;
pFont->m_poTexture = (CTexture2D*)CResourceManager::getInstance().loadResource(RES_TEXTURE2D, sBuffer);
pFont->m_cTileSize = SET_INT(cfgFont.GetValue("Font Info", "FontSize"), 16);
pFont->m_cLineHeight = SET_INT(cfgFont.GetValue("Font Info", "LineHeight"), pFont->m_cTileSize);
pFont->m_cTilesAcross = pFont->m_poTexture->getWidth() / pFont->m_cTileSize;
// Process Font Definition
char szChar[5] = {0};
for(short c = 0; c <= 255; ++c)
{
sprintf(szChar, "%i", c);
pFont->m_mCharMap[(char)c] = (char)(cfgFont.GetValue("Char Widths", szChar).ToInt());
}
return pFont;
}
static void _parse_resample(instance_t *instance,xmlDocPtr doc, xmlNodePtr node)
{
do {
if (node == NULL) break;
if (xmlIsBlankNode(node)) continue;
if(strcmp(node->name, "in-rate") == 0)
SET_INT(instance->resampleinrate);
else if(strcmp(node->name, "out-rate") == 0)
SET_INT(instance->resampleoutrate);
} while((node = node->next));
}
get_user( ZBCompInst *zbc )
{
LWPanelFuncs *panf;
LWPanelID panel;
LWPanControlDesc desc;
LWValue ival = { LWT_INTEGER };
LWControl *ctl[ 3 ];
char *tip[] = {
"Use the Image Editor to load",
"both of these.",
NULL
};
int i, w, w1, ok;
panf = zbc->global( LWPANELFUNCS_GLOBAL, GFUSE_TRANSIENT );
if ( !panf ) return ZCOMP_NAME ": Couldn't get panel functions.";
if( !( panel = PAN_CREATE( panf, "3D Nature's IFF-ZBUF Compositor V2.0" )))
return ZCOMP_NAME ": Couldn't create the panel.";
ctl[ 0 ] = ITEM_CTL( panf, panel, "Z-Buffer", zbc->global, LWI_IMAGE );
ctl[ 1 ] = ITEM_CTL( panf, panel, "Comp Image", zbc->global, LWI_IMAGE );
ctl[ 2 ] = TEXT_CTL( panf, panel, "Note: ", tip );
/* align */
w1 = 40 + CON_LW( ctl[ 1 ] );
for ( i = 0; i < 3; i++ ) {
w = CON_LW( ctl[ i ] );
ival.intv.value = w1 - w;
ctl[ i ]->set( ctl[ i ], CTL_X, &ival );
}
SET_INT( ctl[ 0 ], ( int ) zbc->zimage.id );
SET_INT( ctl[ 1 ], ( int ) zbc->cimage.id );
ok = panf->open( panel, PANF_BLOCKING | PANF_CANCEL );
if ( ok ) {
ctl[ 0 ]->get( ctl[ 0 ], CTL_VALUE, &ival );
zbc->zimage.id = ( LWItemID ) ival.intv.value;
ctl[ 1 ]->get( ctl[ 1 ], CTL_VALUE, &ival );
zbc->cimage.id = ( LWItemID ) ival.intv.value;
}
PAN_KILL( panf, panel );
return NULL;
}
t_stat ptr_wr (int32 data, int32 PA, int32 access)
{
switch ((PA >> 1) & 01) { /* decode PA<1> */
case 0: /* ptr csr */
if (PA & 1)
return SCPE_OK;
if ((data & CSR_IE) == 0)
CLR_INT (PTR);
else if (((ptr_csr & CSR_IE) == 0) && (ptr_csr & (CSR_ERR | CSR_DONE)))
SET_INT (PTR);
if (data & CSR_GO) {
ptr_csr = (ptr_csr & ~CSR_DONE) | CSR_BUSY;
CLR_INT (PTR);
if (ptr_unit.flags & UNIT_ATT) /* data to read? */
sim_activate (&ptr_unit, ptr_unit.wait);
else sim_activate (&ptr_unit, 0); /* error if not */
}
ptr_csr = (ptr_csr & ~PTRCSR_RW) | (data & PTRCSR_RW);
return SCPE_OK;
case 1: /* ptr buf */
return SCPE_OK;
} /* end switch PA */
return SCPE_NXM; /* can't get here */
}
t_stat tto_wr (int32 data, int32 PA, int32 access)
{
switch ((PA >> 1) & 01) { /* decode PA<1> */
case 00: /* tto csr */
if (PA & 1)
return SCPE_OK;
if ((data & CSR_IE) == 0)
CLR_INT (TTO);
else if ((tto_csr & (CSR_DONE + CSR_IE)) == CSR_DONE)
SET_INT (TTO);
tto_csr = (tto_csr & ~TTOCSR_RW) | (data & TTOCSR_RW);
return SCPE_OK;
case 01: /* tto buf */
if ((PA & 1) == 0)
tto_unit.buf = data & 0377;
tto_csr = tto_csr & ~CSR_DONE;
CLR_INT (TTO);
sim_activate (&tto_unit, tto_unit.wait);
return SCPE_OK;
} /* end switch PA */
return SCPE_NXM;
}
static void string_length(LVGActionCtx *ctx, ASClass *cls, uint8_t *a, uint32_t nargs)
{
assert(1 == nargs);
ASVal *res = &ctx->stack[ctx->stack_ptr];
const char *str = (const char *)cls;
SET_INT(res, strlen(str));
}
t_stat tto_svc (UNIT *uptr)
{
uint32 c7b;
UNIT *ruptr = &tty_unit[TTR];
UNIT *puptr = &tty_unit[TTP];
t_stat r;
c7b = tty_buf & 0177;
if (ttp_tape_rcvd != 0) { /* prev = tape? */
ttp_tape_rcvd--; /* decrement state */
if ((ttp_tape_rcvd == 0) && (puptr->flags & UNIT_ATT))
puptr->STA |= RUNNING; /* start after delay */
}
else if (c7b == TAPE) /* char = TAPE? */
ttp_tape_rcvd = 2;
if (ttp_xoff_rcvd != 0) { /* prev = XOFF? */
ttp_xoff_rcvd--; /* decrement state */
if (ttp_xoff_rcvd == 0) /* stop after delay */
puptr->STA &= ~RUNNING;
}
else if (c7b == XOFF) /* char = XOFF? */
ttp_xoff_rcvd = 2;
if ((c7b == XON) && (ruptr->flags & UNIT_ATT)) { /* char = XON? */
ruptr->STA |= RUNNING; /* start reader */
ttr_xoff_read = 0; /* cancel stop */
}
if ((r = tto_write (tty_buf)) != SCPE_OK) { /* print; error? */
sim_activate (uptr, uptr->wait); /* try again */
return ((r == SCPE_STALL)? SCPE_OK: r); /* !stall? report */
}
if ((r = ttp_write (tty_buf)) != SCPE_OK) /* punch; error? */
return r;
SET_INT (INT_TTY); /* set done flag */
return SCPE_OK;
}
t_stat tti_svc (UNIT *uptr)
{
int32 out, c;
UNIT *ruptr = &tty_unit[TTR];
sim_activate (uptr, uptr->wait); /* continue poll */
if ((c = sim_poll_kbd ()) >= SCPE_KFLAG) { /* character? */
out = c & 0177; /* mask echo to 7b */
if (c & SCPE_BREAK) /* break? */
c = 0;
else c = sim_tt_inpcvt (c, TT_GET_MODE (uptr->flags) | TTUF_KSR);
uptr->pos = uptr->pos + 1;
}
else if (c != SCPE_OK) /* error? */
return c;
else if ((ruptr->flags & UNIT_ATT) && /* TTR attached */
(ruptr->STA & RUNNING)) { /* and running? */
if (ruptr->STA & LF_PEND) { /* lf pending? */
c = 0212; /* char is lf */
ruptr->STA &= ~LF_PEND; /* clear flag */
}
else { /* normal read */
if ((c = getc (ruptr->fileref)) == EOF) { /* read byte */
if (feof (ruptr->fileref)) { /* EOF? */
ruptr->STA &= ~RUNNING; /* stop reader */
if (ttr_stopioe)
printf ("TTR end of file\n");
else return SCPE_OK;
}
else perror ("TTR I/O error");
clearerr (ruptr->fileref);
return SCPE_IOERR;
}
if ((ruptr->flags & UNIT_UASC) && (c == '\n')) {
c = 0215; /* Unix ASCII NL? */
ruptr->STA |= LF_PEND; /* LF pending */
}
else if ((ruptr->flags & UNIT_ASC) && (c != 0))
c = c | 0200; /* ASCII nz? cvt */
ruptr->pos = ftell (ruptr->fileref);
}
if (ttr_xoff_read != 0) { /* reader stopping? */
if (c == RUBOUT) /* rubout? stop */
ttr_xoff_read = 0;
else ttr_xoff_read--; /* else decr state */
if (ttr_xoff_read == 0) /* delay done? */
ruptr->STA &= ~RUNNING; /* stop reader */
}
else if ((c & 0177) == XOFF) /* XOFF read? */
ttr_xoff_read = 2;
out = c; /* echo char */
}
else return SCPE_OK; /* no char */
if (tty_mode == 0) { /* input mode? */
tty_buf = c & 0377; /* put char in buf */
SET_INT (INT_TTY); /* set flag */
}
tto_write (out); /* echo to printer */
return ttp_write (out); /* and punch */
}
t_stat ptp_svc (UNIT *uptr)
{
int32 c;
SET_INT (INT_PTP); /* set flag */
if (ptp_power == 0) { /* power on? */
ptp_power = 1; /* ptp is ready */
return SCPE_OK;
}
if ((uptr->flags & UNIT_ATT) == 0) /* attached? */
return IORETURN (ptp_stopioe, SCPE_UNATT);
if (uptr->flags & UNIT_ASC) { /* ASCII? */
c = uptr->buf & 0177; /* mask to 7b */
if ((uptr->flags & UNIT_UASC) && (c == 015)) /* cr? drop if Unix */
return SCPE_OK;
else if (c == 012) /* lf? cvt to nl */
c = '\n';
}
else c = uptr->buf & 0377; /* no, binary */
if (putc (c, uptr->fileref) == EOF) { /* output byte */
perror ("PTP I/O error");
clearerr (uptr->fileref);
return SCPE_IOERR;
}
uptr->pos = ftell (uptr->fileref); /* update pos */
return SCPE_OK;
}
t_stat ptr_svc (UNIT *uptr)
{
int32 c;
if ((uptr->flags & UNIT_ATT) == 0) /* attached? */
return IORETURN (ptr_stopioe, SCPE_UNATT);
if (uptr->STA & LF_PEND) { /* lf pending? */
uptr->STA &= ~LF_PEND; /* clear flag */
c = 0212; /* insert LF */
}
else {
if ((c = getc (uptr->fileref)) == EOF) { /* read byte */
if (feof (uptr->fileref)) {
if (ptr_stopioe)
printf ("PTR end of file\n");
else return SCPE_OK;
}
else perror ("PTR I/O error");
clearerr (uptr->fileref);
return SCPE_IOERR;
}
if ((uptr->flags & UNIT_UASC) && (c == '\n')) { /* Unix newline? */
c = 0215; /* insert CR */
uptr->STA |= LF_PEND; /* lf pending */
}
else if ((uptr->flags & UNIT_ASC) && (c != 0)) /* ASCII? */
c = c | 0200;
uptr->pos = ftell (uptr->fileref); /* update pos */
}
SET_INT (INT_PTR); /* set ready flag */
uptr->buf = c & 0377; /* get byte */
return SCPE_OK;
}
t_stat
ptr_svc(UNIT * uptr)
{
int32 temp;
ptr_csr = (ptr_csr | CSR_ERR) & ~CSR_BUSY;
if (ptr_csr & CSR_IE)
SET_INT(PTR);
if ((ptr_unit.flags & UNIT_ATT) == 0)
return IORETURN(ptr_stopioe, SCPE_UNATT);
if ((temp = fgetc(ptr_unit.fileref)) == EOF) {
if (feof(ptr_unit.fileref)) {
if (ptr_stopioe)
printf("PTR end of file\n");
else
return SCPE_OK;
} else
perror("PTR I/O error");
clearerr(ptr_unit.fileref);
return SCPE_IOERR;
}
ptr_csr = (ptr_csr | CSR_DONE) & ~CSR_ERR;
ptr_unit.buf = temp & 0377;
ptr_unit.pos = ptr_unit.pos + 1;
return SCPE_OK;
}
t_stat ptp_wr (int32 data, int32 PA, int32 access)
{
switch ((PA >> 1) & 01) { /* decode PA<1> */
case 0: /* ptp csr */
if (PA & 1)
return SCPE_OK;
if ((data & CSR_IE) == 0)
CLR_INT (PTP);
else if (((ptp_csr & CSR_IE) == 0) && (ptp_csr & (CSR_ERR | CSR_DONE)))
SET_INT (PTP);
ptp_csr = (ptp_csr & ~PTPCSR_RW) | (data & PTPCSR_RW);
return SCPE_OK;
case 1: /* ptp buf */
if ((PA & 1) == 0)
ptp_unit.buf = data & 0377;
ptp_csr = ptp_csr & ~CSR_DONE;
CLR_INT (PTP);
if (ptp_unit.flags & UNIT_ATT) /* file to write? */
sim_activate (&ptp_unit, ptp_unit.wait);
else sim_activate (&ptp_unit, 0); /* error if not */
return SCPE_OK;
} /* end switch PA */
return SCPE_NXM; /* can't get here */
}
void rp_updsta (int32 newa, int32 newb)
{
int32 f;
UNIT *uptr;
uptr = rp_dev.units + GET_UNIT (rp_sta);
rp_sta = (rp_sta & ~(STA_DYN | STA_ERR)) | newa;
rp_stb = (rp_stb & ~STB_DYN) | newb;
if (uptr->flags & UNIT_WPRT)
rp_sta = rp_sta | STA_SUWP;
if ((uptr->flags & UNIT_ATT) == 0)
rp_stb = rp_stb | STB_SUFU | STB_SUNR;
else if (sim_is_active (uptr)) {
f = (uptr->FUNC) & STA_M_FUNC;
if ((f == FN_SEEK) || (f == FN_RECAL))
rp_stb = rp_stb | STB_SUSU | STB_SUNR;
}
else if (uptr->CYL >= RP_NUMCY)
rp_sta = rp_sta | STA_SUSI;
if ((rp_sta & STA_EFLGS) || (rp_stb & STB_EFLGS))
rp_sta = rp_sta | STA_ERR;
if (((rp_sta & (STA_ERR | STA_DON)) && (rp_sta & STA_IED)) ||
((rp_stb & STB_ATTN) && (rp_sta & STA_IEA)))
SET_INT (RP);
else CLR_INT (RP);
return;
}
t_stat ttpi_svc (UNIT *uptr)
{
int32 c, out;
sim_activate (uptr, KBD_WAIT (uptr->wait, lfc_poll)); /* continue poll */
ttp_sta = ttp_sta & ~STA_FR; /* clear break */
if ((c = sim_poll_kbd ()) < SCPE_KFLAG) /* no char or error? */
return c;
ttp_sta = ttp_sta & ~STA_PF; /* clear parity err */
if (ttp_kchp) /* overrun? */
ttp_sta = ttp_sta | STA_OVR;
if (ttp_karm)
SET_INT (v_TTP);
if (c & SCPE_BREAK) { /* break? */
ttp_sta = ttp_sta | STA_FR; /* framing error */
uptr->buf = 0; /* no character */
}
else {
out = c & 0x7F; /* echo is 7b */
c = sim_tt_inpcvt (c, TT_GET_MODE (uptr->flags));
if (TT_GET_MODE (uptr->flags) != TT_MODE_8B) /* not 8b mode? */
c = pas_par (ttp_cmd, c); /* apply parity */
uptr->buf = c; /* save char */
uptr->pos = uptr->pos + 1; /* incr count */
ttp_kchp = 1; /* char pending */
if (ttp_cmd & CMD_ECHO) {
out = sim_tt_outcvt (out, TT_GET_MODE (uptr->flags));
if (c >= 0)
sim_putchar (out);
ttp_unit[TTO].pos = ttp_unit[TTO].pos + 1;
}
}
return SCPE_OK;
}
static jboolean android_view_GraphicBuffer_lockCanvas(JNIEnv* env, jobject,
jlong wrapperHandle, jobject canvas, jobject dirtyRect) {
GraphicBufferWrapper* wrapper =
reinterpret_cast<GraphicBufferWrapper*>(wrapperHandle);
if (!wrapper) {
return JNI_FALSE;
}
sp<GraphicBuffer> buffer(wrapper->buffer);
Rect rect;
if (dirtyRect) {
rect.left = GET_INT(dirtyRect, gRectClassInfo.left);
rect.top = GET_INT(dirtyRect, gRectClassInfo.top);
rect.right = GET_INT(dirtyRect, gRectClassInfo.right);
rect.bottom = GET_INT(dirtyRect, gRectClassInfo.bottom);
} else {
rect.set(Rect(buffer->getWidth(), buffer->getHeight()));
}
void* bits = NULL;
status_t status = buffer->lock(LOCK_CANVAS_USAGE, rect, &bits);
if (status) return JNI_FALSE;
if (!bits) {
buffer->unlock();
return JNI_FALSE;
}
ssize_t bytesCount = buffer->getStride() * bytesPerPixel(buffer->getPixelFormat());
SkBitmap bitmap;
bitmap.setInfo(SkImageInfo::Make(buffer->getWidth(), buffer->getHeight(),
convertPixelFormat(buffer->getPixelFormat()),
kPremul_SkAlphaType),
bytesCount);
if (buffer->getWidth() > 0 && buffer->getHeight() > 0) {
bitmap.setPixels(bits);
} else {
bitmap.setPixels(NULL);
}
SET_INT(canvas, gCanvasClassInfo.mSurfaceFormat, buffer->getPixelFormat());
INVOKEV(canvas, gCanvasClassInfo.setNativeBitmap, reinterpret_cast<jlong>(&bitmap));
SkRect clipRect;
clipRect.set(rect.left, rect.top, rect.right, rect.bottom);
SkCanvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvas);
nativeCanvas->clipRect(clipRect);
if (dirtyRect) {
INVOKEV(dirtyRect, gRectClassInfo.set,
int(rect.left), int(rect.top), int(rect.right), int(rect.bottom));
}
return JNI_TRUE;
}
void dp_done (uint32 flg)
{
dp_sta = (dp_sta | STC_IDL | flg) & ~STA_BSY; /* set flag, idle */
SET_INT (v_DPC); /* unmaskable intr */
if (flg) /* if err, stop ch */
sch_stop (dp_dib.sch);
return;
}
static void _parse_encode(instance_t *instance,xmlDocPtr doc, xmlNodePtr node)
{
instance->encode = 1;
do {
if (node == NULL) break;
if (xmlIsBlankNode(node)) continue;
if (strcmp(node->name, "nominal-bitrate") == 0)
SET_INT(instance->nom_br);
else if (strcmp(node->name, "minimum-bitrate") == 0)
SET_INT(instance->min_br);
else if (strcmp(node->name, "maximum-bitrate") == 0)
SET_INT(instance->max_br);
else if (strcmp(node->name, "quality") == 0)
SET_FLOAT(instance->quality);
else if (strcmp(node->name, "samplerate") == 0)
SET_INT(instance->samplerate);
else if (strcmp(node->name, "channels") == 0)
SET_INT(instance->channels);
else if (strcmp(node->name, "managed") == 0)
SET_INT(instance->managed);
else if (strcmp(node->name, "flush-samples") == 0)
SET_INT(instance->max_samples_ppage);
} while ((node = node->next));
if (instance->max_samples_ppage == 0)
instance->max_samples_ppage = instance->samplerate;
if (instance->max_samples_ppage < instance->samplerate/100)
instance->max_samples_ppage = instance->samplerate/100;
}
void txcs_wr (int32 data)
{
if ((data & CSR_IE) == 0)
CLR_INT (TTO);
else if ((tto_csr & (CSR_DONE + CSR_IE)) == CSR_DONE)
SET_INT (TTO);
tto_csr = (tto_csr & ~TTOCSR_RW) | (data & TTOCSR_RW);
return;
}
static void set_scroll( void )
{
int i;
if ( !inscroll ) {
i = ( int )( 1000.0 * ( double ) pos / ( double ) filesize );
SET_INT( ctl[ 10 ], i );
}
}
t_stat dp_done (uint32 req, uint32 flg)
{
dp_xip = 0; /* clear xfr in prog */
dp_sta = (dp_sta | flg) & ~(STA_BUSY | STA_MBZ); /* clear busy */
if (req || dp_defint) /* if req, set intr */
SET_INT (INT_DP);
dp_defint = 0; /* clr def intr */
return SCPE_OK;
}
static void create_controls( ConvolveInst *inst )
{
const LWDisplayMetrics *dm;
int x, y, dx, dy, w, i, pw, ph;
/* create a control */
ctl[ 0 ] = FLOAT_CTL( panf, panel, "" );
/* find out how much vertical space the panel wants for drawing its
own decorations */
ph = PAN_GETH( panf, panel );
ph -= CON_H( ctl[ 0 ] );
/* create the rest of the controls */
for ( i = 1; i < 9; i++ )
ctl[ i ] = FLOAT_CTL( panf, panel, "" );
ctl[ 9 ] = WPOPUP_CTL( panf, panel, "Presets", preset, 150 );
/* position all of the controls */
x = CON_X( ctl[ 0 ] );
y = CON_Y( ctl[ 0 ] );
dx = CON_HOTW( ctl[ 0 ] ) + 8;
dy = CON_HOTH( ctl[ 0 ] ) + 4;
for ( i = 1; i < 9; i++ )
MOVE_CON( ctl[ i ], x + dx * ( i % 3 ), y + dy * ( i / 3 ));
w = CON_W( ctl[ 9 ] );
MOVE_CON( ctl[ 9 ], x + 3 * dx - w, y + 10 * dy / 3 );
/* now that we know how much room the controls will take up, set the
height of the panel and center it */
ph += CON_Y( ctl[ 9 ] );
ph += CON_HOTH( ctl[ 9 ] );
PAN_SETH( panf, panel, ph - 6 );
pw = PAN_GETW( panf, panel );
dm = panf->drawFuncs->dispMetrics();
MOVE_PAN( panf, panel, ( dm->width - pw ) / 2, ( dm->height - ph ) / 2 );
/* initialize the controls */
set_kernctl( inst );
SET_INT( ctl[ 9 ], pindex );
/* set the control event callbacks */
CON_SETEVENT( ctl[ 9 ], handle_preset, inst );
}
t_stat dp_detach (UNIT *uptr)
{
uint32 u = uptr - dp_dev.units;
if (!(uptr->flags & UNIT_ATT)) /* attached? */
return SCPE_OK;
if (dpd_arm[u]) /* if arm, intr */
SET_INT (v_DPC + u + 1);
return detach_unit (uptr);
}
void keyscanner_main(void)
{
/* TODO: low power mode:
* When all keys reported up:
* DDR_PP = 0x11; PORT_PP = 0x00;
* Guarantee wake on TWI / any PORT_OD pin FALLING
* Sleep
*/
for (uint8_t pp = 0; pp < 8; ++pp) {
uint8_t pp_bitmask = _BV(pp);
_delay_ms(0.5);
DDR_PP = 0x00 ^ pp_bitmask;
PORT_PP = 0xFF ^ pp_bitmask;
_delay_ms(0.5);
uint8_t od_bits = PIN_OD;
/*
* Rollover conditions exist if:
* * Multiple OD pins are pulled low AND
* * Multiple PP pins are pulled low
*/
uint8_t nPp = popCount(~PIN_PP);
uint8_t nOd = popCount(~od_bits);
// Most of the time the keyboard will not be a rollover state
if (__builtin_expect(nPp > 1 && nOd > 1, 0)) {
continue;
}
// Debounce key state
uint8_t changes = debounce(od_bits, db + pp);
// Most of the time there will be no new key events
if (__builtin_expect(changes == 0, 1)) {
continue;
}
DISABLE_INTERRUPTS({
key_t key;
key.dataNumber = 0; // Set by I²C code (ringbuf.count != 0)
key.pp = pp;
for (int8_t od = 0; od < 8; od++) {
// Fewer than half the keys are expected to be down for each scanline
if (__builtin_expect(bit_is_set(changes, od), 0)) {
key.keyState = bit_is_clear(db[pp].state, od);
key.od = od;
ringbuf_append(key.val);
}
}
SET_INT(0);
});
}
static void
cfg_main_section_save (const char *section)
{
char *filters;
SET_STRING(theme);
SET_STRING(engine);
SET_STRING(verbosity);
SET_STRING(log_file);
SET_INT(idle_timeout);
SET_INT(fullscreen);
SET_INT(slideshow_delay);
SET_BOOL(display_mouse);
SET_TUPLE(music_filters, "music_ext");
SET_TUPLE(video_filters, "video_ext");
SET_TUPLE(photo_filters, "photo_ext");
}
static jboolean android_view_TextureView_lockCanvas(JNIEnv* env, jobject,
jlong nativeWindow, jobject canvas, jobject dirtyRect) {
if (!nativeWindow) {
return JNI_FALSE;
}
ANativeWindow_Buffer buffer;
Rect rect;
if (dirtyRect) {
rect.left = GET_INT(dirtyRect, gRectClassInfo.left);
rect.top = GET_INT(dirtyRect, gRectClassInfo.top);
rect.right = GET_INT(dirtyRect, gRectClassInfo.right);
rect.bottom = GET_INT(dirtyRect, gRectClassInfo.bottom);
} else {
rect.set(Rect(0x3FFF, 0x3FFF));
}
sp<ANativeWindow> window((ANativeWindow*) nativeWindow);
int32_t status = native_window_lock(window.get(), &buffer, &rect);
if (status) return JNI_FALSE;
ssize_t bytesCount = buffer.stride * bytesPerPixel(buffer.format);
SkBitmap bitmap;
bitmap.setConfig(convertPixelFormat(buffer.format), buffer.width, buffer.height, bytesCount);
if (buffer.format == WINDOW_FORMAT_RGBX_8888) {
bitmap.setIsOpaque(true);
}
if (buffer.width > 0 && buffer.height > 0) {
bitmap.setPixels(buffer.bits);
} else {
bitmap.setPixels(NULL);
}
SET_INT(canvas, gCanvasClassInfo.mSurfaceFormat, buffer.format);
SkCanvas* nativeCanvas = SkNEW_ARGS(SkCanvas, (bitmap));
swapCanvasPtr(env, canvas, nativeCanvas);
SkRect clipRect;
clipRect.set(rect.left, rect.top, rect.right, rect.bottom);
nativeCanvas->clipRect(clipRect);
if (dirtyRect) {
INVOKEV(dirtyRect, gRectClassInfo.set,
int(rect.left), int(rect.top), int(rect.right), int(rect.bottom));
}
return JNI_TRUE;
}
t_stat ttp_set_break (UNIT *uptr, int32 val, char *cptr, void *desc)
{
if (ttp_dev.flags & DEV_DIS)
return SCPE_NOFNC;
ttp_sta = ttp_sta | STA_FR;
if (ttp_karm) /* if armed, intr */
SET_INT (v_TTP);
sim_cancel (&ttp_unit[TTI]); /* restart TT poll */
sim_activate (&ttp_unit[TTI], ttp_unit[TTI].wait);
return SCPE_OK;
}
void ttox_clr_done (int32 ln)
{
ttox_done = ttox_done & ~(1 << ln);
if (ttox_done) {
SET_INT (TTO1);
}
else {
CLR_INT (TTO1);
}
return;
}
// HandleList():
void HandleList( LWControl *con, void *data ) {
int index, column, other;
GET_IVEC( rint->list, index, column, other );
if( index >= (int)rint->swaps.NumElements() ) {
index = ((int)rint->swaps.NumElements()) - 1;
SET_IVEC( rint->list, index, 1, 0 );
} else {
if( index != -1 ) {
int x = CON_MOUSEX( con );
int y = CON_MOUSEY( con );
if( x < list_column_widths[0] + 8 )
rint->swaps[ index ]->SetUse( !rint->swaps[ index ]->GetUse() );
}
}
if( index == -1 ) {
SET_STR( rint->path, "", 0 );
SET_FLOAT( rint->weight, 1.0 );
SET_INT( rint->enable, 1 );
GHOST_CON( rint->path );
GHOST_CON( rint->weight );
GHOST_CON( rint->enable );
} else {
char * string = (char *)rint->swaps[ index ]->GetFullPath();
if( string == NULL ) {
SET_STR( rint->path, "", 0 );
} else {
SET_STR( rint->path, string, strlen( string ) );
}
SET_FLOAT( rint->weight, rint->swaps[ index ]->GetWeight() );
SET_INT( rint->enable, rint->swaps[ index ]->GetUse() );
UNGHOST_CON( rint->path );
UNGHOST_CON( rint->weight );
UNGHOST_CON( rint->enable );
}
}
t_stat clk_svc (UNIT *uptr)
{
int32 t;
clk_csr = clk_csr | CSR_DONE; /* set done */
if ((clk_csr & CSR_IE) || clk_fie) SET_INT (CLK);
t = sim_rtcn_calb (clk_tps, TMR_CLK); /* calibrate clock */
sim_activate (&clk_unit, t); /* reactivate unit */
tmr_poll = t; /* set timer poll */
tmxr_poll = t; /* set mux poll */
return SCPE_OK;
}
