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;
}
