primitiveCreateRenderer(void)
{
// B3DAcceleratorPlugin>>#primitiveCreateRenderer
sqInt allowHardware;
sqInt allowSoftware;
sqInt h;
sqInt result;
sqInt w;
sqInt x;
sqInt y;
if (!((methodArgumentCount()) == 6)) {
return primitiveFail();
}
h = stackIntegerValue(0);
w = stackIntegerValue(1);
y = stackIntegerValue(2);
x = stackIntegerValue(3);
allowHardware = booleanValueOf(stackValue(4));
allowSoftware = booleanValueOf(stackValue(5));
if (failed()) {
return null;
}
result = b3dxCreateRenderer(allowSoftware, allowHardware, x, y, w, h);
if (result < 0) {
return primitiveFail();
}
pop(7);
return pushInteger(result);
}
primitiveCompositeTexture(void)
{
// B3DAcceleratorPlugin>>#primitiveCompositeTexture
sqInt h;
sqInt rendererHandle;
sqInt result;
sqInt texHandle;
sqInt translucent;
sqInt w;
sqInt x;
sqInt y;
if (!((methodArgumentCount()) == 7)) {
return primitiveFail();
}
translucent = booleanValueOf(stackValue(0));
h = stackIntegerValue(1);
w = stackIntegerValue(2);
y = stackIntegerValue(3);
x = stackIntegerValue(4);
texHandle = stackIntegerValue(5);
rendererHandle = stackIntegerValue(6);
if (failed()) {
return null;
}
result = b3dxCompositeTexture(rendererHandle, texHandle, x, y, w, h, translucent);
if (!result) {
return primitiveFail();
}
return pop(7);
}
primitiveEnableDrawRangeChecks(void)
{
// B3DAcceleratorPlugin>>#primitiveEnableDrawRangeChecks
sqInt enabled;
if ((methodArgumentCount()) == 0) {
pop(1);
return pushBool(doRangeChecks);
}
if ((methodArgumentCount()) == 1) {
enabled = booleanValueOf(stackValue(0));
if (failed()) {
return null;
}
doRangeChecks = enabled;
return pop(1);
}
}
primitiveSoundStartRecording(void)
{
// SoundPlugin>>#primitiveSoundStartRecording
sqInt desiredSamplesPerSec;
sqInt semaIndex;
sqInt stereoFlag;
desiredSamplesPerSec = stackIntegerValue(2);
stereoFlag = booleanValueOf(stackValue(1));
semaIndex = stackIntegerValue(0);
if (failed()) {
return null;
}
snd_StartRecording(desiredSamplesPerSec, stereoFlag, semaIndex);
if (failed()) {
return null;
}
pop(3);
return null;
}
primitiveSoundStart(void)
{
// SoundPlugin>>#primitiveSoundStart
sqInt bufFrames;
sqInt samplesPerSec;
sqInt stereoFlag;
bufFrames = stackIntegerValue(2);
samplesPerSec = stackIntegerValue(1);
stereoFlag = booleanValueOf(stackValue(0));
if (failed()) {
return null;
}
success(snd_Start(bufFrames, samplesPerSec, stereoFlag, 0));
if (failed()) {
return null;
}
pop(3);
return null;
}
primitiveAsyncFileOpen(void)
{
// AsynchFilePlugin>>#primitiveAsyncFileOpen
AsyncFile *f;
char *fileName;
sqInt fileNameSize;
sqInt fOop;
sqInt okToOpen;
sqInt semaIndex;
sqInt writeFlag;
success(isBytes(stackValue(2)));
fileName = ((char *) (firstIndexableField(stackValue(2))));
writeFlag = booleanValueOf(stackValue(1));
semaIndex = stackIntegerValue(0);
if (failed()) {
return null;
}
/* If the security plugin can be loaded, use it to check for permission.
If not, assume it's ok */
fileNameSize = slotSizeOf(((int) fileName) - 4);
if (sCOAFfn != 0) {
okToOpen = ((sqInt (*) (char *, sqInt, sqInt)) sCOAFfn)(fileName, fileNameSize, writeFlag);
if (!okToOpen) {
primitiveFail();
return null;
}
}
fOop = instantiateClassindexableSize(classByteArray(), sizeof(AsyncFile));
f = asyncFileValueOf(fOop);
if (!(failed())) {
asyncFileOpen(f, (int)fileName, fileNameSize, writeFlag, semaIndex);
}
if (failed()) {
return null;
}
popthenPush(4, fOop);
return null;
}
primitiveFileOpen(void)
{
// FilePlugin>>#primitiveFileOpen
sqInt filePointer;
char *nameIndex;
sqInt namePointer;
sqInt nameSize;
sqInt writeFlag;
writeFlag = booleanValueOf(stackValue(0));
namePointer = stackValue(1);
if (!(isBytes(namePointer))) {
return primitiveFail();
}
nameIndex = firstIndexableField(namePointer);
nameSize = byteSizeOf(namePointer);
filePointer = fileOpenNamesizewritesecure(nameIndex, nameSize, writeFlag, 1);
if (!(failed())) {
popthenPush(3, filePointer);
}
}
primitiveSoundStartWithSemaphore(void)
{
// SoundPlugin>>#primitiveSoundStartWithSemaphore
sqInt bufFrames;
sqInt samplesPerSec;
sqInt semaIndex;
sqInt stereoFlag;
bufFrames = stackIntegerValue(3);
samplesPerSec = stackIntegerValue(2);
stereoFlag = booleanValueOf(stackValue(1));
semaIndex = stackIntegerValue(0);
if (failed()) {
return null;
}
success(snd_Start(bufFrames, samplesPerSec, stereoFlag, semaIndex));
if (failed()) {
return null;
}
pop(4);
return null;
}
primitiveFFTTransformData(void)
{
sqInt fftScale;
sqInt fftSize2;
sqInt fftSize4;
sqInt forward;
sqInt i;
sqInt ii;
float imagT;
float imagU;
sqInt ip;
sqInt j;
int lev;
int lev1;
sqInt level;
sqInt rcvr;
float realT;
float realU;
sqInt theta;
forward = booleanValueOf(stackValue(0));
rcvr = stackObjectValue(1);
if (!(loadFFTFrom(rcvr))) {
return null;
}
/* begin transformData: */
permuteData();
if (failed()) {
/* permuteData went wrong. Do the permutation again -- this will restore the original order */
permuteData();
goto l1;
}
/* begin transformForward: */
fftSize2 = fftSize / 2;
fftSize4 = fftSize / 4;
for (level = 1; level <= nu; level += 1) {
lev = 1L << level;
lev1 = lev / 2;
fftScale = fftSize / lev;
for (j = 1; j <= lev1; j += 1) {
/* pi * (j-1) / lev1 mapped onto 0..n/2 */
theta = (j - 1) * fftScale;
if (theta < fftSize4) {
/* Compute U, the complex multiplier for each level */
realU = sinTable[(sinTableSize - theta) - 1];
imagU = sinTable[theta];
}
else {
realU = 0.0 - (sinTable[theta - fftSize4]);
imagU = sinTable[fftSize2 - theta];
}
if (!forward) {
imagU = 0.0 - imagU;
}
i = j;
while (i <= fftSize) {
ip = (i + lev1) - 1;
ii = i - 1;
realT = ((realData[ip]) * realU) - ((imagData[ip]) * imagU);
imagT = ((realData[ip]) * imagU) + ((imagData[ip]) * realU);
realData[ip] = ((realData[ii]) - realT);
imagData[ip] = ((imagData[ii]) - imagT);
realData[ii] = ((realData[ii]) + realT);
imagData[ii] = ((imagData[ii]) + imagT);
i += lev;
}
}
}
if (!forward) {
scaleData();
}
l1: /* end transformData: */;
if (!(failed())) {
pop(1);
}
return 0;
}
static jobject OSNetworkSystem_getSocketOption(JNIEnv* env, jobject, jobject fileDescriptor, jint option) {
NetFd fd(env, fileDescriptor);
if (fd.isClosed()) {
return NULL;
}
int family = getSocketAddressFamily(fd.get());
if (family != AF_INET && family != AF_INET6) {
jniThrowSocketException(env, EAFNOSUPPORT);
return NULL;
}
switch (option) {
case JAVASOCKOPT_TCP_NODELAY:
return getSocketOption_Boolean(env, fd, IPPROTO_TCP, TCP_NODELAY);
case JAVASOCKOPT_SO_SNDBUF:
return getSocketOption_Integer(env, fd, SOL_SOCKET, SO_SNDBUF);
case JAVASOCKOPT_SO_RCVBUF:
return getSocketOption_Integer(env, fd, SOL_SOCKET, SO_RCVBUF);
case JAVASOCKOPT_SO_BROADCAST:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_BROADCAST);
case JAVASOCKOPT_SO_REUSEADDR:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_REUSEADDR);
case JAVASOCKOPT_SO_KEEPALIVE:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_KEEPALIVE);
case JAVASOCKOPT_SO_OOBINLINE:
return getSocketOption_Boolean(env, fd, SOL_SOCKET, SO_OOBINLINE);
case JAVASOCKOPT_IP_TOS:
if (family == AF_INET) {
return getSocketOption_Integer(env, fd, IPPROTO_IP, IP_TOS);
} else {
return getSocketOption_Integer(env, fd, IPPROTO_IPV6, IPV6_TCLASS);
}
case JAVASOCKOPT_SO_LINGER:
{
linger lingr;
bool ok = getSocketOption(env, fd, SOL_SOCKET, SO_LINGER, &lingr);
if (!ok) {
return NULL; // We already threw.
} else if (!lingr.l_onoff) {
return booleanValueOf(env, false);
} else {
return integerValueOf(env, lingr.l_linger);
}
}
case JAVASOCKOPT_SO_TIMEOUT:
{
timeval timeout;
bool ok = getSocketOption(env, fd, SOL_SOCKET, SO_RCVTIMEO, &timeout);
return ok ? integerValueOf(env, toMs(timeout)) : NULL;
}
#ifdef ENABLE_MULTICAST
case JAVASOCKOPT_IP_MULTICAST_IF:
{
// Although setsockopt(2) can take an ip_mreqn for IP_MULTICAST_IF, getsockopt(2)
// always returns an in_addr.
sockaddr_storage ss;
memset(&ss, 0, sizeof(ss));
ss.ss_family = AF_INET; // This call is IPv4-only.
sockaddr_in* sa = reinterpret_cast<sockaddr_in*>(&ss);
if (!getSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_IF, &sa->sin_addr)) {
return NULL;
}
return socketAddressToInetAddress(env, &ss);
}
case JAVASOCKOPT_IP_MULTICAST_IF2:
if (family == AF_INET) {
// The caller's asking for an interface index, but that's not how IPv4 works.
// Our Java should never get here, because we'll try IP_MULTICAST_IF first and
// that will satisfy us.
jniThrowSocketException(env, EAFNOSUPPORT);
} else {
return getSocketOption_Integer(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_IF);
}
case JAVASOCKOPT_IP_MULTICAST_LOOP:
if (family == AF_INET) {
// Although IPv6 was cleaned up to use int, IPv4 multicast loopback uses a byte.
u_char loopback;
bool ok = getSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_LOOP, &loopback);
return ok ? booleanValueOf(env, loopback) : NULL;
} else {
return getSocketOption_Boolean(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_LOOP);
}
case JAVASOCKOPT_MULTICAST_TTL:
if (family == AF_INET) {
// Although IPv6 was cleaned up to use int, and IPv4 non-multicast TTL uses int,
// IPv4 multicast TTL uses a byte.
u_char ttl;
bool ok = getSocketOption(env, fd, IPPROTO_IP, IP_MULTICAST_TTL, &ttl);
return ok ? integerValueOf(env, ttl) : NULL;
} else {
return getSocketOption_Integer(env, fd, IPPROTO_IPV6, IPV6_MULTICAST_HOPS);
}
#else
case JAVASOCKOPT_MULTICAST_TTL:
case JAVASOCKOPT_IP_MULTICAST_IF:
case JAVASOCKOPT_IP_MULTICAST_IF2:
case JAVASOCKOPT_IP_MULTICAST_LOOP:
jniThrowException(env, "java/lang/UnsupportedOperationException", NULL);
return NULL;
#endif // def ENABLE_MULTICAST
default:
jniThrowSocketException(env, ENOPROTOOPT);
return NULL;
}
}
static jobject getSocketOption_Boolean(JNIEnv* env, const NetFd& fd, int level, int option) {
int value;
return getSocketOption(env, fd, level, option, &value) ? booleanValueOf(env, value) : NULL;
}
