JNIEXPORT jdouble JNICALL PRIMLIB_UnwrapDouble(JNIEnv * env, jobject obj) {
if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_DOUBLE))) {
return PRIMLIB_GetDoubleObjectValue(env, obj);
} else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_FLOAT))) {
return (jdouble)PRIMLIB_GetFloatObjectValue(env, obj);
} else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_LONG))) {
return (jdouble)PRIMLIB_GetLongObjectValue(env, obj);
} else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_INT))) {
return (jdouble)PRIMLIB_GetIntObjectValue(env, obj);
} else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_SHORT))) {
return (jdouble)PRIMLIB_GetShortObjectValue(env, obj);
} else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_CHAR))) {
return (jdouble)PRIMLIB_GetCharObjectValue(env, obj);
} else if((*env)->IsInstanceOf(env, obj, PRIMLIB_GetNativeWrapClass(env, PRIMLIB_BYTE))) {
return (jdouble)PRIMLIB_GetByteObjectValue(env, obj);
} else {
JCL_ThrowException(env, "java/lang/IllegalArgumentException", "Argument not of correct type.");
return 0;
}
}
jlong
_javaio_get_file_length (JNIEnv * env, jint fd)
{
#ifndef WITHOUT_FILESYSTEM
jlong length;
int result;
TARGET_NATIVE_FILE_SIZE (fd, length, result);
if (result != TARGET_NATIVE_OK)
{
JCL_ThrowException (env,
"java/io/IOException",
TARGET_NATIVE_LAST_ERROR_STRING ());
return (TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1);
}
return (length);
#else /* not WITHOUT_FILESYSTEM */
return (TARGET_NATIVE_MATH_INT_INT64_CONST_0);
#endif /* not WITHOUT_FILESYSTEM */
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GdkScreenGraphicsDevice_nativeSetDisplayMode
(JNIEnv *env, jobject obj __attribute__((unused)), jobject gdkGraphicsEnv __attribute__((unused)), jint index __attribute__((unused)), jshort rate __attribute__((unused)))
{
#ifdef HAVE_XRANDR
GdkDisplay *display;
XRRScreenConfiguration *config;
Rotation rotation;
display = (GdkDisplay *) NSA_GET_DISPLAY_PTR(env, gdkGraphicsEnv);
gdk_threads_enter();
config = XRRGetScreenInfo (GDK_DISPLAY_XDISPLAY(display), GDK_ROOT_WINDOW());
/* The rotation is not exposed to the Java API. So we retrieve its current
* value and set it to the same when switching resolution.
*/
XRRConfigCurrentConfiguration (config, &rotation);
XRRSetScreenConfigAndRate (GDK_DISPLAY_XDISPLAY(display),
config,
GDK_ROOT_WINDOW(),
index,
rotation,
rate,
CurrentTime);
XRRFreeScreenConfigInfo(config);
gdk_threads_leave();
#else
JCL_ThrowException(env,
"java/lang/InternalError",
"Method should not have been invoked.");
#endif
}
JNIEXPORT jobjectArray JNICALL
Java_gnu_java_awt_peer_gtk_GdkScreenGraphicsDevice_nativeGetDisplayModes
(JNIEnv *env, jobject obj __attribute__((unused)), jobject gdkGraphicsEnv __attribute__((unused)))
{
#ifdef HAVE_XRANDR
GdkDisplay *display;
XRRScreenConfiguration *config;
XRRScreenSize *screenSizes;
int nsizes = 0, nrates = 0, i = 0;
jclass x11DisplayMode_class;
jmethodID x11DisplayMode_ctor;
jobjectArray array;
jobject instance;
short *rates;
jshortArray shortArray;
display = (GdkDisplay *) NSA_GET_DISPLAY_PTR(env, gdkGraphicsEnv);
gdk_threads_enter();
config = XRRGetScreenInfo (GDK_DISPLAY_XDISPLAY(display), GDK_ROOT_WINDOW());
screenSizes = XRRConfigSizes(config, &nsizes);
x11DisplayMode_class = (*env)->FindClass(env, "gnu/java/awt/peer/gtk/GdkScreenGraphicsDevice$X11DisplayMode");
x11DisplayMode_ctor = (*env)->GetMethodID(env, x11DisplayMode_class, "<init>", "(II[S)V");
array = (*env)->NewObjectArray(env, nsizes, x11DisplayMode_class, NULL);
for (; i < nsizes ; i++)
{
/* Retrieves refresh rate information. */
rates = XRRConfigRates(config, i, &nrates);
/* Create a Java short array and put them in. */
shortArray = (*env)->NewShortArray(env, nrates);
(*env)->SetShortArrayRegion(env, shortArray, 0, nrates, (jshort *) rates);
/* Create a GdkScreenGraphicsDevice.X11DisplayMode instance. */
instance = (*env)->NewObject(env,
x11DisplayMode_class,
x11DisplayMode_ctor,
screenSizes[i].width,
screenSizes[i].height,
shortArray);
/* Put it into the result array. */
(*env)->SetObjectArrayElement(env, array, i, instance);
}
/* Free everything acquired by xlib. */
XRRFreeScreenConfigInfo (config);
gdk_threads_leave();
return array;
#else
JCL_ThrowException(env,
"java/lang/InternalError",
"Method should not have been invoked.");
return NULL;
#endif
}
JNIEXPORT void JNICALL
Java_gnu_javax_sound_sampled_gstreamer_lines_GstPipeline_init_1instance
(JNIEnv *env, jobject pipeline)
{
GstNativePipeline *_pipeline = NULL;
jclass localGstPipelineClass = NULL;
jclass localPointerClass = NULL;
jobject _pointer = NULL;
_pipeline =
(GstNativePipeline *) JCL_malloc (env, sizeof (GstNativePipeline));
if (_pipeline == NULL)
return;
_pipeline->priv = (GstNativePipelinePrivate *)
JCL_malloc (env, sizeof (GstNativePipelinePrivate));
if (_pipeline->priv == NULL)
{
JCL_free (env, _pipeline);
return;
}
#if SIZEOF_VOID_P == 8
localPointerClass = JCL_FindClass (env, "gnu/classpath/Pointer64");
#else
# if SIZEOF_VOID_P == 4
localPointerClass = JCL_FindClass (env, "gnu/classpath/Pointer32");
# else
# error "Pointer size is not supported."
# endif /* SIZEOF_VOID_P == 4 */
#endif /* SIZEOF_VOID_P == 8 */
localGstPipelineClass = (*env)->GetObjectClass(env, pipeline);
if (localGstPipelineClass == NULL || localGstPipelineClass == NULL)
{
JCL_free (env, _pipeline->priv);
JCL_free (env, _pipeline);
JCL_ThrowException (env, "java/lang/InternalError",
"Class Initialization failed.");
return;
}
GST_DETECTED_PIPE_CAPACITY = (long) (*env)->GetLongField(env, pipeline,
capacityFID);
/* fill the object */
(*env)->GetJavaVM(env, &_pipeline->priv->vm);
_pipeline->priv->jni_pipeline = (*env)->NewGlobalRef(env, pipeline);
_pipeline->priv->GstPipelineClass =
(*env)->NewGlobalRef(env, localGstPipelineClass);
_pipeline->priv->PointerClass = (*env)->NewGlobalRef(env, localPointerClass);
_pipeline->priv->pipeline = NULL;
_pointer = (*env)->GetObjectField(env, pipeline, pipelineFID);
if (_pointer == NULL)
{
#if SIZEOF_VOID_P == 8
_pointer = (*env)->NewObject(env, _pipeline->priv->PointerClass,
pointerConstructorMID, (jlong) _pipeline);
#else
_pointer = (*env)->NewObject(env, _pipeline->priv->PointerClass,
pointerConstructorMID, (jint) _pipeline);
#endif
}
else
{
#if SIZEOF_VOID_P == 8
(*env)->SetLongField(env, pipeline, pipelineFID, (jlong) _pipeline);
#else
(*env)->SetIntField(env, pipeline, pipelineFID, (jint) _pipeline);
#endif
}
/* store back our pointer into the calling class */
(*env)->SetObjectField(env, pipeline, pipelineFID, _pointer);
}
/*
* Returns all local network interfaces as an array.
*/
JNIEXPORT jobjectArray JNICALL
Java_java_net_VMNetworkInterface_getVMInterfaces (JNIEnv * env,
jclass clazz UNUSED)
{
#if defined (HAVE_IFADDRS_H) && defined (HAVE_GETIFADDRS)
struct ifaddrs *ifaddrs, *i;
struct netif_entry *iflist = NULL, *e;
jobjectArray netifs;
int numifs = 0;
int k;
if (getifaddrs (&ifaddrs) == -1)
{
JCL_ThrowException (env, "java/net/SocketException", strerror (errno));
return NULL;
}
for (i = ifaddrs; i != NULL; i = i->ifa_next)
{
if (iflist == NULL)
{
iflist = JCL_malloc (env, sizeof (struct netif_entry));
if (iflist == NULL)
{
freeifaddrs (ifaddrs);
return NULL;
}
iflist->name = i->ifa_name;
iflist->numaddrs = 0;
iflist->next = NULL;
iflist->netif = (*env)->NewObject (env, clazz, java_net_VMNetworkInterface_init,
(*env)->NewStringUTF (env, i->ifa_name));
if (iflist->netif == NULL)
{
freeifaddrs (ifaddrs);
JCL_free (env, iflist);
return NULL;
}
e = iflist;
}
else
{
struct netif_entry *p = NULL;
for (e = iflist; e != NULL; e = e->next)
{
if (strcmp (e->name, i->ifa_name) == 0)
break;
p = e;
}
if (e == NULL)
{
p->next = (struct netif_entry *) JCL_malloc (env, sizeof (struct netif_entry));
if (p->next == NULL)
{
free_netif_list (env, iflist);
freeifaddrs (ifaddrs);
return NULL;
}
e = p->next;
e->name = i->ifa_name;
e->numaddrs = 0;
e->next = NULL;
e->netif = (*env)->NewObject (env, clazz, java_net_VMNetworkInterface_init,
(*env)->NewStringUTF (env, i->ifa_name));
if (e->netif == NULL)
{
free_netif_list (env, iflist);
freeifaddrs (ifaddrs);
return NULL;
}
}
}
if (i->ifa_addr == NULL)
continue;
if (i->ifa_addr->sa_family == AF_INET)
{
struct sockaddr_in *sin = (struct sockaddr_in *) i->ifa_addr;
jobject buffer = (*env)->NewDirectByteBuffer (env, &(sin->sin_addr.s_addr), 4);
(*env)->CallVoidMethod (env, e->netif, java_net_VMNetworkInterface_addAddress,
buffer);
if ((*env)->ExceptionCheck (env))
{
free_netif_list (env, iflist);
freeifaddrs (ifaddrs);
return NULL;
}
(*env)->DeleteLocalRef (env, buffer);
e->numaddrs++;
}
#ifdef HAVE_INET6
else if (i->ifa_addr->sa_family == AF_INET6)
{
struct sockaddr_in6 *sin = (struct sockaddr_in6 *) i->ifa_addr;
jobject buffer = (*env)->NewDirectByteBuffer (env, &(sin->sin6_addr.s6_addr), 16);
(*env)->CallVoidMethod (env, e->netif, java_net_VMNetworkInterface_addAddress,
buffer);
if ((*env)->ExceptionCheck (env))
{
free_netif_list (env, iflist);
freeifaddrs (ifaddrs);
return NULL;
}
(*env)->DeleteLocalRef (env, buffer);
e->numaddrs++;
}
#endif /* HAVE_INET6 */
}
/* Count how many interfaces we have that have addresses. */
for (e = iflist; e != NULL; e = e->next)
{
if (e->numaddrs != 0)
numifs++;
}
netifs = (*env)->NewObjectArray (env, numifs, clazz, NULL);
k = 0;
for (e = iflist; e != NULL && k < numifs; e = e->next)
{
if (e->numaddrs != 0)
{
(*env)->SetObjectArrayElement (env, netifs, k, e->netif);
(*env)->DeleteLocalRef (env, e->netif);
k++;
}
}
free_netif_list (env, iflist);
freeifaddrs (ifaddrs);
return netifs;
#else
JCL_ThrowException (env, "java/net/SocketException", "getifaddrs not supported");
return NULL;
#endif /* HAVE_IFADDRS_H && HAVE_GETIFADDRS */
}
/*
* Implementation of a gathering write. Will use the appropriate
* vector based read call (currently readv on Linux).
*
* This has a limit to the number of buffers that will be read. It
* will not make muliple readv calls. This is to ensure that operations
* are atomic. Currently it is limited to 16 buffers. This is for
* compatibiliy with Sun.
*/
JNIEXPORT jlong JNICALL
Java_gnu_java_nio_VMChannel_writeGathering (JNIEnv *env,
jobject o __attribute__ ((__unused__)),
jint fd,
jobjectArray bbufs,
jint offset,
jint length)
{
int i;
/* jboolean is_error = JNI_FALSE; */
/* char *error_msg; */
struct iovec buffers[JCL_IOV_MAX];
struct JCL_buffer bi_list[JCL_IOV_MAX];
ssize_t result;
jint vec_len = length < JCL_IOV_MAX ? length : JCL_IOV_MAX;
jlong bytes_written;
/* Build the vector of buffers to read into */
for (i = 0; i < vec_len; i++)
{
struct JCL_buffer* buf;
jobject bbuf;
buf = &bi_list[i];
bbuf = (*env)->GetObjectArrayElement(env, bbufs, offset + i);
JCL_init_buffer(env, buf, bbuf);
buffers[i].iov_base = &(buf->ptr[buf->position + buf->offset]);
buffers[i].iov_len = buf->limit - buf->position;
(*env)->DeleteLocalRef(env, bbuf);
}
/* Work the gathering magic */
result = writev(fd, buffers, vec_len);
bytes_written = (jlong) result;
if (result < 0)
{
bytes_written = 0;
if (errno == EAGAIN) /* Non blocking */
result = 0;
else if (errno == EBADF) /* Bad fd */
{
JCL_cleanup_buffers(env, bi_list, vec_len, bbufs, offset,
bytes_written);
JCL_ThrowException (env, NON_WRITABLE_CHANNEL_EXCEPTION,
strerror(errno));
return -1;
}
else
{
JCL_cleanup_buffers(env, bi_list, vec_len, bbufs, offset,
bytes_written);
JCL_ThrowException (env, IO_EXCEPTION, strerror(errno));
return -1;
}
}
else if (result == 0) /* EOF?? Does this happen on a write */
result = -1;
JCL_cleanup_buffers(env, bi_list, vec_len, bbufs, offset, bytes_written);
return (jlong) result;
}
static void
throw_exception_by_name (JNIEnv *env, const char *name, const char *msg)
{
JCL_ThrowException (env, name, msg);
}
JNIEXPORT jint JNICALL
Java_gnu_java_nio_VMSelector_select (JNIEnv * env,
jclass obj __attribute__ ((__unused__)),
jintArray read,
jintArray write,
jintArray except, jlong timeout)
{
jint result;
jclass thread_class = (*env)->FindClass (env, "java/lang/Thread");
jmethodID thread_current_thread =
(*env)->GetStaticMethodID (env, thread_class, "currentThread",
"()Ljava/lang/Thread;");
jmethodID thread_interrupt =
(*env)->GetMethodID (env, thread_class, "interrupt", "()V");
jmethodID thread_interrupted =
(*env)->GetStaticMethodID (env, thread_class, "interrupted", "()Z");
jobject current_thread;
int max_fd = 0;
fd_set read_fds;
fd_set write_fds;
fd_set except_fds;
struct timeval real_time_data;
struct timeval *time_data = NULL;
char *message;
/* If a legal timeout value isn't given, use NULL.
* This means an infinite timeout. The specification
* also says that a zero timeout should be treated
* as infinite. Otherwise (if the timeout value is legal),
* fill our timeval struct and use it for the select.
*/
if (timeout > 0)
{
real_time_data.tv_sec = timeout / 1000;
real_time_data.tv_usec = (timeout % 1000) * 1000;
time_data = &real_time_data;
}
/* Reset all fd_set structures */
FD_ZERO (&read_fds);
FD_ZERO (&write_fds);
FD_ZERO (&except_fds);
/* Fill the fd_set data structures for the _Jv_select() call. */
helper_put_filedescriptors (env, read, &read_fds, &max_fd);
helper_put_filedescriptors (env, write, &write_fds, &max_fd);
helper_put_filedescriptors (env, except, &except_fds, &max_fd);
/* Actually do the select */
result =
helper_select (env, thread_class, thread_interrupted, max_fd + 1,
&read_fds, &write_fds, &except_fds, time_data);
if (result == -EINTR)
{
/* The behavior of JRE 1.4.1 is that no exception is thrown
* when the thread is interrupted, but the thread's interrupt
* status is set. Clear all of our select sets and return 0,
* indicating that nothing was selected.
*/
current_thread =
(*env)->CallStaticObjectMethod (env, thread_class,
thread_current_thread);
(*env)->CallVoidMethod (env, current_thread, thread_interrupt);
helper_reset (env, read);
helper_reset (env, write);
helper_reset (env, except);
return 0;
}
if (result < 0)
{
#if defined(HAVE_STRERROR_R)
char message_buf[BUF_SIZE+1];
int errorcode = -result;
if (strerror_r (errorcode, message_buf, BUF_SIZE))
{
/* This would mean that message_buf was to small
* to hold the error message.
*/
JCL_ThrowException (env, "java/lang/InternalError",
"Not enough space in message buffer.");
return 0;
}
message = message_buf;
#else
message = strerror(errno);
#endif
JCL_ThrowException (env, "java/io/IOException", message);
return 0;
}
/* Set the file descriptors according to the values returned from select(). */
helper_get_filedescriptors (env, read, &read_fds);
helper_get_filedescriptors (env, write, &write_fds);
helper_get_filedescriptors (env, except, &except_fds);
return result;
}
jint
_javaio_write (JNIEnv * env, jint fd, jarray buf, jint offset, jint len)
{
#ifndef WITHOUT_FILESYSTEM
jbyte *bufptr;
int bytes_written;
int result;
if (len == 0)
return 0; /* Nothing todo, and GetByteArrayElements() seems undefined. */
bufptr = (*env)->GetByteArrayElements (env, buf, 0);
if (bufptr == NULL)
{
JCL_ThrowException (env, "java/io/IOException",
"Internal Error: get byte array");
return (-1);
}
TARGET_NATIVE_FILE_WRITE (fd, (bufptr + offset), len, bytes_written,
result);
(*env)->ReleaseByteArrayElements (env, buf, bufptr, 0);
if (result != TARGET_NATIVE_OK)
JCL_ThrowException (env,
"java/io/IOException",
TARGET_NATIVE_LAST_ERROR_STRING ());
if (bytes_written == 0)
return (-1);
return (bytes_written);
#else /* not WITHOUT_FILESYSTEM */
jbyte *bufptr;
int bytesWritten;
if ((fd == 0) || (fd == 1) || (fd == 2))
{
if (len == 0)
return 0; /* Nothing todo, and GetByteArrayElements() seems undefined. */
bufptr = (*env)->GetByteArrayElements (env, buf, 0);
if (bufptr == NULL)
{
JCL_ThrowException (env, "java/io/IOException", "Internal Error");
return (-1);
}
TARGET_NATIVE_FILE_WRITE (fd, (bufptr + offset), len, bytes_written,
result);
(*env)->ReleaseByteArrayElements (env, buf, bufptr, 0);
if (bytes_written == -1)
JCL_ThrowException (env,
"java/io/IOException",
TARGET_NATIVE_LAST_ERROR_STRING ());
if (bytes_written == 0)
return (-1);
return (bytes_written);
}
else
{
return (-1);
}
#endif /* not WITHOUT_FILESYSTEM */
}
