SV platform dependency builds

/*

 * Portable Audio I/O Library

 * Java Binding for PortAudio

 *

 * Based on the Open Source API proposed by Ross Bencina

 * Copyright (c) 2008 Ross Bencina

 *

 * Permission is hereby granted, free of charge, to any person obtaining

 * a copy of this software and associated documentation files

 * (the "Software"), to deal in the Software without restriction,

 * including without limitation the rights to use, copy, modify, merge,

 * publish, distribute, sublicense, and/or sell copies of the Software,

 * and to permit persons to whom the Software is furnished to do so,

 * subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be

 * included in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR

 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF

 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 */

/*

 * The text above constitutes the entire PortAudio license; however, 

 * the PortAudio community also makes the following non-binding requests:

 *

 * Any person wishing to distribute modifications to the Software is

 * requested to send the modifications to the original developer so that

 * they can be incorporated into the canonical version. It is also 

 * requested that these non-binding requests be included along with the 

 * license above.

 */

#include "com_portaudio_BlockingStream.h"

#include "portaudio.h"

#include "jpa_tools.h"

#ifndef FALSE

#define FALSE  (0)

#endif

#ifndef TRUE

#define TRUE  (!FALSE)

#endif

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    getReadAvailable

 * Signature: ()I

 */

JNIEXPORT jint JNICALL Java_com_portaudio_BlockingStream_getReadAvailable

  (JNIEnv *env, jobject blockingStream)

{

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( stream == NULL ) return 0;

        return Pa_GetStreamReadAvailable( stream );

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    getWriteAvailable

 * Signature: ()I

 */

JNIEXPORT jint JNICALL Java_com_portaudio_BlockingStream_getWriteAvailable

  (JNIEnv *env, jobject blockingStream)

{

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( stream == NULL ) return 0;

        return Pa_GetStreamWriteAvailable( stream );

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    writeFloats

 * Signature: ([FI)Z

 */

JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_writeFloats

  (JNIEnv *env, jobject blockingStream, jfloatArray buffer, jint numFrames)

{

        jfloat *carr;

        jint err;

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( buffer == NULL )

        {

                (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),

                  "null stream buffer");

                return FALSE;

        }

        carr = (*env)->GetFloatArrayElements(env, buffer, NULL);

        if (carr == NULL)

        {

                (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),

                  "invalid stream buffer");

                return FALSE;

        }

        err = Pa_WriteStream( stream, carr, numFrames );

        (*env)->ReleaseFloatArrayElements(env, buffer, carr, 0);

        if( err == paOutputUnderflowed )

        {

                return TRUE;

        }

        else

        {

                jpa_CheckError( env, err );

                return FALSE;

        }

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    readFloats

 * Signature: ([FI)Z

 */

JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_readFloats

  (JNIEnv *env, jobject blockingStream, jfloatArray buffer, jint numFrames)

{

        jfloat *carr;

        jint err;

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( buffer == NULL )

        {

                (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),

                  "null stream buffer");

                return FALSE;

        }

        carr = (*env)->GetFloatArrayElements(env, buffer, NULL);

        if (carr == NULL)

        {

                (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),

                  "invalid stream buffer");

                return FALSE;

        }

        err = Pa_ReadStream( stream, carr, numFrames );

        (*env)->ReleaseFloatArrayElements(env, buffer, carr, 0);

        if( err == paInputOverflowed )

        {

                return TRUE;

        }

        else

        {

                jpa_CheckError( env, err );

                return FALSE;

        }

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    writeShorts

 * Signature: ([SI)Z

 */

JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_writeShorts

  (JNIEnv *env, jobject blockingStream, jfloatArray buffer, jint numFrames)

{

        jshort *carr;

        jint err;

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( buffer == NULL )

        {

                (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),

                  "null stream buffer");

                return FALSE;

        }

        carr = (*env)->GetShortArrayElements(env, buffer, NULL);

        if (carr == NULL)

        {

                (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),

                  "invalid stream buffer");

                return FALSE;

        }

        err = Pa_WriteStream( stream, carr, numFrames );

        (*env)->ReleaseShortArrayElements(env, buffer, carr, 0);

        if( err == paOutputUnderflowed )

        {

                return TRUE;

        }

        else

        {

                jpa_CheckError( env, err );

                return FALSE;

        }

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    readShorts

 * Signature: ([SI)Z

 */

JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_readShorts

  (JNIEnv *env, jobject blockingStream, jfloatArray buffer, jint numFrames)

{

        jshort *carr;

        jint err;

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( buffer == NULL )

        {

                (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),

                  "null stream buffer");

                return FALSE;

        }

        carr = (*env)->GetShortArrayElements(env, buffer, NULL);

        if (carr == NULL)

        {

                (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),

                  "invalid stream buffer");

                return FALSE;

        }

        err = Pa_ReadStream( stream, carr, numFrames );

        (*env)->ReleaseShortArrayElements(env, buffer, carr, 0);

        if( err == paInputOverflowed )

        {

                return TRUE;

        }

        else

        {

                jpa_CheckError( env, err );

                return FALSE;

        }

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    start

 * Signature: ()V

 */

JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_start

  (JNIEnv *env, jobject blockingStream )

{

        PaStream *stream = jpa_GetStreamPointer( env, blockingStream );

        int err = Pa_StartStream( stream );

        jpa_CheckError( env, err );

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    stop

 * Signature: ()V

 */

JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_stop

  (JNIEnv *env, jobject blockingStream )

{

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        int err = Pa_StopStream( stream );

        jpa_CheckError( env, err );

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    abort

 * Signature: ()V

 */

JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_abort

  (JNIEnv *env, jobject blockingStream )

{

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        int err = Pa_AbortStream( stream );

        jpa_CheckError( env, err );

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    close

 * Signature: ()V

 */

JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_close

  (JNIEnv *env, jobject blockingStream )

{

        jclass cls;

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( stream != NULL )

        {

                int err = Pa_CloseStream( stream );

                jpa_CheckError( env, err );

                cls = (*env)->GetObjectClass(env, blockingStream);

                jpa_SetLongField( env, cls, blockingStream, "nativeStream", (jlong) 0 );

        }

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    isStopped

 * Signature: ()V

 */

JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_isStopped

  (JNIEnv *env, jobject blockingStream )

{

        int err;

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( stream == NULL ) return 1;

        err = Pa_IsStreamStopped( stream );

        return (jpa_CheckError( env, err ) > 0);

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    isActive

 * Signature: ()V

 */

JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_isActive

  (JNIEnv *env, jobject blockingStream )

{

        int err;

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( stream == NULL ) return 0;

        err = Pa_IsStreamActive( stream );

        return (jpa_CheckError( env, err ) > 0);

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    getTime

 * Signature: ()D

 */

JNIEXPORT jdouble JNICALL Java_com_portaudio_BlockingStream_getTime

  (JNIEnv *env, jobject blockingStream )

{

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        if( stream == NULL ) return 0.0;

        return Pa_GetStreamTime( stream );

}

/*

 * Class:     com_portaudio_BlockingStream

 * Method:    getInfo

 * Signature: ()Lcom/portaudio/StreamInfo;

 */

JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_getInfo

  (JNIEnv *env, jobject blockingStream, jobject streamInfo)

{

        PaStream *stream =jpa_GetStreamPointer( env, blockingStream );

        const PaStreamInfo *info = Pa_GetStreamInfo( stream );

        if( streamInfo == NULL )

        {

                jpa_ThrowError( env, "Invalid stream." );

        }

        else

        {

                /* Get a reference to obj's class */

                jclass cls = (*env)->GetObjectClass(env, streamInfo);

                jpa_SetIntField( env, cls, streamInfo, "structVersion", info->structVersion );

                jpa_SetDoubleField( env, cls, streamInfo, "inputLatency", info->inputLatency );

                jpa_SetDoubleField( env, cls, streamInfo, "outputLatency", info->outputLatency );

                jpa_SetDoubleField( env, cls, streamInfo, "sampleRate", info->sampleRate );

        }

}