void fxConnect(txMachine* the)
{
#if TARGET_OS_MAC
FskThread thread = NULL;
FskThreadCreate(&thread, fxConnectThreadProc, kFskThreadFlagsJoinable, the, "fxConnect");
#else
fxDoConnect(the);
#endif
}
FskErr KplAudioStart(KplAudio audio)
{
FskErr err = kFskErrNone;
audio->played = 0;
bailIfError(FskThreadCreate(&audio->thread, KplAudioThread, kFskThreadFlagsJoinable | kFskThreadFlagsWaitForInit, audio, "KplAudioThread"));
bail:
return err;
}
FskErr FskECMAScriptInitialize(const char *configPath)
{
FskErr err = kFskErrNone;
FskExtensionsEmbedLoad(NULL);
#if TARGET_OS_ANDROID
{
FskThread thread = NULL;
err = FskThreadCreate(&thread, FskECMAScriptInitializeThread, kFskThreadFlagsDefault, NULL, "KPR");
}
#else
FskECMAScriptInitializeThread();
#endif
return err;
}
void KprServicesStart(KprShell shell)
{
UInt32 flags = kFskThreadFlagsWaitForInit | kFskThreadFlagsJoinable;
KprService service = gServices;
FskThread thread = KprShellGetThread(gShell);
xsMachine* the = gShell->the;
gServicesThreadQuitting = false;
FskThreadCreate(&gServicesThread, KprServicesLoop, flags, NULL, "services");
while (service) {
if (!(service->flags & kprServicesThread)) {
FskInstrumentedTypePrintfNormal(&KprServiceInstrumentation, "Starting %s", service->id);
(*service->start)(service, thread, the);
}
service = service->next;
}
}
FskErr linuxDigitalRepeat(FskPinDigital pin, FskPinDigitalRepeatTriggerProc triggeredCallback, void *refCon)
{
linuxDigital ld = (linuxDigital)pin;
linuxDigital walker;
int interruptCount;
if (!ld->canInterrupt)
return kFskErrUnimplemented;
if ((ld->triggeredCallback == triggeredCallback) && (ld->triggeredRefCon == refCon))
return kFskErrNone;
ld->triggeredCallback = triggeredCallback,
ld->triggeredRefCon = refCon;
for (walker = gLinuxDigitalPins->list, interruptCount = 0; NULL != walker; walker = *(linuxDigital *)walker) {
linuxDigital w = (linuxDigital)(((char *)walker) - offsetof(linuxDigitalRecord, next));
if (!w->canInterrupt)
continue;
if (!w->triggeredCallback)
continue;
interruptCount += 1;
}
gGPIOPollersSeed++;
if (0 == interruptCount) {
if (gGPIOThread)
gpioThreadQuit();
}
else if ((1 == interruptCount) && (NULL == gGPIOThread)) {
gGPIOEventFD = eventfd(0, EFD_NONBLOCK);
if (gGPIOEventFD >= 0)
FskThreadCreate(&gGPIOThread, gpioThread, kFskThreadFlagsDefault, NULL, "linux digital repeat thread");
}
else {
uint64_t one = 1;
write(gGPIOEventFD, &one, sizeof(one));
}
return kFskErrNone;
}
FskErr FskGtkWindowCreate(FskWindow fskWindow, UInt32 style, SInt32 width, SInt32 height)
{
FskErr err = kFskErrNone;
FskGtkWindow gtkWin;
if(fskWindow->gtkWin == NULL) {
err = FskMemPtrNewClear(sizeof(FskGtkWindowRecord), &(fskWindow->gtkWin));
BAIL_IF_ERR(err);
}
gtkWin = (FskGtkWindow)fskWindow->gtkWin;
gtkWin->width = width;
gtkWin->height = height;
//Create gtk thread: initialization and main loop for GTK
FskThreadCreate(&fskWindow->gtkThread, FskGtkWindowLoop, kFskThreadFlagsJoinable | kFskThreadFlagsWaitForInit, fskWindow, "gtk_thread");
bail:
return err;
}
FskErr KplScreenGetBitmap(KplBitmap *bitmap)
{
FskErr err = kFskErrNone;
FrameBufferVectorSet fbv;
if (!gKplScreen) {
BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KplScreenRecord), (FskMemPtr *)&gKplScreen));
BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KplBitmapRecord), (FskMemPtr *)&gKplScreen->bitmap));
fbGetScreenDim(&gScreenWidth, &gScreenHeight);
fprintf(stderr, "ScreenWidth: %d, ScreenHeight: %d\n", gScreenWidth, gScreenHeight);
gKplScreen->bitmap->width = gScreenWidth;
gKplScreen->bitmap->height = gScreenHeight;
gKplScreen->bitmap->pixelFormat = kScreenPixelFormat;
gKplScreen->bitmap->depth = kScreenDepth;
gKplScreen->bitmap->rowBytes = gScreenWidth * (kScreenDepth / 8);
BAIL_IF_ERR(err = FskMemPtrNewClear(gKplScreen->bitmap->rowBytes * gScreenHeight, (FskMemPtr *)&gKplScreen->bitmap->baseAddress));
initializeLinuxInput(gScreenWidth, gScreenHeight);
}
gKplScreen->vSyncInterval = MAX_FRAMERATE_MS;
gKplScreen->vSyncIntervalTime.useconds = MAX_FRAMERATE_MS * 1000;
FskSemaphoreNew(&gKplScreen->flipSemaphore, 0);
FskThreadCreate(&gKplScreen->flipThread, flipThread, kFskThreadFlagsJoinable | kFskThreadFlagsWaitForInit, gKplScreen, "flip");
FskFrameBufferGetVectors(&fbv);
if (fbv) {
fbv->doHasProperty = KplScreenHasProperty;
fbv->doSetProperty = KplScreenSetProperty;
fbv->doGetProperty = KplScreenGetProperty;
}
*bitmap = gKplScreen->bitmap;
bail:
return err;
}
FskErr KplScreenGetBitmap(KplBitmap *bitmap)
{
FskErr err = kFskErrNone;
KplScreen screen = NULL;
int bpp;
// Perform one-time intialization on the first request
if (!gKplScreen) {
FrameBufferVectorSet vectors;
char *fbdev = deviceName;
FskTimeRecord now;
if (getenv("FRAMEBUFFER"))
fbdev = getenv("FRAMEBUFFER");
BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KplScreenRecord), (FskMemPtr *)&screen));
BAIL_IF_ERR(err = FskMemPtrNewClear(sizeof(KplBitmapRecord), (FskMemPtr *)&screen->bitmap));
screen->fbfd = open(fbdev, O_RDWR);
if (-1 != screen->fbfd) {
if (ioctl(screen->fbfd, FBIOGET_FSCREENINFO, &screen->finfo)) {
fprintf(stderr, "Error: fb - reading fixed info\n");
exit(2);
}
if (ioctl(screen->fbfd, FBIOGET_VSCREENINFO, &screen->vinfo)) {
fprintf(stderr, "Error: fb - reading variable info\n");
exit(3);
}
gScreenWidth = screen->vinfo.xres;
gScreenHeight = screen->vinfo.yres;
bpp = screen->vinfo.bits_per_pixel;
screen->rowBytes = screen->vinfo.xres_virtual * bpp / 8;
screen->screensize = gScreenHeight * screen->rowBytes;
screen->framebuffer = (char*)mmap((void*)screen->finfo.smem_start, screen->finfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, screen->fbfd, 0);
fprintf(stderr, "framebuffer mem_start: %d, length %d\n", screen->finfo.smem_start, screen->finfo.smem_len);
fprintf(stderr, "mmio_start: %d, mmio_len: %d\n", screen->finfo.mmio_start, screen->finfo.mmio_len);
if (screen->framebuffer == (char*)-1) {
fprintf(stderr,"Error: can't map framebuffer %d\n", errno);
exit(4);
}
screen->displayPage = 0;
screen->baseAddr[0] = screen->framebuffer;
// screen->baseAddr[1] = screen->framebuffer + screen->finfo.ypanstep * screen->finfo.line_length;
FskBitmapNew(gScreenWidth, gScreenHeight, kFskBitmapFormat16RGB565LE, &screen->bitmaps[0]);
// FskBitmapNew(gScreenWidth, gScreenHeight, kFskBitmapFormat16RGB565LE, &screen->bitmaps[1]);
FskBitmapWriteBegin(screen->bitmaps[0], NULL, NULL, NULL);
// FskBitmapWriteBegin(screen->bitmaps[1], NULL, NULL, NULL);
FskMutexNew(&screen->withCare, "screen flipper");
}
else {
fprintf(stderr, "Error: can't open framebuffer device - use ram\n");
gScreenWidth = 320;
gScreenHeight = 240;
bpp = 16;
screen->rowBytes = gScreenWidth * bpp / 8;
screen->screensize = gScreenHeight * screen->rowBytes;
FskMemPtrNew(screen->screensize, (FskMemPtr*)&screen->framebuffer);
}
#if 0
devFBFlip(screen);
devFBFlip(screen);
#endif
FskTimeGetNow(&now);
devFBFlip(screen);
FskTimeGetNow(&screen->vSyncIntervalTime);
FskTimeSub(&now, &screen->vSyncIntervalTime);
screen->vSyncInterval = FskTimeInMS(&screen->vSyncIntervalTime);
// if (!screen->vSyncInterval) screen->vSyncInterval = 1;
if (!screen->vSyncInterval) screen->vSyncInterval = 32;
FskInstrumentedTypePrintfDebug(&gKplScreenTypeInstrumentation, "VsyncInterval = %d", screen->vSyncInterval);
screen->bitmap->baseAddress = screen->baseAddr[screen->displayPage];
screen->bitmap->rowBytes = screen->rowBytes;
screen->bitmap->pixelFormat = kFskBitmapFormat16RGB565LE;
screen->bitmap->depth = 16;
screen->bitmap->width = gScreenWidth;
screen->bitmap->height = gScreenHeight;
#if SUPPORT_FLIP_THREAD
FskSemaphoreNew(&screen->flipSemaphore, 0);
FskThreadCreate(&screen->flipThread, flipThread, kFskThreadFlagsJoinable | kFskThreadFlagsWaitForInit | kFskThreadFlagsHighPriority, screen, "dfb flip");
#endif
BAIL_IF_ERR(err = FskFrameBufferGetVectors(&vectors));
vectors->doHasProperty = KplScreenHasProperty;
vectors->doSetProperty = KplScreenSetProperty;
vectors->doGetProperty = KplScreenGetProperty;
gKplScreen = screen;
initializeLinuxInput(gScreenWidth, gScreenHeight);
}
*bitmap = gKplScreen->bitmap;
if (NULL == *bitmap)
err = kFskErrNotFound;
bail:
if (err) {
if (screen) {
//dispose of data structures here
FskMemPtrDispose(screen);
}
*bitmap = NULL;
}
return err;
}
