FskErr androidAudioOutStop(FskAudioOut audioOut) { androidAudioExt *ext; FskSampleTime pos; SLresult res; FskErr err = kFskErrNone; FskAudioNativePrintfVerbose("audioOutStop %x", audioOut); BAIL_IF_NULL(audioOut, err, kFskErrNone); ext = (androidAudioExt*)audioOut->ext; BAIL_IF_NULL(ext, err, kFskErrNone); if (ext->flushTimer) { FskAudioNativePrintfVerbose("%x -- Disposing of flushTimer", audioOut); FskTimeCallbackDispose(ext->flushTimer); ext->flushTimer = NULL; } if (!audioOut->playing) { FskAudioNativePrintfDebug(" -- wuzn't playin"); BAIL(kFskErrNone); } androidAudioOutGetSamplePosition(audioOut, &ext->stoppedAtSamplePosition); // get final pos before we shut it down FskAudioNativePrintfVerbose("stoppedAtSamplePosition = %lld", ext->stoppedAtSamplePosition); audioOut->playing = false; FskAudioNativePrintfVerbose("-- stopping audioOut: %x", audioOut); res = (*ext->playItf)->SetPlayState(ext->playItf, SL_PLAYSTATE_STOPPED); CheckErr(" audioOutStop - set playstate stopped", res); if (gActiveAudioOut == audioOut) { FskMutexAcquire(gActiveAudioMutex); gActiveAudioOut = NULL; FskMutexRelease(gActiveAudioMutex); } androidAudioOutFlush(audioOut); bail: removeFromQueue(audioOut, kAll); return err; }
void KprDebugMachineChangeTitle(KprDebugMachine self, char* theTitle) { FskErr err = kFskErrNone; // FskDebugStr("%s: %s", __FUNCTION__, theTitle); BAIL_IF_NULL(self->title = FskStrDoCopy(theTitle), err, kFskErrMemFull); KprDebugMachineCallbackText(self, "onMachineTitleChanged", mxNoCommand, theTitle); bail: return; }
jint JAVANAME(KinomaPlay_doPause)(JNIEnv* env, jclass clazz) { FskErr err = kFskErrNone; FskWindow fWin = FskWindowGetActive(); FskThread drawThread; FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "[%p] KinomaPlay_doPause(%p, %p, %p) calling ShutdownGLCallback()", (void*)pthread_self(), env, clazz, fWin); BAIL_IF_NULL(fWin, err, kFskErrBadState); drawThread = fWin->thread; err = FskThreadPostCallback(drawThread, ShutdownGLCallback, NULL, NULL, NULL, NULL); bail: return !err; }
jint JAVANAME(KinomaPlay_doResume)(JNIEnv* env, jclass clazz) { FskErr err = kFskErrNone; FskWindow fWin = FskWindowGetActive(); FskThread drawThread; FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation,"[%p] KinomaPlay_doResume(%p, %p, %p)", (void*)pthread_self(), env, clazz, fWin); BAIL_IF_NULL(fWin, err, kFskErrBadState); drawThread = fWin->thread; FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "KinomaPlay_doResume: drawThread is %p %s", drawThread, drawThread ? "" : ", bailing"); BAIL_IF_NULL(drawThread, err, kFskErrBadState); FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "KinomaPlay_doResume calling InitGLCallback"); FskMutexAcquire(jniRespMutex); err = FskThreadPostCallback(drawThread, InitGLCallback, theNativeWindow, NULL, NULL, NULL); if (!gQuitting) { FskConditionWait(jniRespCond, jniRespMutex); FskMutexRelease(jniRespMutex); } FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "KinomaPlay_doResume: FskThreadPostCallback(InitGLCallback) returns %d", err); FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "[%p] KinomaPlay_doResume successful", (void*)pthread_self()); bail: return !err; }
FskErr amrReaderNew(FskMediaReader reader, void **readerState, const char *mimeType, const char *uri, FskMediaSpooler spooler) { FskErr err; amrReader state = NULL; BAIL_IF_NULL(spooler, err, kFskErrUnimplemented); err = FskMemPtrNewClear(sizeof(amrReaderRecord), &state); BAIL_IF_ERR(err); *readerState = state; // must be set before anything that might issue a callback state->spooler = spooler; state->reader = reader; if (spooler->doOpen) { err = (spooler->doOpen)(spooler, kFskFilePermissionReadOnly); BAIL_IF_ERR(err); state->spoolerOpen = true; } state->spooler->onSpoolerCallback = amrSpoolerCallback; state->spooler->clientRefCon = state; state->spooler->flags |= kFskMediaSpoolerForwardOnly; state->duration = kFskUInt32Max; (reader->doSetState)(reader, kFskMediaPlayerStateInstantiating); err = amrInstantiate(state); if (err) { if (kFskErrNeedMoreTime == err) err = kFskErrNone; goto bail; } bail: if ((kFskErrNone != err) && (NULL != state)) { amrReaderDispose(reader, state); state = NULL; } *readerState = state; return err; }
void KPR_Path2D(xsMachine *the) { FskCanvas2dPath path = NULL; FskErr err; bailIfError(FskCanvas2dPathNew(&path)); if (xsToInteger(xsArgc) > 0) { if (xsIsInstanceOf(xsArg(0), xsGet(xsGet(xsGlobal, xsID_KPR), xsID("path2D")))) { FskCanvas2dPath fromPath = xsGetHostData(xsArg(0)); BAIL_IF_NULL(fromPath, err, kFskErrNotFound); bailIfError(FskCanvas2dPathAppendPath(NULL, path, fromPath, NULL)); } else { xsStringValue str = xsToString(xsArg(0)); (void)FskCanvas2dPathAppendPathString(NULL, path, str); } } xsSetHostData(xsResult, path); bail: if (err) FskCanvas2dPathDispose(path); return; }
FskErr FskWidePolyLineToPolygon( UInt32 nPts, const FskFixedPoint2D *pts, FskFixed strokeWidth, FskFixed jointSharpness, UInt32 endCaps, const FskFixedMatrix3x2 *M, FskGrowableFixedPoint2DArray *polygonHandle ) { FskErr err; FskGrowableFixedPoint2DArray poly, back = NULL; SInt32 n; const FskFixedPoint2D *p0, *p1; FskFixedPoint2D pt; LineSeg seg0, seg1; MakeEndCap endCap; MakeJoin join; BAIL_IF_TRUE((jointSharpness < 0), err, kFskErrInvalidParameter); BAIL_IF_NULL(polygonHandle, err, kFskErrInvalidParameter); /* Select the join proc */ if (jointSharpness < FIXED_ONE) { /* Rounded */ join = RoundedJoin; n = nPts * 8; } else if (jointSharpness == FIXED_ONE) { /* Beveled */ join = BeveledJoin; n = nPts * 3; } else { /* Mitered */ join = MiteredJoin; n = nPts * 2; seg0.sinMiterLimit = seg1.sinMiterLimit = FskFixDiv(FRACT_ONE, jointSharpness); } /* Convert closed 2 point polylines into open ones with compatible endcaps */ if ((nPts == 2) && ((endCaps & kFskLineEndCapClosed) != 0)) { endCaps = (jointSharpness < FIXED_ONE) ? kFskLineEndCapRound : kFskLineEndCapButt; } /* Make sure a polygon is allocated */ if (*polygonHandle == NULL) { BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayNew(n, polygonHandle)); } else { BAIL_IF_ERR(err = FskGrowableFixedPoint2DArraySetItemCount(*polygonHandle, 0)); } poly = *polygonHandle; BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayNew(n, &back)); seg0.strokeWidth = seg1.strokeWidth = strokeWidth; /* Generate the polygon from the polyline description */ switch (endCaps) { case kFskLineEndCapRound: endCap = RoundEndCap; seg0.arcRelTol = seg1.arcRelTol = FskFracSqrt(FskFixedNDiv(LINEAR_TOLERANCE, strokeWidth, 31)); goto openLine; case kFskLineEndCapSquare: endCap = SquareEndCap; goto openLine; case kFskLineEndCapButt: endCap = ButtEndCap; openLine: p0 = pts; p1 = p0 + 1; for (n = nPts - 2; !InitLineSeg(p0, p1, M, &seg0) && (n > 0); p1++, n--) ; /* Get the first nondegenerate segment */ BAIL_IF_ERR(err = (*endCap)(&seg0, 0, poly)); seg1 = seg0; /* This should take care of the case with just 2 points */ for (p0 = p1++; n-- > 0; p0 = p1++) { if (InitLineSeg(p0, p1, M, &seg1)) { BAIL_IF_ERR(err = (*join)(&seg0, &seg1, poly, back)); seg0 = seg1; /* Only shift nondegenerate segments */ } } BAIL_IF_ERR(err = (*endCap)(&seg1, 1, poly)); break; case kFskLineEndCapClosed: // case kFskLineEndCapClosed|kFskLineEndCapRound: // round == 0 case kFskLineEndCapClosed|kFskLineEndCapSquare: case kFskLineEndCapClosed|kFskLineEndCapButt: p0 = pts + nPts - 2; p1 = p0 + 1; for (n = nPts; !InitLineSeg(p0, p1, M, &seg0) && (n > 0); p0--, n--) ; /* Nondegenerate segment coming in to the last point */ for (p0 = p1, p1 = pts; n-- > 0; p0 = p1++) { if (InitLineSeg(p0, p1, M, &seg1)) { BAIL_IF_ERR(err = (*join)(&seg0, &seg1, poly, back)); seg0 = seg1; /* Only shift nondegenerate segments */ } } BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayGetItem(poly, 0, &pt)); BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayAppendItem(poly, &pt)); BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayGetItem(back, 0, &pt)); BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayAppendItem(back, &pt)); break; } n = FskGrowableFixedPoint2DArrayGetItemCount(back); FskGrowableFixedPoint2DArrayGetConstPointerToItem(back, 0, (const void**)(const void*)(&p1)); BAIL_IF_ERR(err = FskGrowableFixedPoint2DArrayAppendReversedItems(poly, p1, n)); bail: if (back != NULL) FskGrowableFixedPoint2DArrayDispose(back); return err; }
jint JAVANAME(FskViewGL_setFskSurface)(JNIEnv* env, jobject viewObj, jobject surfaceObj) { FskWindow fWin = FskWindowGetActive(); FskErr err = kFskErrNone; FskErr retErr; FskThread drawThread; FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "[%p] FskViewGL_setFskSurface(%p, %p, %p)", (void*)pthread_self(), env, viewObj, surfaceObj); ANativeWindow *nw = theNativeWindow; theNativeWindow = ANativeWindow_fromSurface(env, surfaceObj); fbGlobals->surface = theNativeWindow; if (theNativeWindow && theNativeWindow == nw) { FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, " native window surface is same as before - don't setFskSurface twice\n"); return 0; } FskGLSetNativeWindow((void*)theNativeWindow); FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "FskViewGL_setFskSurface: active window is %p%s", fWin, fWin ? "" : ", bailing"); BAIL_IF_NULL(fWin, err, kFskErrBadState); drawThread = fWin->thread; FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "FskViewGL_setFskSurface: drawThread is %p %s", drawThread, drawThread ? "" : ", bailing"); BAIL_IF_NULL(drawThread, err, kFskErrBadState); FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "FskViewGL_setFskSurface calling InitGLCallback"); /* MDK - we need to wait for the callback to complete it's action in the other thread before we continue. I'm doing this by means of the jniRespCond. * However, at startup, we don't have the target thread to do it's work yet, so allow this through once at initialization. */ static int pass = 0; if (pass != 0) FskMutexAcquire(jniRespMutex); FskInstrumentedTypePrintfVerbose(&gAndroidMainBlockTypeInstrumentation, " about to post callback and wait for response from InitGLCallback\n"); err = FskThreadPostCallback(drawThread, InitGLCallback, theNativeWindow, NULL, NULL, NULL); if (pass++ != 0) { if (!gQuitting) { FskConditionWait(jniRespCond, jniRespMutex); FskMutexRelease(jniRespMutex); } } else usleep(500); FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, "FskViewGL_setFskSurface: FskThreadPostCallback(InitGLCallback) returns %d", err); gScreenWidth = fbGlobals->frameBuffer->bounds.width; gScreenHeight = fbGlobals->frameBuffer->bounds.height; if (fWin) { FskRectangleRecord b; FskPortGetBounds(fWin->port, &b); FskInstrumentedTypePrintfVerbose(&gAndroidWindowTypeInstrumentation, " - gl invalidating port bounds %d %d %d %d\n", b.x, b.y, b.width, b.height); FskPortInvalidateRectangle(fWin->port, &b); } bail: return !err; }