PortAudio 2.0
com_portaudio_BlockingStream.c
1/*
2 * Portable Audio I/O Library
3 * Java Binding for PortAudio
4 *
5 * Based on the Open Source API proposed by Ross Bencina
6 * Copyright (c) 2008 Ross Bencina
7 *
8 * Permission is hereby granted, free of charge, to any person obtaining
9 * a copy of this software and associated documentation files
10 * (the "Software"), to deal in the Software without restriction,
11 * including without limitation the rights to use, copy, modify, merge,
12 * publish, distribute, sublicense, and/or sell copies of the Software,
13 * and to permit persons to whom the Software is furnished to do so,
14 * subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be
17 * included in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
22 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
23 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
24 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
25 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 */
27
28/*
29 * The text above constitutes the entire PortAudio license; however,
30 * the PortAudio community also makes the following non-binding requests:
31 *
32 * Any person wishing to distribute modifications to the Software is
33 * requested to send the modifications to the original developer so that
34 * they can be incorporated into the canonical version. It is also
35 * requested that these non-binding requests be included along with the
36 * license above.
37 */
38
39#include "com_portaudio_BlockingStream.h"
40#include "portaudio.h"
41#include "jpa_tools.h"
42
43#ifndef FALSE
44#define FALSE (0)
45#endif
46#ifndef TRUE
47#define TRUE (!FALSE)
48#endif
49
50/*
51 * Class: com_portaudio_BlockingStream
52 * Method: getReadAvailable
53 * Signature: ()I
54 */
55JNIEXPORT jint JNICALL Java_com_portaudio_BlockingStream_getReadAvailable
56 (JNIEnv *env, jobject blockingStream)
57{
58 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
59 if( stream == NULL ) return 0;
60 return Pa_GetStreamReadAvailable( stream );
61}
62
63/*
64 * Class: com_portaudio_BlockingStream
65 * Method: getWriteAvailable
66 * Signature: ()I
67 */
68JNIEXPORT jint JNICALL Java_com_portaudio_BlockingStream_getWriteAvailable
69 (JNIEnv *env, jobject blockingStream)
70{
71 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
72 if( stream == NULL ) return 0;
73 return Pa_GetStreamWriteAvailable( stream );
74}
75
76
77/*
78 * Class: com_portaudio_BlockingStream
79 * Method: writeFloats
80 * Signature: ([FI)Z
81 */
82JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_writeFloats
83 (JNIEnv *env, jobject blockingStream, jfloatArray buffer, jint numFrames)
84{
85 jfloat *carr;
86 jint err;
87 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
88 if( buffer == NULL )
89 {
90 (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),
91 "null stream buffer");
92 return FALSE;
93 }
94 carr = (*env)->GetFloatArrayElements(env, buffer, NULL);
95 if (carr == NULL)
96 {
97 (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),
98 "invalid stream buffer");
99 return FALSE;
100 }
101 err = Pa_WriteStream( stream, carr, numFrames );
102 (*env)->ReleaseFloatArrayElements(env, buffer, carr, 0);
103 if( err == paOutputUnderflowed )
104 {
105 return TRUE;
106 }
107 else
108 {
109 jpa_CheckError( env, err );
110 return FALSE;
111 }
112}
113
114/*
115 * Class: com_portaudio_BlockingStream
116 * Method: readFloats
117 * Signature: ([FI)Z
118 */
119JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_readFloats
120 (JNIEnv *env, jobject blockingStream, jfloatArray buffer, jint numFrames)
121{
122 jfloat *carr;
123 jint err;
124 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
125 if( buffer == NULL )
126 {
127 (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),
128 "null stream buffer");
129 return FALSE;
130 }
131 carr = (*env)->GetFloatArrayElements(env, buffer, NULL);
132 if (carr == NULL)
133 {
134 (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),
135 "invalid stream buffer");
136 return FALSE;
137 }
138 err = Pa_ReadStream( stream, carr, numFrames );
139 (*env)->ReleaseFloatArrayElements(env, buffer, carr, 0);
140 if( err == paInputOverflowed )
141 {
142 return TRUE;
143 }
144 else
145 {
146 jpa_CheckError( env, err );
147 return FALSE;
148 }
149}
150
151/*
152 * Class: com_portaudio_BlockingStream
153 * Method: writeShorts
154 * Signature: ([SI)Z
155 */
156JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_writeShorts
157 (JNIEnv *env, jobject blockingStream, jfloatArray buffer, jint numFrames)
158{
159 jshort *carr;
160 jint err;
161 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
162 if( buffer == NULL )
163 {
164 (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),
165 "null stream buffer");
166 return FALSE;
167 }
168 carr = (*env)->GetShortArrayElements(env, buffer, NULL);
169 if (carr == NULL)
170 {
171 (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),
172 "invalid stream buffer");
173 return FALSE;
174 }
175 err = Pa_WriteStream( stream, carr, numFrames );
176 (*env)->ReleaseShortArrayElements(env, buffer, carr, 0);
177 if( err == paOutputUnderflowed )
178 {
179 return TRUE;
180 }
181 else
182 {
183 jpa_CheckError( env, err );
184 return FALSE;
185 }
186}
187
188/*
189 * Class: com_portaudio_BlockingStream
190 * Method: readShorts
191 * Signature: ([SI)Z
192 */
193JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_readShorts
194 (JNIEnv *env, jobject blockingStream, jfloatArray buffer, jint numFrames)
195{
196 jshort *carr;
197 jint err;
198 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
199 if( buffer == NULL )
200 {
201 (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),
202 "null stream buffer");
203 return FALSE;
204 }
205 carr = (*env)->GetShortArrayElements(env, buffer, NULL);
206 if (carr == NULL)
207 {
208 (*env)->ThrowNew( env, (*env)->FindClass(env,"java/lang/RuntimeException"),
209 "invalid stream buffer");
210 return FALSE;
211 }
212 err = Pa_ReadStream( stream, carr, numFrames );
213 (*env)->ReleaseShortArrayElements(env, buffer, carr, 0);
214 if( err == paInputOverflowed )
215 {
216 return TRUE;
217 }
218 else
219 {
220 jpa_CheckError( env, err );
221 return FALSE;
222 }
223}
224
225/*
226 * Class: com_portaudio_BlockingStream
227 * Method: start
228 * Signature: ()V
229 */
230JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_start
231 (JNIEnv *env, jobject blockingStream )
232{
233 PaStream *stream = jpa_GetStreamPointer( env, blockingStream );
234 int err = Pa_StartStream( stream );
235 jpa_CheckError( env, err );
236}
237
238/*
239 * Class: com_portaudio_BlockingStream
240 * Method: stop
241 * Signature: ()V
242 */
243JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_stop
244 (JNIEnv *env, jobject blockingStream )
245{
246 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
247 int err = Pa_StopStream( stream );
248 jpa_CheckError( env, err );
249}
250/*
251 * Class: com_portaudio_BlockingStream
252 * Method: abort
253 * Signature: ()V
254 */
255JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_abort
256 (JNIEnv *env, jobject blockingStream )
257{
258 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
259 int err = Pa_AbortStream( stream );
260 jpa_CheckError( env, err );
261}
262
263/*
264 * Class: com_portaudio_BlockingStream
265 * Method: close
266 * Signature: ()V
267 */
268JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_close
269 (JNIEnv *env, jobject blockingStream )
270{
271 jclass cls;
272 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
273 if( stream != NULL )
274 {
275 int err = Pa_CloseStream( stream );
276 jpa_CheckError( env, err );
277 cls = (*env)->GetObjectClass(env, blockingStream);
278 jpa_SetLongField( env, cls, blockingStream, "nativeStream", (jlong) 0 );
279 }
280}
281
282/*
283 * Class: com_portaudio_BlockingStream
284 * Method: isStopped
285 * Signature: ()V
286 */
287JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_isStopped
288 (JNIEnv *env, jobject blockingStream )
289{
290 int err;
291 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
292 if( stream == NULL ) return 1;
293 err = Pa_IsStreamStopped( stream );
294 return (jpa_CheckError( env, err ) > 0);
295}
296/*
297 * Class: com_portaudio_BlockingStream
298 * Method: isActive
299 * Signature: ()V
300 */
301JNIEXPORT jboolean JNICALL Java_com_portaudio_BlockingStream_isActive
302 (JNIEnv *env, jobject blockingStream )
303{
304 int err;
305 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
306 if( stream == NULL ) return 0;
307 err = Pa_IsStreamActive( stream );
308 return (jpa_CheckError( env, err ) > 0);
309}
310
311
312/*
313 * Class: com_portaudio_BlockingStream
314 * Method: getTime
315 * Signature: ()D
316 */
317JNIEXPORT jdouble JNICALL Java_com_portaudio_BlockingStream_getTime
318 (JNIEnv *env, jobject blockingStream )
319{
320 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
321 if( stream == NULL ) return 0.0;
322 return Pa_GetStreamTime( stream );
323}
324
325
326/*
327 * Class: com_portaudio_BlockingStream
328 * Method: getInfo
329 * Signature: ()Lcom/portaudio/StreamInfo;
330 */
331JNIEXPORT void JNICALL Java_com_portaudio_BlockingStream_getInfo
332 (JNIEnv *env, jobject blockingStream, jobject streamInfo)
333{
334
335 PaStream *stream =jpa_GetStreamPointer( env, blockingStream );
336 const PaStreamInfo *info = Pa_GetStreamInfo( stream );
337 if( streamInfo == NULL )
338 {
339 jpa_ThrowError( env, "Invalid stream." );
340 }
341 else
342 {
343 /* Get a reference to obj's class */
344 jclass cls = (*env)->GetObjectClass(env, streamInfo);
345
346 jpa_SetIntField( env, cls, streamInfo, "structVersion", info->structVersion );
347 jpa_SetDoubleField( env, cls, streamInfo, "inputLatency", info->inputLatency );
348 jpa_SetDoubleField( env, cls, streamInfo, "outputLatency", info->outputLatency );
349 jpa_SetDoubleField( env, cls, streamInfo, "sampleRate", info->sampleRate );
350 }
351}
352
The portable PortAudio API.
PaError Pa_WriteStream(PaStream *stream, const void *buffer, unsigned long frames)
PaError Pa_ReadStream(PaStream *stream, void *buffer, unsigned long frames)
PaError Pa_AbortStream(PaStream *stream)
void PaStream
Definition: portaudio.h:584
PaError Pa_IsStreamActive(PaStream *stream)
signed long Pa_GetStreamWriteAvailable(PaStream *stream)
PaTime Pa_GetStreamTime(PaStream *stream)
PaError Pa_IsStreamStopped(PaStream *stream)
PaError Pa_StartStream(PaStream *stream)
PaError Pa_CloseStream(PaStream *stream)
const PaStreamInfo * Pa_GetStreamInfo(PaStream *stream)
signed long Pa_GetStreamReadAvailable(PaStream *stream)
PaError Pa_StopStream(PaStream *stream)
PaTime inputLatency
Definition: portaudio.h:999
PaTime outputLatency
Definition: portaudio.h:1007
int structVersion
Definition: portaudio.h:991
double sampleRate
Definition: portaudio.h:1016

Generated for PortAudio by  doxygen1.9.2