jcs.org
this repo has no description
1/*
2 SGLUALSA.h
3
4 Copyright (C) 2012 Stephan Kochen, Paul C. Pratt
5
6 You can redistribute this file and/or modify it under the terms
7 of version 2 of the GNU General Public License as published by
8 the Free Software Foundation. You should have received a copy
9 of the license along with this file; see the file COPYING.
10
11 This file is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 license for more details.
15*/
16
17/*
18 Sound GLUe for ALSA
19
20 ALSA sound support by Stephan Kochen.
21*/
22
23#ifndef RaspbianWorkAround
24#define RaspbianWorkAround 0
25#endif
26
27#if 0
28
29#include "alsa/asoundlib.h"
30 /* and link with "-lasound" */
31
32#define My_snd_pcm_t snd_pcm_t
33#define My_snd_pcm_hw_params_t snd_pcm_hw_params_t
34#define My_snd_pcm_sw_params_t snd_pcm_sw_params_t
35#define My_snd_pcm_state_t snd_pcm_state_t
36#if RaspbianWorkAround
37#define My_snd_pcm_status_t snd_pcm_status_t
38#endif
39
40#define My_SND_PCM_STATE_OPEN SND_PCM_STATE_OPEN
41#define My_SND_PCM_STATE_SETUP SND_PCM_STATE_SETUP
42#define My_SND_PCM_STATE_PREPARED SND_PCM_STATE_PREPARED
43#define My_SND_PCM_STATE_RUNNING SND_PCM_STATE_RUNNING
44#define My_SND_PCM_STATE_XRUN SND_PCM_STATE_XRUN
45#define My_SND_PCM_STATE_DRAINING SND_PCM_STATE_DRAINING
46#define My_SND_PCM_STATE_PAUSED SND_PCM_STATE_PAUSED
47#define My_SND_PCM_STATE_SUSPENDED SND_PCM_STATE_SUSPENDED
48#define My_SND_PCM_STATE_DISCONNECTED SND_PCM_STATE_DISCONNECTED
49#define My_SND_PCM_STATE_LAST SND_PCM_STATE_LAST
50
51#define My_snd_pcm_stream_t snd_pcm_stream_t
52
53#define My_SND_PCM_STREAM_PLAYBACK SND_PCM_STREAM_PLAYBACK
54#define My_SND_PCM_STREAM_CAPTURE SND_PCM_STREAM_CAPTURE
55#define My_SND_PCM_STREAM_LAST SND_PCM_STREAM_LAST
56
57#define My_snd_pcm_access_t snd_pcm_access_t
58
59#define My_SND_PCM_ACCESS_MMAP_INTERLEAVED \
60 SND_PCM_ACCESS_MMAP_INTERLEAVED
61#define My_SND_PCM_ACCESS_MMAP_NONINTERLEAVED \
62 SND_PCM_ACCESS_MMAP_NONINTERLEAVED
63#define My_SND_PCM_ACCESS_MMAP_COMPLEX \
64 SND_PCM_ACCESS_MMAP_COMPLEX
65#define My_SND_PCM_ACCESS_RW_INTERLEAVED \
66 SND_PCM_ACCESS_RW_INTERLEAVED
67#define My_SND_PCM_ACCESS_RW_NONINTERLEAVED \
68 SND_PCM_ACCESS_RW_NONINTERLEAVED
69#define My_SND_PCM_ACCESS_LAST \
70 SND_PCM_ACCESS_LAST
71
72#define My_snd_pcm_format_t snd_pcm_format_t
73
74#define My_SND_PCM_FORMAT_UNKNOWN SND_PCM_FORMAT_UNKNOWN
75#define My_SND_PCM_FORMAT_S8 SND_PCM_FORMAT_S8
76#define My_SND_PCM_FORMAT_U8 SND_PCM_FORMAT_U8
77#define My_SND_PCM_FORMAT_S16_LE SND_PCM_FORMAT_S16_LE
78#define My_SND_PCM_FORMAT_S16_BE SND_PCM_FORMAT_S16_BE
79#define My_SND_PCM_FORMAT_U16_LE SND_PCM_FORMAT_U16_LE
80#define My_SND_PCM_FORMAT_U16_BE SND_PCM_FORMAT_U16_BE
81#define My_SND_PCM_FORMAT_S24_LE SND_PCM_FORMAT_S24_LE
82#define My_SND_PCM_FORMAT_S24_BE SND_PCM_FORMAT_S24_BE
83#define My_SND_PCM_FORMAT_U24_LE SND_PCM_FORMAT_U24_LE
84#define My_SND_PCM_FORMAT_U24_BE SND_PCM_FORMAT_U24_BE
85#define My_SND_PCM_FORMAT_S32_LE SND_PCM_FORMAT_S32_LE
86#define My_SND_PCM_FORMAT_S32_BE SND_PCM_FORMAT_S32_BE
87#define My_SND_PCM_FORMAT_U32_LE SND_PCM_FORMAT_U32_LE
88#define My_SND_PCM_FORMAT_U32_BE SND_PCM_FORMAT_U32_BE
89#define My_SND_PCM_FORMAT_FLOAT_LE SND_PCM_FORMAT_FLOAT_LE
90#define My_SND_PCM_FORMAT_FLOAT_BE SND_PCM_FORMAT_FLOAT_BE
91#define My_SND_PCM_FORMAT_FLOAT64_LE SND_PCM_FORMAT_FLOAT64_LE
92#define My_SND_PCM_FORMAT_FLOAT64_BE SND_PCM_FORMAT_FLOAT64_BE
93#define My_SND_PCM_FORMAT_IEC958_SUBFRAME_LE \
94 SND_PCM_FORMAT_IEC958_SUBFRAME_LE
95#define My_SND_PCM_FORMAT_IEC958_SUBFRAME_BE \
96 SND_PCM_FORMAT_IEC958_SUBFRAME_BE
97#define My_SND_PCM_FORMAT_MU_LAW SND_PCM_FORMAT_MU_LAW
98#define My_SND_PCM_FORMAT_A_LAW SND_PCM_FORMAT_A_LAW
99#define My_SND_PCM_FORMAT_IMA_ADPCM SND_PCM_FORMAT_IMA_ADPCM
100#define My_SND_PCM_FORMAT_MPEG SND_PCM_FORMAT_MPEG
101#define My_SND_PCM_FORMAT_GSM SND_PCM_FORMAT_GSM
102#define My_SND_PCM_FORMAT_SPECIAL SND_PCM_FORMAT_SPECIAL
103#define My_SND_PCM_FORMAT_S24_3LE SND_PCM_FORMAT_S24_3LE
104#define My_SND_PCM_FORMAT_S24_3BE SND_PCM_FORMAT_S24_3BE
105#define My_SND_PCM_FORMAT_U24_3LE SND_PCM_FORMAT_U24_3LE
106#define My_SND_PCM_FORMAT_U24_3BE SND_PCM_FORMAT_U24_3BE
107#define My_SND_PCM_FORMAT_S20_3LE SND_PCM_FORMAT_S20_3LE
108#define My_SND_PCM_FORMAT_S20_3BE SND_PCM_FORMAT_S20_3BE
109#define My_SND_PCM_FORMAT_U20_3LE SND_PCM_FORMAT_U20_3LE
110#define My_SND_PCM_FORMAT_U20_3BE SND_PCM_FORMAT_U20_3BE
111#define My_SND_PCM_FORMAT_S18_3LE SND_PCM_FORMAT_S18_3LE
112#define My_SND_PCM_FORMAT_S18_3BE SND_PCM_FORMAT_S18_3BE
113#define My_SND_PCM_FORMAT_U18_3LE SND_PCM_FORMAT_U18_3LE
114#define My_SND_PCM_FORMAT_U18_3BE SND_PCM_FORMAT_U18_3BE
115#define My_SND_PCM_FORMAT_LAST SND_PCM_FORMAT_LAST
116
117#define My_SND_PCM_FORMAT_S16 SND_PCM_FORMAT_S16
118#define My_SND_PCM_FORMAT_U16 SND_PCM_FORMAT_U16
119#define My_SND_PCM_FORMAT_S24 SND_PCM_FORMAT_S24
120#define My_SND_PCM_FORMAT_U24 SND_PCM_FORMAT_U24
121#define My_SND_PCM_FORMAT_S32 SND_PCM_FORMAT_S32
122#define My_SND_PCM_FORMAT_U32 SND_PCM_FORMAT_U32
123#define My_SND_PCM_FORMAT_FLOAT SND_PCM_FORMAT_FLOAT
124#define My_SND_PCM_FORMAT_FLOAT64 SND_PCM_FORMAT_FLOAT64
125#define My_SND_PCM_FORMAT_IEC958_SUBFRAME SND_PCM_FORMAT_FLOAT64
126
127#define My_snd_pcm_uframes_t snd_pcm_uframes_t
128#define My_snd_pcm_sframes_t snd_pcm_sframes_t
129
130#define My_SND_PCM_NONBLOCK SND_PCM_NONBLOCK
131
132#define My_snd_pcm_open snd_pcm_open
133#define HaveMy_snd_pcm_open() (1)
134
135#define My_snd_pcm_close snd_pcm_close
136#define HaveMy_snd_pcm_close() (1)
137
138#define My_snd_pcm_hw_params_malloc snd_pcm_hw_params_malloc
139#define HaveMy_snd_pcm_hw_params_malloc() (1)
140
141#define My_snd_pcm_hw_params_free snd_pcm_hw_params_free
142#define HaveMy_snd_pcm_hw_params_free() (1)
143
144#define My_snd_pcm_hw_params_any snd_pcm_hw_params_any
145#define HaveMy_snd_pcm_hw_params_any() (1)
146
147#define My_snd_pcm_hw_params_set_access snd_pcm_hw_params_set_access
148#define HaveMy_snd_pcm_hw_params_set_access() (1)
149
150#define My_snd_pcm_hw_params_set_format snd_pcm_hw_params_set_format
151#define HaveMy_snd_pcm_hw_params_set_format() (1)
152
153#define My_snd_pcm_hw_params_set_rate_near \
154 snd_pcm_hw_params_set_rate_near
155#define HaveMy_snd_pcm_hw_params_set_rate_near() (1)
156
157#define My_snd_pcm_hw_params_set_channels \
158 snd_pcm_hw_params_set_channels
159#define HaveMy_snd_pcm_hw_params_set_channels() (1)
160
161#define My_snd_pcm_hw_params_set_buffer_size_near \
162 snd_pcm_hw_params_set_buffer_size_near
163#define HaveMy_snd_pcm_hw_params_set_buffer_size_near() (1)
164
165#define My_snd_pcm_hw_params_set_period_size_near \
166 snd_pcm_hw_params_set_period_size_near
167#define HaveMy_snd_pcm_hw_params_set_period_size_near() (1)
168
169#define My_snd_pcm_hw_params snd_pcm_hw_params
170#define HaveMy_snd_pcm_hw_params() (1)
171
172#define My_snd_pcm_sw_params_malloc snd_pcm_sw_params_malloc
173#define HaveMy_snd_pcm_sw_params_malloc() (1)
174
175#define My_snd_pcm_sw_params_free snd_pcm_sw_params_free
176#define HaveMy_snd_pcm_sw_params_free() (1)
177
178#define My_snd_pcm_sw_params_current snd_pcm_sw_params_current
179#define HaveMy_snd_pcm_sw_params_current() (1)
180
181#define My_snd_pcm_sw_params_set_start_threshold \
182 snd_pcm_sw_params_set_start_threshold
183#define HaveMy_snd_pcm_sw_params_set_start_threshold() (1)
184
185#define My_snd_pcm_sw_params_set_avail_min \
186 snd_pcm_sw_params_set_avail_min
187#define HaveMy_snd_pcm_sw_params_set_avail_min() (1)
188
189#define My_snd_pcm_sw_params_set_xfer_align \
190 snd_pcm_sw_params_set_xfer_align
191#define HaveMy_snd_pcm_sw_params_set_xfer_align() (1)
192
193#define My_snd_pcm_sw_params snd_pcm_sw_params
194#define HaveMy_snd_pcm_sw_params() (1)
195
196#define My_snd_pcm_nonblock snd_pcm_nonblock
197#define HaveMy_snd_pcm_nonblock() (1)
198
199#define My_snd_pcm_state snd_pcm_state
200#define HaveMy_snd_pcm_state() (1)
201
202#define My_snd_pcm_prepare snd_pcm_prepare
203#define HaveMy_snd_pcm_prepare() (1)
204
205#define My_snd_pcm_start snd_pcm_start
206#define HaveMy_snd_pcm_start() (1)
207
208#define My_snd_pcm_resume snd_pcm_resume
209#define HaveMy_snd_pcm_resume() (1)
210
211#define My_snd_pcm_avail_update snd_pcm_avail_update
212#define HaveMy_snd_pcm_avail_update() (1)
213
214#define My_snd_pcm_writei snd_pcm_writei
215#define HaveMy_snd_pcm_writei() (1)
216
217#define My_snd_pcm_drop snd_pcm_drop
218#define HaveMy_snd_pcm_drop() (1)
219
220#if RaspbianWorkAround
221#define My_snd_pcm_status_malloc snd_pcm_status_malloc
222#define HaveMy_snd_pcm_status_malloc() (1)
223
224#define My_snd_pcm_status snd_pcm_status
225#define HaveMy_snd_pcm_status() (1)
226
227#define My_snd_pcm_status_get_avail snd_pcm_status_get_avail
228#define HaveMy_snd_pcm_status_get_avail() (1)
229#endif
230
231#define My_snd_strerror snd_strerror
232#define HaveMy_snd_strerror() (1)
233
234#define MyCloseAlsaLib()
235
236#else
237
238static void *alsa_handle = NULL;
239
240LOCALVAR blnr DidAlsaLib = falseblnr;
241
242LOCALFUNC blnr HaveAlsaLib(void)
243{
244 if (! DidAlsaLib) {
245 alsa_handle = dlopen("libasound.so.2", RTLD_NOW);
246 if (NULL == alsa_handle) {
247 fprintf(stderr, "dlopen libasound failed\n");
248 }
249 DidAlsaLib = trueblnr;
250 }
251 return (alsa_handle != NULL);
252}
253
254LOCALPROC MyCloseAlsaLib(void)
255{
256 if (NULL != alsa_handle) {
257 if (0 != dlclose(alsa_handle)) {
258 fprintf(stderr, "dlclose libasound failed\n");
259 }
260 alsa_handle = NULL;
261 }
262}
263
264/* PCM handle */
265typedef struct My__snd_pcm My_snd_pcm_t;
266/* PCM hardware configuration space container */
267typedef struct My__snd_pcm_hw_params My_snd_pcm_hw_params_t;
268/* PCM software configuration container */
269typedef struct My__snd_pcm_sw_params My_snd_pcm_sw_params_t;
270
271#if RaspbianWorkAround
272/* PCM status container */
273typedef struct My__snd_pcm_status My_snd_pcm_status_t;
274#endif
275
276/* PCM state */
277typedef enum My__snd_pcm_state {
278 /* Open */
279 My_SND_PCM_STATE_OPEN = 0,
280 /* Setup installed */
281 My_SND_PCM_STATE_SETUP,
282 /* Ready to start */
283 My_SND_PCM_STATE_PREPARED,
284 /* Running */
285 My_SND_PCM_STATE_RUNNING,
286 /* Stopped: underrun (playback) or overrun (capture) detected */
287 My_SND_PCM_STATE_XRUN,
288 /* Draining: running (playback) or stopped (capture) */
289 My_SND_PCM_STATE_DRAINING,
290 /* Paused */
291 My_SND_PCM_STATE_PAUSED,
292 /* Hardware is suspended */
293 My_SND_PCM_STATE_SUSPENDED,
294 /* Hardware is disconnected */
295 My_SND_PCM_STATE_DISCONNECTED,
296 My_SND_PCM_STATE_LAST = My_SND_PCM_STATE_DISCONNECTED
297} My_snd_pcm_state_t;
298
299/* PCM stream (direction) */
300typedef enum My__snd_pcm_stream {
301 /* Playback stream */
302 My_SND_PCM_STREAM_PLAYBACK = 0,
303 /* Capture stream */
304 My_SND_PCM_STREAM_CAPTURE,
305 My_SND_PCM_STREAM_LAST = My_SND_PCM_STREAM_CAPTURE
306} My_snd_pcm_stream_t;
307
308/* PCM access type */
309typedef enum My__snd_pcm_access {
310 /* mmap access with simple interleaved channels */
311 My_SND_PCM_ACCESS_MMAP_INTERLEAVED = 0,
312 /* mmap access with simple non interleaved channels */
313 My_SND_PCM_ACCESS_MMAP_NONINTERLEAVED,
314 /* mmap access with complex placement */
315 My_SND_PCM_ACCESS_MMAP_COMPLEX,
316 /* snd_pcm_readi/snd_pcm_writei access */
317 My_SND_PCM_ACCESS_RW_INTERLEAVED,
318 /* snd_pcm_readn/snd_pcm_writen access */
319 My_SND_PCM_ACCESS_RW_NONINTERLEAVED,
320 My_SND_PCM_ACCESS_LAST = My_SND_PCM_ACCESS_RW_NONINTERLEAVED
321} My_snd_pcm_access_t;
322
323/* PCM sample format */
324typedef enum My__snd_pcm_format {
325 /* Unknown */
326 My_SND_PCM_FORMAT_UNKNOWN = -1,
327 /* Signed 8 bit */
328 My_SND_PCM_FORMAT_S8 = 0,
329 /* Unsigned 8 bit */
330 My_SND_PCM_FORMAT_U8,
331 /* Signed 16 bit Little Endian */
332 My_SND_PCM_FORMAT_S16_LE,
333 /* Signed 16 bit Big Endian */
334 My_SND_PCM_FORMAT_S16_BE,
335 /* Unsigned 16 bit Little Endian */
336 My_SND_PCM_FORMAT_U16_LE,
337 /* Unsigned 16 bit Big Endian */
338 My_SND_PCM_FORMAT_U16_BE,
339 /*
340 Signed 24 bit Little Endian using low three bytes in 32-bit word
341 */
342 My_SND_PCM_FORMAT_S24_LE,
343 /* Signed 24 bit Big Endian using low three bytes in 32-bit word */
344 My_SND_PCM_FORMAT_S24_BE,
345 /*
346 Unsigned 24 bit Little Endian using low three bytes in
347 32-bit word
348 */
349 My_SND_PCM_FORMAT_U24_LE,
350 /*
351 Unsigned 24 bit Big Endian using low three bytes in 32-bit word
352 */
353 My_SND_PCM_FORMAT_U24_BE,
354 /* Signed 32 bit Little Endian */
355 My_SND_PCM_FORMAT_S32_LE,
356 /* Signed 32 bit Big Endian */
357 My_SND_PCM_FORMAT_S32_BE,
358 /* Unsigned 32 bit Little Endian */
359 My_SND_PCM_FORMAT_U32_LE,
360 /* Unsigned 32 bit Big Endian */
361 My_SND_PCM_FORMAT_U32_BE,
362 /* Float 32 bit Little Endian, Range -1.0 to 1.0 */
363 My_SND_PCM_FORMAT_FLOAT_LE,
364 /* Float 32 bit Big Endian, Range -1.0 to 1.0 */
365 My_SND_PCM_FORMAT_FLOAT_BE,
366 /* Float 64 bit Little Endian, Range -1.0 to 1.0 */
367 My_SND_PCM_FORMAT_FLOAT64_LE,
368 /* Float 64 bit Big Endian, Range -1.0 to 1.0 */
369 My_SND_PCM_FORMAT_FLOAT64_BE,
370 /* IEC-958 Little Endian */
371 My_SND_PCM_FORMAT_IEC958_SUBFRAME_LE,
372 /* IEC-958 Big Endian */
373 My_SND_PCM_FORMAT_IEC958_SUBFRAME_BE,
374 /* Mu-Law */
375 My_SND_PCM_FORMAT_MU_LAW,
376 /* A-Law */
377 My_SND_PCM_FORMAT_A_LAW,
378 /* Ima-ADPCM */
379 My_SND_PCM_FORMAT_IMA_ADPCM,
380 /* MPEG */
381 My_SND_PCM_FORMAT_MPEG,
382 /* GSM */
383 My_SND_PCM_FORMAT_GSM,
384 /* Special */
385 My_SND_PCM_FORMAT_SPECIAL = 31,
386 /* Signed 24bit Little Endian in 3bytes format */
387 My_SND_PCM_FORMAT_S24_3LE = 32,
388 /* Signed 24bit Big Endian in 3bytes format */
389 My_SND_PCM_FORMAT_S24_3BE,
390 /* Unsigned 24bit Little Endian in 3bytes format */
391 My_SND_PCM_FORMAT_U24_3LE,
392 /* Unsigned 24bit Big Endian in 3bytes format */
393 My_SND_PCM_FORMAT_U24_3BE,
394 /* Signed 20bit Little Endian in 3bytes format */
395 My_SND_PCM_FORMAT_S20_3LE,
396 /* Signed 20bit Big Endian in 3bytes format */
397 My_SND_PCM_FORMAT_S20_3BE,
398 /* Unsigned 20bit Little Endian in 3bytes format */
399 My_SND_PCM_FORMAT_U20_3LE,
400 /* Unsigned 20bit Big Endian in 3bytes format */
401 My_SND_PCM_FORMAT_U20_3BE,
402 /* Signed 18bit Little Endian in 3bytes format */
403 My_SND_PCM_FORMAT_S18_3LE,
404 /* Signed 18bit Big Endian in 3bytes format */
405 My_SND_PCM_FORMAT_S18_3BE,
406 /* Unsigned 18bit Little Endian in 3bytes format */
407 My_SND_PCM_FORMAT_U18_3LE,
408 /* Unsigned 18bit Big Endian in 3bytes format */
409 My_SND_PCM_FORMAT_U18_3BE,
410 My_SND_PCM_FORMAT_LAST = My_SND_PCM_FORMAT_U18_3BE,
411
412#if __BYTE_ORDER == __LITTLE_ENDIAN
413 /* Signed 16 bit CPU endian */
414 My_SND_PCM_FORMAT_S16 = My_SND_PCM_FORMAT_S16_LE,
415 /* Unsigned 16 bit CPU endian */
416 My_SND_PCM_FORMAT_U16 = My_SND_PCM_FORMAT_U16_LE,
417 /* Signed 24 bit CPU endian */
418 My_SND_PCM_FORMAT_S24 = My_SND_PCM_FORMAT_S24_LE,
419 /* Unsigned 24 bit CPU endian */
420 My_SND_PCM_FORMAT_U24 = My_SND_PCM_FORMAT_U24_LE,
421 /* Signed 32 bit CPU endian */
422 My_SND_PCM_FORMAT_S32 = My_SND_PCM_FORMAT_S32_LE,
423 /* Unsigned 32 bit CPU endian */
424 My_SND_PCM_FORMAT_U32 = My_SND_PCM_FORMAT_U32_LE,
425 /* Float 32 bit CPU endian */
426 My_SND_PCM_FORMAT_FLOAT = My_SND_PCM_FORMAT_FLOAT_LE,
427 /* Float 64 bit CPU endian */
428 My_SND_PCM_FORMAT_FLOAT64 = My_SND_PCM_FORMAT_FLOAT64_LE,
429 /* IEC-958 CPU Endian */
430 My_SND_PCM_FORMAT_IEC958_SUBFRAME =
431 My_SND_PCM_FORMAT_IEC958_SUBFRAME_LE
432#elif __BYTE_ORDER == __BIG_ENDIAN
433 /* Signed 16 bit CPU endian */
434 My_SND_PCM_FORMAT_S16 = My_SND_PCM_FORMAT_S16_BE,
435 /* Unsigned 16 bit CPU endian */
436 My_SND_PCM_FORMAT_U16 = My_SND_PCM_FORMAT_U16_BE,
437 /* Signed 24 bit CPU endian */
438 My_SND_PCM_FORMAT_S24 = My_SND_PCM_FORMAT_S24_BE,
439 /* Unsigned 24 bit CPU endian */
440 My_SND_PCM_FORMAT_U24 = My_SND_PCM_FORMAT_U24_BE,
441 /* Signed 32 bit CPU endian */
442 My_SND_PCM_FORMAT_S32 = My_SND_PCM_FORMAT_S32_BE,
443 /* Unsigned 32 bit CPU endian */
444 My_SND_PCM_FORMAT_U32 = My_SND_PCM_FORMAT_U32_BE,
445 /* Float 32 bit CPU endian */
446 My_SND_PCM_FORMAT_FLOAT = My_SND_PCM_FORMAT_FLOAT_BE,
447 /* Float 64 bit CPU endian */
448 My_SND_PCM_FORMAT_FLOAT64 = My_SND_PCM_FORMAT_FLOAT64_BE,
449 /* IEC-958 CPU Endian */
450 My_SND_PCM_FORMAT_IEC958_SUBFRAME =
451 My_SND_PCM_FORMAT_IEC958_SUBFRAME_BE
452#else
453#error "Unknown endian"
454#endif
455} My_snd_pcm_format_t;
456
457/* Unsigned frames quantity */
458typedef unsigned long My_snd_pcm_uframes_t;
459/* Signed frames quantity */
460typedef long My_snd_pcm_sframes_t;
461
462/* Non blocking mode (flag for open mode) \hideinitializer */
463#define My_SND_PCM_NONBLOCK 0x00000001
464
465typedef int (*snd_pcm_open_ProcPtr)
466 (My_snd_pcm_t **pcm, const char *name, My_snd_pcm_stream_t stream,
467 int mode);
468LOCALVAR snd_pcm_open_ProcPtr My_snd_pcm_open = NULL;
469LOCALVAR blnr Did_snd_pcm_open = falseblnr;
470
471LOCALFUNC blnr HaveMy_snd_pcm_open(void)
472{
473 if (! Did_snd_pcm_open) {
474 if (HaveAlsaLib()) {
475 My_snd_pcm_open = (snd_pcm_open_ProcPtr)dlsym(alsa_handle,
476 "snd_pcm_open");
477 if (NULL == My_snd_pcm_open) {
478 fprintf(stderr, "dlsym snd_pcm_open failed\n");
479 }
480 }
481 Did_snd_pcm_open = trueblnr;
482 }
483 return (My_snd_pcm_open != NULL);
484}
485
486typedef int (*snd_pcm_close_ProcPtr)(My_snd_pcm_t *pcm);
487LOCALVAR snd_pcm_close_ProcPtr My_snd_pcm_close = NULL;
488LOCALVAR blnr Did_snd_pcm_close = falseblnr;
489
490LOCALFUNC blnr HaveMy_snd_pcm_close(void)
491{
492 if (! Did_snd_pcm_close) {
493 if (HaveAlsaLib()) {
494 My_snd_pcm_close = (snd_pcm_close_ProcPtr)dlsym(alsa_handle,
495 "snd_pcm_close");
496 if (NULL == My_snd_pcm_close) {
497 fprintf(stderr, "dlsym snd_pcm_close failed\n");
498 }
499 }
500 Did_snd_pcm_close = trueblnr;
501 }
502 return (My_snd_pcm_close != NULL);
503}
504
505typedef int (*snd_pcm_hw_params_malloc_ProcPtr)
506 (My_snd_pcm_hw_params_t **ptr);
507LOCALVAR snd_pcm_hw_params_malloc_ProcPtr My_snd_pcm_hw_params_malloc
508 = NULL;
509LOCALVAR blnr Did_snd_pcm_hw_params_malloc = falseblnr;
510
511LOCALFUNC blnr HaveMy_snd_pcm_hw_params_malloc(void)
512{
513 if (! Did_snd_pcm_hw_params_malloc) {
514 if (HaveAlsaLib()) {
515 My_snd_pcm_hw_params_malloc =
516 (snd_pcm_hw_params_malloc_ProcPtr)
517 dlsym(alsa_handle, "snd_pcm_hw_params_malloc");
518 if (NULL == My_snd_pcm_hw_params_malloc) {
519 fprintf(stderr,
520 "dlsym snd_pcm_hw_params_malloc failed\n");
521 }
522 }
523 Did_snd_pcm_hw_params_malloc = trueblnr;
524 }
525 return (My_snd_pcm_hw_params_malloc != NULL);
526}
527
528typedef void (*snd_pcm_hw_params_free_ProcPtr)
529 (My_snd_pcm_hw_params_t *obj);
530LOCALVAR snd_pcm_hw_params_free_ProcPtr
531 My_snd_pcm_hw_params_free = NULL;
532LOCALVAR blnr Did_snd_pcm_hw_params_free = falseblnr;
533
534LOCALFUNC blnr HaveMy_snd_pcm_hw_params_free(void)
535{
536 if (! Did_snd_pcm_hw_params_free) {
537 if (HaveAlsaLib()) {
538 My_snd_pcm_hw_params_free = (snd_pcm_hw_params_free_ProcPtr)
539 dlsym(alsa_handle, "snd_pcm_hw_params_free");
540 if (NULL == My_snd_pcm_hw_params_free) {
541 fprintf(stderr,
542 "dlsym snd_pcm_hw_params_free failed\n");
543 }
544 }
545 Did_snd_pcm_hw_params_free = trueblnr;
546 }
547 return (My_snd_pcm_hw_params_free != NULL);
548}
549
550typedef int (*snd_pcm_hw_params_any_ProcPtr)
551 (My_snd_pcm_t *pcm, My_snd_pcm_hw_params_t *params);
552LOCALVAR snd_pcm_hw_params_any_ProcPtr My_snd_pcm_hw_params_any = NULL;
553LOCALVAR blnr Did_snd_pcm_hw_params_any = falseblnr;
554
555LOCALFUNC blnr HaveMy_snd_pcm_hw_params_any(void)
556{
557 if (! Did_snd_pcm_hw_params_any) {
558 if (HaveAlsaLib()) {
559 My_snd_pcm_hw_params_any = (snd_pcm_hw_params_any_ProcPtr)
560 dlsym(alsa_handle, "snd_pcm_hw_params_any");
561 if (NULL == My_snd_pcm_hw_params_any) {
562 fprintf(stderr, "dlsym snd_pcm_hw_params_any failed\n");
563 }
564 }
565 Did_snd_pcm_hw_params_any = trueblnr;
566 }
567 return (My_snd_pcm_hw_params_any != NULL);
568}
569
570typedef int (*snd_pcm_hw_params_set_access_ProcPtr)
571 (My_snd_pcm_t *pcm, My_snd_pcm_hw_params_t *params,
572 My_snd_pcm_access_t _access);
573LOCALVAR snd_pcm_hw_params_set_access_ProcPtr
574 My_snd_pcm_hw_params_set_access = NULL;
575LOCALVAR blnr Did_snd_pcm_hw_params_set_access = falseblnr;
576
577LOCALFUNC blnr HaveMy_snd_pcm_hw_params_set_access(void)
578{
579 if (! Did_snd_pcm_hw_params_set_access) {
580 if (HaveAlsaLib()) {
581 My_snd_pcm_hw_params_set_access =
582 (snd_pcm_hw_params_set_access_ProcPtr)
583 dlsym(alsa_handle, "snd_pcm_hw_params_set_access");
584 if (NULL == My_snd_pcm_hw_params_set_access) {
585 fprintf(stderr,
586 "dlsym snd_pcm_hw_params_set_access failed\n");
587 }
588 }
589 Did_snd_pcm_hw_params_set_access = trueblnr;
590 }
591 return (My_snd_pcm_hw_params_set_access != NULL);
592}
593
594typedef int (*snd_pcm_hw_params_set_format_ProcPtr)
595 (My_snd_pcm_t *pcm, My_snd_pcm_hw_params_t *params,
596 My_snd_pcm_format_t val);
597LOCALVAR snd_pcm_hw_params_set_format_ProcPtr
598 My_snd_pcm_hw_params_set_format = NULL;
599LOCALVAR blnr Did_snd_pcm_hw_params_set_format = falseblnr;
600
601LOCALFUNC blnr HaveMy_snd_pcm_hw_params_set_format(void)
602{
603 if (! Did_snd_pcm_hw_params_set_format) {
604 if (HaveAlsaLib()) {
605 My_snd_pcm_hw_params_set_format =
606 (snd_pcm_hw_params_set_format_ProcPtr)
607 dlsym(alsa_handle, "snd_pcm_hw_params_set_format");
608 if (NULL == My_snd_pcm_hw_params_set_format) {
609 fprintf(stderr,
610 "dlsym snd_pcm_hw_params_set_format failed\n");
611 }
612 }
613 Did_snd_pcm_hw_params_set_format = trueblnr;
614 }
615 return (My_snd_pcm_hw_params_set_format != NULL);
616}
617
618typedef int (*snd_pcm_hw_params_set_rate_near_ProcPtr)
619 (My_snd_pcm_t *pcm, My_snd_pcm_hw_params_t *params,
620 unsigned int *val, int *dir);
621LOCALVAR snd_pcm_hw_params_set_rate_near_ProcPtr
622 My_snd_pcm_hw_params_set_rate_near = NULL;
623LOCALVAR blnr Did_snd_pcm_hw_params_set_rate_near = falseblnr;
624
625LOCALFUNC blnr HaveMy_snd_pcm_hw_params_set_rate_near(void)
626{
627 if (! Did_snd_pcm_hw_params_set_rate_near) {
628 if (HaveAlsaLib()) {
629 My_snd_pcm_hw_params_set_rate_near =
630 (snd_pcm_hw_params_set_rate_near_ProcPtr)
631 dlsym(alsa_handle, "snd_pcm_hw_params_set_rate_near");
632 if (NULL == My_snd_pcm_hw_params_set_rate_near) {
633 fprintf(stderr,
634 "dlsym snd_pcm_hw_params_set_rate_near failed\n");
635 }
636 }
637 Did_snd_pcm_hw_params_set_rate_near = trueblnr;
638 }
639 return (My_snd_pcm_hw_params_set_rate_near != NULL);
640}
641
642typedef int (*snd_pcm_hw_params_set_channels_ProcPtr)
643 (My_snd_pcm_t *pcm, My_snd_pcm_hw_params_t *params,
644 unsigned int val);
645LOCALVAR snd_pcm_hw_params_set_channels_ProcPtr
646 My_snd_pcm_hw_params_set_channels = NULL;
647LOCALVAR blnr Did_snd_pcm_hw_params_set_channels = falseblnr;
648
649LOCALFUNC blnr HaveMy_snd_pcm_hw_params_set_channels(void)
650{
651 if (! Did_snd_pcm_hw_params_set_channels) {
652 if (HaveAlsaLib()) {
653 My_snd_pcm_hw_params_set_channels =
654 (snd_pcm_hw_params_set_channels_ProcPtr)
655 dlsym(alsa_handle, "snd_pcm_hw_params_set_channels");
656 if (NULL == My_snd_pcm_hw_params_set_channels) {
657 fprintf(stderr,
658 "dlsym snd_pcm_hw_params_set_channels failed\n");
659 }
660 }
661 Did_snd_pcm_hw_params_set_channels = trueblnr;
662 }
663 return (My_snd_pcm_hw_params_set_channels != NULL);
664}
665
666typedef int (*snd_pcm_hw_params_set_buffer_size_near_ProcPtr)
667 (My_snd_pcm_t *pcm, My_snd_pcm_hw_params_t *params,
668 My_snd_pcm_uframes_t *val);
669LOCALVAR snd_pcm_hw_params_set_buffer_size_near_ProcPtr
670 My_snd_pcm_hw_params_set_buffer_size_near = NULL;
671LOCALVAR blnr Did_snd_pcm_hw_params_set_buffer_size_near = falseblnr;
672
673LOCALFUNC blnr HaveMy_snd_pcm_hw_params_set_buffer_size_near(void)
674{
675 if (! Did_snd_pcm_hw_params_set_buffer_size_near) {
676 if (HaveAlsaLib()) {
677 My_snd_pcm_hw_params_set_buffer_size_near =
678 (snd_pcm_hw_params_set_buffer_size_near_ProcPtr)
679 dlsym(alsa_handle,
680 "snd_pcm_hw_params_set_buffer_size_near");
681 if (NULL == My_snd_pcm_hw_params_set_buffer_size_near) {
682 fprintf(stderr,
683 "dlsym snd_pcm_hw_params_set_buffer_size_near"
684 " failed\n");
685 }
686 }
687 Did_snd_pcm_hw_params_set_buffer_size_near = trueblnr;
688 }
689 return (My_snd_pcm_hw_params_set_buffer_size_near != NULL);
690}
691
692typedef int (*snd_pcm_hw_params_set_period_size_near_ProcPtr)
693 (My_snd_pcm_t *pcm, My_snd_pcm_hw_params_t *params,
694 My_snd_pcm_uframes_t *val, int *dir);
695LOCALVAR snd_pcm_hw_params_set_period_size_near_ProcPtr
696 My_snd_pcm_hw_params_set_period_size_near = NULL;
697LOCALVAR blnr Did_snd_pcm_hw_params_set_period_size_near = falseblnr;
698
699LOCALFUNC blnr HaveMy_snd_pcm_hw_params_set_period_size_near(void)
700{
701 if (! Did_snd_pcm_hw_params_set_period_size_near) {
702 if (HaveAlsaLib()) {
703 My_snd_pcm_hw_params_set_period_size_near =
704 (snd_pcm_hw_params_set_period_size_near_ProcPtr)
705 dlsym(alsa_handle,
706 "snd_pcm_hw_params_set_period_size_near");
707 if (NULL == My_snd_pcm_hw_params_set_period_size_near) {
708 fprintf(stderr,
709 "dlsym snd_pcm_hw_params_set_period_size_near"
710 " failed\n");
711 }
712 }
713 Did_snd_pcm_hw_params_set_period_size_near = trueblnr;
714 }
715 return (My_snd_pcm_hw_params_set_period_size_near != NULL);
716}
717
718typedef int (*snd_pcm_hw_params_ProcPtr)
719 (My_snd_pcm_t *pcm, My_snd_pcm_hw_params_t *params);
720LOCALVAR snd_pcm_hw_params_ProcPtr My_snd_pcm_hw_params = NULL;
721LOCALVAR blnr Did_snd_pcm_hw_params = falseblnr;
722
723LOCALFUNC blnr HaveMy_snd_pcm_hw_params(void)
724{
725 if (! Did_snd_pcm_hw_params) {
726 if (HaveAlsaLib()) {
727 My_snd_pcm_hw_params = (snd_pcm_hw_params_ProcPtr)
728 dlsym(alsa_handle, "snd_pcm_hw_params");
729 if (NULL == My_snd_pcm_hw_params) {
730 fprintf(stderr, "dlsym snd_pcm_hw_params failed\n");
731 }
732 }
733 Did_snd_pcm_hw_params = trueblnr;
734 }
735 return (My_snd_pcm_hw_params != NULL);
736}
737
738typedef int (*snd_pcm_sw_params_malloc_ProcPtr)
739 (My_snd_pcm_sw_params_t **ptr);
740LOCALVAR snd_pcm_sw_params_malloc_ProcPtr
741 My_snd_pcm_sw_params_malloc = NULL;
742LOCALVAR blnr Did_snd_pcm_sw_params_malloc = falseblnr;
743
744LOCALFUNC blnr HaveMy_snd_pcm_sw_params_malloc(void)
745{
746 if (! Did_snd_pcm_sw_params_malloc) {
747 if (HaveAlsaLib()) {
748 My_snd_pcm_sw_params_malloc =
749 (snd_pcm_sw_params_malloc_ProcPtr)
750 dlsym(alsa_handle, "snd_pcm_sw_params_malloc");
751 if (NULL == My_snd_pcm_sw_params_malloc) {
752 fprintf(stderr,
753 "dlsym snd_pcm_sw_params_malloc failed\n");
754 }
755 }
756 Did_snd_pcm_sw_params_malloc = trueblnr;
757 }
758 return (My_snd_pcm_sw_params_malloc != NULL);
759}
760
761typedef void (*snd_pcm_sw_params_free_ProcPtr)
762 (My_snd_pcm_sw_params_t *obj);
763LOCALVAR snd_pcm_sw_params_free_ProcPtr
764 My_snd_pcm_sw_params_free = NULL;
765LOCALVAR blnr Did_snd_pcm_sw_params_free = falseblnr;
766
767LOCALFUNC blnr HaveMy_snd_pcm_sw_params_free(void)
768{
769 if (! Did_snd_pcm_sw_params_free) {
770 if (HaveAlsaLib()) {
771 My_snd_pcm_sw_params_free = (snd_pcm_sw_params_free_ProcPtr)
772 dlsym(alsa_handle, "snd_pcm_sw_params_free");
773 if (NULL == My_snd_pcm_sw_params_free) {
774 fprintf(stderr,
775 "dlsym snd_pcm_sw_params_free failed\n");
776 }
777 }
778 Did_snd_pcm_sw_params_free = trueblnr;
779 }
780 return (My_snd_pcm_sw_params_free != NULL);
781}
782
783typedef int (*snd_pcm_sw_params_current_ProcPtr)
784 (My_snd_pcm_t *pcm, My_snd_pcm_sw_params_t *params);
785LOCALVAR snd_pcm_sw_params_current_ProcPtr
786 My_snd_pcm_sw_params_current = NULL;
787LOCALVAR blnr Did_snd_pcm_sw_params_current = falseblnr;
788
789LOCALFUNC blnr HaveMy_snd_pcm_sw_params_current(void)
790{
791 if (! Did_snd_pcm_sw_params_current) {
792 if (HaveAlsaLib()) {
793 My_snd_pcm_sw_params_current =
794 (snd_pcm_sw_params_current_ProcPtr)
795 dlsym(alsa_handle, "snd_pcm_sw_params_current");
796 if (NULL == My_snd_pcm_sw_params_current) {
797 fprintf(stderr,
798 "dlsym snd_pcm_sw_params_current failed\n");
799 }
800 }
801 Did_snd_pcm_sw_params_current = trueblnr;
802 }
803 return (My_snd_pcm_sw_params_current != NULL);
804}
805
806typedef int (*snd_pcm_sw_params_set_start_threshold_ProcPtr)
807 (My_snd_pcm_t *pcm, My_snd_pcm_sw_params_t *params,
808 My_snd_pcm_uframes_t val);
809LOCALVAR snd_pcm_sw_params_set_start_threshold_ProcPtr
810 My_snd_pcm_sw_params_set_start_threshold = NULL;
811LOCALVAR blnr Did_snd_pcm_sw_params_set_start_threshold = falseblnr;
812
813LOCALFUNC blnr HaveMy_snd_pcm_sw_params_set_start_threshold(void)
814{
815 if (! Did_snd_pcm_sw_params_set_start_threshold) {
816 if (HaveAlsaLib()) {
817 My_snd_pcm_sw_params_set_start_threshold =
818 (snd_pcm_sw_params_set_start_threshold_ProcPtr)
819 dlsym(alsa_handle,
820 "snd_pcm_sw_params_set_start_threshold");
821 if (NULL == My_snd_pcm_sw_params_set_start_threshold) {
822 fprintf(stderr,
823 "dlsym snd_pcm_sw_params_set_start_threshold"
824 " failed\n");
825 }
826 }
827 Did_snd_pcm_sw_params_set_start_threshold = trueblnr;
828 }
829 return (My_snd_pcm_sw_params_set_start_threshold != NULL);
830}
831
832typedef int (*snd_pcm_sw_params_set_avail_min_ProcPtr)
833 (My_snd_pcm_t *pcm, My_snd_pcm_sw_params_t *params,
834 My_snd_pcm_uframes_t val);
835LOCALVAR snd_pcm_sw_params_set_avail_min_ProcPtr
836 My_snd_pcm_sw_params_set_avail_min = NULL;
837LOCALVAR blnr Did_snd_pcm_sw_params_set_avail_min = falseblnr;
838
839LOCALFUNC blnr HaveMy_snd_pcm_sw_params_set_avail_min(void)
840{
841 if (! Did_snd_pcm_sw_params_set_avail_min) {
842 if (HaveAlsaLib()) {
843 My_snd_pcm_sw_params_set_avail_min =
844 (snd_pcm_sw_params_set_avail_min_ProcPtr)
845 dlsym(alsa_handle, "snd_pcm_sw_params_set_avail_min");
846 if (NULL == My_snd_pcm_sw_params_set_avail_min) {
847 fprintf(stderr,
848 "dlsym snd_pcm_sw_params_set_avail_min failed\n");
849 }
850 }
851 Did_snd_pcm_sw_params_set_avail_min = trueblnr;
852 }
853 return (My_snd_pcm_sw_params_set_avail_min != NULL);
854}
855
856typedef int (*snd_pcm_sw_params_set_xfer_align_ProcPtr)
857 (My_snd_pcm_t *pcm, My_snd_pcm_sw_params_t *params,
858 My_snd_pcm_uframes_t val);
859LOCALVAR snd_pcm_sw_params_set_xfer_align_ProcPtr
860 My_snd_pcm_sw_params_set_xfer_align = NULL;
861LOCALVAR blnr Did_snd_pcm_sw_params_set_xfer_align = falseblnr;
862
863LOCALFUNC blnr HaveMy_snd_pcm_sw_params_set_xfer_align(void)
864{
865 if (! Did_snd_pcm_sw_params_set_xfer_align) {
866 if (HaveAlsaLib()) {
867 My_snd_pcm_sw_params_set_xfer_align =
868 (snd_pcm_sw_params_set_xfer_align_ProcPtr)
869 dlsym(alsa_handle, "snd_pcm_sw_params_set_xfer_align");
870 if (NULL == My_snd_pcm_sw_params_set_xfer_align) {
871 fprintf(stderr,
872 "dlsym snd_pcm_sw_params_set_xfer_align failed\n");
873 }
874 }
875 Did_snd_pcm_sw_params_set_xfer_align = trueblnr;
876 }
877 return (My_snd_pcm_sw_params_set_xfer_align != NULL);
878}
879
880typedef int (*snd_pcm_sw_params_ProcPtr)
881 (My_snd_pcm_t *pcm, My_snd_pcm_sw_params_t *params);
882LOCALVAR snd_pcm_sw_params_ProcPtr My_snd_pcm_sw_params = NULL;
883LOCALVAR blnr Did_snd_pcm_sw_params = falseblnr;
884
885LOCALFUNC blnr HaveMy_snd_pcm_sw_params(void)
886{
887 if (! Did_snd_pcm_sw_params) {
888 if (HaveAlsaLib()) {
889 My_snd_pcm_sw_params = (snd_pcm_sw_params_ProcPtr)
890 dlsym(alsa_handle, "snd_pcm_sw_params");
891 if (NULL == My_snd_pcm_sw_params) {
892 fprintf(stderr, "dlsym snd_pcm_sw_params failed\n");
893 }
894 }
895 Did_snd_pcm_sw_params = trueblnr;
896 }
897 return (My_snd_pcm_sw_params != NULL);
898}
899
900typedef int (*snd_pcm_nonblock_ProcPtr)
901 (My_snd_pcm_t *pcm, int nonblock);
902LOCALVAR snd_pcm_nonblock_ProcPtr My_snd_pcm_nonblock = NULL;
903LOCALVAR blnr Did_snd_pcm_nonblock = falseblnr;
904
905LOCALFUNC blnr HaveMy_snd_pcm_nonblock(void)
906{
907 if (! Did_snd_pcm_nonblock) {
908 if (HaveAlsaLib()) {
909 My_snd_pcm_nonblock = (snd_pcm_nonblock_ProcPtr)
910 dlsym(alsa_handle, "snd_pcm_nonblock");
911 if (NULL == My_snd_pcm_nonblock) {
912 fprintf(stderr, "dlsym snd_pcm_nonblock failed\n");
913 }
914 }
915 Did_snd_pcm_nonblock = trueblnr;
916 }
917 return (My_snd_pcm_nonblock != NULL);
918}
919
920typedef My_snd_pcm_state_t (*snd_pcm_state_ProcPtr)(My_snd_pcm_t *pcm);
921LOCALVAR snd_pcm_state_ProcPtr My_snd_pcm_state = NULL;
922LOCALVAR blnr Did_snd_pcm_state = falseblnr;
923
924LOCALFUNC blnr HaveMy_snd_pcm_state(void)
925{
926 if (! Did_snd_pcm_state) {
927 if (HaveAlsaLib()) {
928 My_snd_pcm_state = (snd_pcm_state_ProcPtr)
929 dlsym(alsa_handle, "snd_pcm_state");
930 if (NULL == My_snd_pcm_state) {
931 fprintf(stderr, "dlsym snd_pcm_state failed\n");
932 }
933 }
934 Did_snd_pcm_state = trueblnr;
935 }
936 return (My_snd_pcm_state != NULL);
937}
938
939typedef int (*snd_pcm_prepare_ProcPtr)(My_snd_pcm_t *pcm);
940LOCALVAR snd_pcm_prepare_ProcPtr My_snd_pcm_prepare = NULL;
941LOCALVAR blnr Did_snd_pcm_prepare = falseblnr;
942
943LOCALFUNC blnr HaveMy_snd_pcm_prepare(void)
944{
945 if (! Did_snd_pcm_prepare) {
946 if (HaveAlsaLib()) {
947 My_snd_pcm_prepare = (snd_pcm_prepare_ProcPtr)
948 dlsym(alsa_handle, "snd_pcm_prepare");
949 if (NULL == My_snd_pcm_prepare) {
950 fprintf(stderr, "dlsym snd_pcm_prepare failed\n");
951 }
952 }
953 Did_snd_pcm_prepare = trueblnr;
954 }
955 return (My_snd_pcm_prepare != NULL);
956}
957
958typedef int (*snd_pcm_start_ProcPtr)(My_snd_pcm_t *pcm);
959LOCALVAR snd_pcm_start_ProcPtr My_snd_pcm_start = NULL;
960LOCALVAR blnr Did_snd_pcm_start = falseblnr;
961
962LOCALFUNC blnr HaveMy_snd_pcm_start(void)
963{
964 if (! Did_snd_pcm_start) {
965 if (HaveAlsaLib()) {
966 My_snd_pcm_start = (snd_pcm_start_ProcPtr)
967 dlsym(alsa_handle, "snd_pcm_start");
968 if (NULL == My_snd_pcm_start) {
969 fprintf(stderr, "dlsym snd_pcm_start failed\n");
970 }
971 }
972 Did_snd_pcm_start = trueblnr;
973 }
974 return (My_snd_pcm_start != NULL);
975}
976
977typedef int (*snd_pcm_resume_ProcPtr)(My_snd_pcm_t *pcm);
978LOCALVAR snd_pcm_resume_ProcPtr My_snd_pcm_resume = NULL;
979LOCALVAR blnr Did_snd_pcm_resume = falseblnr;
980
981LOCALFUNC blnr HaveMy_snd_pcm_resume(void)
982{
983 if (! Did_snd_pcm_resume) {
984 if (HaveAlsaLib()) {
985 My_snd_pcm_resume = (snd_pcm_resume_ProcPtr)
986 dlsym(alsa_handle, "snd_pcm_resume");
987 if (NULL == My_snd_pcm_resume) {
988 fprintf(stderr, "dlsym snd_pcm_resume failed\n");
989 }
990 }
991 Did_snd_pcm_resume = trueblnr;
992 }
993 return (My_snd_pcm_resume != NULL);
994}
995
996typedef My_snd_pcm_sframes_t (*snd_pcm_avail_update_ProcPtr)
997 (My_snd_pcm_t *pcm);
998LOCALVAR snd_pcm_avail_update_ProcPtr My_snd_pcm_avail_update = NULL;
999LOCALVAR blnr Did_snd_pcm_avail_update = falseblnr;
1000
1001LOCALFUNC blnr HaveMy_snd_pcm_avail_update(void)
1002{
1003 if (! Did_snd_pcm_avail_update) {
1004 if (HaveAlsaLib()) {
1005 My_snd_pcm_avail_update = (snd_pcm_avail_update_ProcPtr)
1006 dlsym(alsa_handle, "snd_pcm_avail_update");
1007 if (NULL == My_snd_pcm_avail_update) {
1008 fprintf(stderr, "dlsym snd_pcm_avail_update failed\n");
1009 }
1010 }
1011 Did_snd_pcm_avail_update = trueblnr;
1012 }
1013 return (My_snd_pcm_avail_update != NULL);
1014}
1015
1016typedef My_snd_pcm_sframes_t (*snd_pcm_writei_ProcPtr)
1017 (My_snd_pcm_t *pcm, const void *buffer, My_snd_pcm_uframes_t size);
1018LOCALVAR snd_pcm_writei_ProcPtr My_snd_pcm_writei = NULL;
1019LOCALVAR blnr Did_snd_pcm_writei = falseblnr;
1020
1021LOCALFUNC blnr HaveMy_snd_pcm_writei(void)
1022{
1023 if (! Did_snd_pcm_writei) {
1024 if (HaveAlsaLib()) {
1025 My_snd_pcm_writei = (snd_pcm_writei_ProcPtr)
1026 dlsym(alsa_handle, "snd_pcm_writei");
1027 if (NULL == My_snd_pcm_writei) {
1028 fprintf(stderr, "dlsym snd_pcm_writei failed\n");
1029 }
1030 }
1031 Did_snd_pcm_writei = trueblnr;
1032 }
1033 return (My_snd_pcm_writei != NULL);
1034}
1035
1036typedef int (*snd_pcm_drop_ProcPtr)(My_snd_pcm_t *pcm);
1037LOCALVAR snd_pcm_drop_ProcPtr My_snd_pcm_drop = NULL;
1038LOCALVAR blnr Did_snd_pcm_drop = falseblnr;
1039
1040LOCALFUNC blnr HaveMy_snd_pcm_drop(void)
1041{
1042 if (! Did_snd_pcm_drop) {
1043 if (HaveAlsaLib()) {
1044 My_snd_pcm_drop = (snd_pcm_drop_ProcPtr)
1045 dlsym(alsa_handle, "snd_pcm_drop");
1046 if (NULL == My_snd_pcm_drop) {
1047 fprintf(stderr, "dlsym snd_pcm_drop failed\n");
1048 }
1049 }
1050 Did_snd_pcm_drop = trueblnr;
1051 }
1052 return (My_snd_pcm_drop != NULL);
1053}
1054
1055#if RaspbianWorkAround
1056typedef int (*snd_pcm_status_malloc_ProcPtr)
1057 (My_snd_pcm_status_t **ptr);
1058LOCALVAR snd_pcm_status_malloc_ProcPtr My_snd_pcm_status_malloc = NULL;
1059LOCALVAR blnr Did_snd_pcm_status_malloc = falseblnr;
1060
1061LOCALFUNC blnr HaveMy_snd_pcm_status_malloc(void)
1062{
1063 if (! Did_snd_pcm_status_malloc) {
1064 if (HaveAlsaLib()) {
1065 My_snd_pcm_status_malloc = (snd_pcm_status_malloc_ProcPtr)
1066 dlsym(alsa_handle, "snd_pcm_status_malloc");
1067 if (NULL == My_snd_pcm_status_malloc) {
1068 fprintf(stderr, "dlsym snd_pcm_status_malloc failed\n");
1069 }
1070 }
1071 Did_snd_pcm_status_malloc = trueblnr;
1072 }
1073 return (My_snd_pcm_status_malloc != NULL);
1074}
1075#endif
1076
1077#if RaspbianWorkAround
1078typedef int (*snd_pcm_status_ProcPtr)(My_snd_pcm_t *pcm,
1079 My_snd_pcm_status_t *status);
1080LOCALVAR snd_pcm_status_ProcPtr My_snd_pcm_status = NULL;
1081LOCALVAR blnr Did_snd_pcm_status = falseblnr;
1082
1083LOCALFUNC blnr HaveMy_snd_pcm_status(void)
1084{
1085 if (! Did_snd_pcm_status) {
1086 if (HaveAlsaLib()) {
1087 My_snd_pcm_status = (snd_pcm_status_ProcPtr)
1088 dlsym(alsa_handle, "snd_pcm_status");
1089 if (NULL == My_snd_pcm_status) {
1090 fprintf(stderr, "dlsym snd_pcm_status failed\n");
1091 }
1092 }
1093 Did_snd_pcm_status = trueblnr;
1094 }
1095 return (My_snd_pcm_status != NULL);
1096}
1097#endif
1098
1099#if RaspbianWorkAround
1100typedef My_snd_pcm_uframes_t (*snd_pcm_status_get_avail_ProcPtr)
1101 (const My_snd_pcm_status_t *obj);
1102LOCALVAR snd_pcm_status_get_avail_ProcPtr
1103 My_snd_pcm_status_get_avail = NULL;
1104LOCALVAR blnr Did_snd_pcm_status_get_avail = falseblnr;
1105
1106LOCALFUNC blnr HaveMy_snd_pcm_status_get_avail(void)
1107{
1108 if (! Did_snd_pcm_status_get_avail) {
1109 if (HaveAlsaLib()) {
1110 My_snd_pcm_status_get_avail =
1111 (snd_pcm_status_get_avail_ProcPtr)
1112 dlsym(alsa_handle, "snd_pcm_status_get_avail");
1113 if (NULL == My_snd_pcm_status_get_avail) {
1114 fprintf(stderr,
1115 "dlsym snd_pcm_status_get_avail failed\n");
1116 }
1117 }
1118 Did_snd_pcm_status_get_avail = trueblnr;
1119 }
1120 return (My_snd_pcm_status_get_avail != NULL);
1121}
1122#endif
1123
1124typedef const char * (*snd_strerror_ProcPtr)(int errnum);
1125LOCALVAR snd_strerror_ProcPtr My_snd_strerror = NULL;
1126LOCALVAR blnr Did_snd_strerror = falseblnr;
1127
1128LOCALFUNC blnr HaveMy_snd_strerror(void)
1129{
1130 if (! Did_snd_strerror) {
1131 if (HaveAlsaLib()) {
1132 My_snd_strerror = (snd_strerror_ProcPtr)
1133 dlsym(alsa_handle, "snd_strerror");
1134 if (NULL == My_snd_strerror) {
1135 fprintf(stderr, "dlsym snd_strerror failed\n");
1136 }
1137 }
1138 Did_snd_strerror = trueblnr;
1139 }
1140 return (My_snd_strerror != NULL);
1141}
1142
1143#endif
1144
1145
1146/*
1147 The elaborate private buffer is mostly
1148 redundant since alsa has its own ring
1149 buffer. But using it keeps the code
1150 closer to the other ports. And anyway
1151 there is no guarantee just what size
1152 buffer you'll get from alsa.
1153*/
1154
1155
1156#if 4 == kLn2SoundSampSz
1157LOCALPROC ConvertSoundBlockToNative(tpSoundSamp p)
1158{
1159 int i;
1160
1161 for (i = kOneBuffLen; --i >= 0; ) {
1162 *p++ -= 0x8000;
1163 }
1164}
1165#else
1166#define ConvertSoundBlockToNative(p)
1167#endif
1168
1169#define desired_alsa_buffer_size kAllBuffLen
1170#define desired_alsa_period_size kOneBuffLen
1171
1172LOCALVAR char *alsadev_name = NULL;
1173
1174LOCALVAR My_snd_pcm_t *pcm_handle = NULL;
1175LOCALVAR My_snd_pcm_uframes_t buffer_size;
1176LOCALVAR My_snd_pcm_uframes_t period_size;
1177
1178
1179LOCALVAR blnr MySound_StartPend = falseblnr;
1180
1181#if RaspbianWorkAround
1182LOCALVAR My_snd_pcm_status_t *my_status = NULL;
1183
1184LOCALFUNC blnr HaveMyStatusAlloc(void)
1185{
1186 if (NULL == my_status) {
1187 if (HaveMy_snd_pcm_status_malloc())
1188 if (HaveMy_snd_pcm_status())
1189 if (HaveMy_snd_pcm_status_get_avail())
1190 {
1191 if (My_snd_pcm_status_malloc(&my_status) < 0) {
1192 my_status = NULL; /* just to make sure */
1193 } else {
1194 /* snd_pcm_status_free(my_status); */
1195 }
1196 }
1197 }
1198
1199 return NULL != my_status;
1200}
1201#endif
1202
1203LOCALPROC MySound_WriteOut(void)
1204{
1205 int retry_count = 32;
1206
1207label_retry:
1208 if (--retry_count > 0) {
1209 My_snd_pcm_sframes_t avail;
1210 int err;
1211 My_snd_pcm_state_t cur_state = My_snd_pcm_state(pcm_handle);
1212
1213 if (My_SND_PCM_STATE_PREPARED == cur_state) {
1214 if (! MySound_StartPend) {
1215 if (TheFillOffset - ThePlayOffset >= kAllBuffLen) {
1216 MySound_StartPend = trueblnr;
1217 }
1218 }
1219 if (MySound_StartPend) {
1220 cur_state = My_SND_PCM_STATE_RUNNING;
1221 }
1222 }
1223
1224 if (My_SND_PCM_STATE_RUNNING != cur_state) {
1225 switch (cur_state) {
1226 case My_SND_PCM_STATE_SETUP:
1227 case My_SND_PCM_STATE_XRUN:
1228 err = My_snd_pcm_prepare(pcm_handle);
1229 if (err < 0) {
1230 fprintf(stderr, "pcm prepare error: %s\n",
1231 My_snd_strerror(err));
1232 } else {
1233 /* fprintf(stderr, "prepare succeeded\n"); */
1234 goto label_retry;
1235 }
1236 break;
1237 case My_SND_PCM_STATE_SUSPENDED:
1238 err = My_snd_pcm_resume(pcm_handle);
1239 if (err < 0) {
1240 fprintf(stderr, "pcm resume error: %s\n",
1241 My_snd_strerror(err));
1242 } else {
1243 /* fprintf(stderr, "resume succeeded\n"); */
1244 goto label_retry;
1245 }
1246 break;
1247 case My_SND_PCM_STATE_DISCONNECTED:
1248 /* just abort ? */
1249 break;
1250 case My_SND_PCM_STATE_PREPARED:
1251 /* leave */
1252 break;
1253 default:
1254 fprintf(stderr, "unknown alsa pcm state\n");
1255 break;
1256 }
1257 } else if ((avail = My_snd_pcm_avail_update(pcm_handle)) < 0) {
1258 fprintf(stderr, "pcm update error: %s\n",
1259 My_snd_strerror(avail));
1260 } else {
1261 tpSoundSamp NextPlayPtr;
1262 ui4b PlayNowSize = 0;
1263 ui4b MaskedFillOffset = ThePlayOffset & kOneBuffMask;
1264
1265#if RaspbianWorkAround
1266 if ((avail > buffer_size) || (avail < 0)) {
1267 /*
1268 fprintf(stderr, "need avail workaround: %d\n",
1269 (int)avail);
1270 */
1271 /* work around bug observed in Raspbian */
1272 if (HaveMyStatusAlloc()) {
1273 if (My_snd_pcm_status(pcm_handle, my_status) >= 0) {
1274 avail = My_snd_pcm_status_get_avail(my_status);
1275 }
1276 }
1277 }
1278#endif
1279
1280 if (! MySound_StartPend) {
1281 My_snd_pcm_uframes_t used = buffer_size - avail;
1282 ui4b TotPendBuffs = used >> kLnOneBuffLen;
1283
1284 if (TotPendBuffs < MinFilledSoundBuffs) {
1285 MinFilledSoundBuffs = TotPendBuffs;
1286 }
1287 /* fprintf(stderr, "buffer used %d\n", (int)used); */
1288 }
1289
1290 if (MaskedFillOffset != 0) {
1291 /* take care of left overs */
1292 PlayNowSize = kOneBuffLen - MaskedFillOffset;
1293 NextPlayPtr =
1294 TheSoundBuffer + (ThePlayOffset & kAllBuffMask);
1295 } else if (0 !=
1296 ((TheFillOffset - ThePlayOffset) >> kLnOneBuffLen))
1297 {
1298 PlayNowSize = kOneBuffLen;
1299 NextPlayPtr =
1300 TheSoundBuffer + (ThePlayOffset & kAllBuffMask);
1301 } else {
1302 /* nothing to play now */
1303 }
1304
1305 if (PlayNowSize > avail) {
1306 /*
1307 This isn't supposed to be needed with nonblock
1308 mode. But in Ubuntu 7.04 running in Parallels,
1309 snd_pcm_writei seemed to block anyway.
1310 */
1311 PlayNowSize = avail;
1312 }
1313
1314 if (0 != PlayNowSize) {
1315 err = My_snd_pcm_writei(
1316 pcm_handle, NextPlayPtr, PlayNowSize);
1317 if (err < 0) {
1318 if ((- EAGAIN == err) || (- ESTRPIPE == err)) {
1319 /* buffer full, try again later */
1320 /* fprintf(stderr, "pcm write: EAGAIN\n"); */
1321 } else if (- EPIPE == err) {
1322 /* buffer seems to have emptied */
1323 /* fprintf(stderr, "pcm write emptied\n"); */
1324 goto label_retry;
1325 } else {
1326 fprintf(stderr, "pcm write error: %s\n",
1327 My_snd_strerror(err));
1328 }
1329 } else {
1330 ThePlayOffset += err;
1331 goto label_retry;
1332 }
1333 } else if (MySound_StartPend) {
1334 MySound_StartPend = falseblnr;
1335 if ((err = My_snd_pcm_start(pcm_handle)) < 0) {
1336 fprintf(stderr, "pcm start error: %s\n",
1337 My_snd_strerror(err));
1338 }
1339 }
1340 }
1341 }
1342}
1343
1344LOCALPROC MySound_Start(void)
1345{
1346 if (pcm_handle != NULL) {
1347 MySound_Start0();
1348 }
1349}
1350
1351LOCALPROC MySound_Stop(void)
1352{
1353 if (pcm_handle != NULL) {
1354 My_snd_pcm_drop(pcm_handle);
1355 }
1356}
1357
1358LOCALFUNC blnr HaveAlsaRoutines(void)
1359{
1360 blnr IsOk = falseblnr;
1361
1362 if (HaveMy_snd_pcm_open())
1363 if (HaveMy_snd_pcm_close())
1364 if (HaveMy_snd_pcm_hw_params_malloc())
1365 if (HaveMy_snd_pcm_hw_params_free())
1366 if (HaveMy_snd_pcm_hw_params_any())
1367 if (HaveMy_snd_pcm_hw_params_set_access())
1368 if (HaveMy_snd_pcm_hw_params_set_format())
1369 if (HaveMy_snd_pcm_hw_params_set_rate_near())
1370 if (HaveMy_snd_pcm_hw_params_set_channels())
1371 if (HaveMy_snd_pcm_hw_params_set_buffer_size_near())
1372 if (HaveMy_snd_pcm_hw_params_set_period_size_near())
1373 if (HaveMy_snd_pcm_hw_params())
1374 if (HaveMy_snd_pcm_sw_params_malloc())
1375 if (HaveMy_snd_pcm_sw_params_free())
1376 if (HaveMy_snd_pcm_sw_params_current())
1377 if (HaveMy_snd_pcm_sw_params_set_start_threshold())
1378 if (HaveMy_snd_pcm_sw_params_set_avail_min())
1379 if (HaveMy_snd_pcm_sw_params())
1380 if (HaveMy_snd_pcm_nonblock())
1381 if (HaveMy_snd_pcm_state())
1382 if (HaveMy_snd_pcm_prepare())
1383 if (HaveMy_snd_pcm_start())
1384 if (HaveMy_snd_pcm_resume())
1385 if (HaveMy_snd_pcm_avail_update())
1386 if (HaveMy_snd_pcm_writei())
1387 if (HaveMy_snd_pcm_drop())
1388 if (HaveMy_snd_strerror())
1389 {
1390 IsOk = trueblnr;
1391 }
1392
1393 return IsOk;
1394}
1395
1396#if 4 == kLn2SoundSampSz
1397#define MyDesiredFormat My_SND_PCM_FORMAT_S16
1398#else
1399#define MyDesiredFormat My_SND_PCM_FORMAT_U8
1400#endif
1401
1402LOCALPROC MySound_Init0(void)
1403{
1404 My_snd_pcm_hw_params_t *hw_params = NULL;
1405 My_snd_pcm_sw_params_t *sw_params = NULL;
1406 unsigned int rrate = SOUND_SAMPLERATE;
1407 int err;
1408
1409 buffer_size = desired_alsa_buffer_size;
1410 period_size = desired_alsa_period_size;
1411
1412 /* Open the sound device */
1413 if (NULL == alsadev_name) {
1414 alsadev_name = getenv("AUDIODEV");
1415 if (NULL == alsadev_name) {
1416 alsadev_name = strdup("default");
1417 }
1418 }
1419
1420 if ((err = My_snd_pcm_open(&pcm_handle, alsadev_name,
1421 My_SND_PCM_STREAM_PLAYBACK, My_SND_PCM_NONBLOCK)) < 0)
1422 {
1423 fprintf(stderr, "cannot open audio device %s (%s)\n",
1424 alsadev_name, My_snd_strerror(err));
1425 pcm_handle = NULL;
1426 } else
1427 /* Set some hardware parameters */
1428 if ((err = My_snd_pcm_hw_params_malloc(&hw_params)) < 0) {
1429 fprintf(stderr,
1430 "cannot allocate hardware parameter structure (%s)\n",
1431 My_snd_strerror(err));
1432 hw_params = NULL;
1433 } else
1434 if ((err = My_snd_pcm_hw_params_any(pcm_handle, hw_params)) < 0) {
1435 fprintf(stderr,
1436 "cannot initialize hardware parameter structure (%s)\n",
1437 My_snd_strerror(err));
1438 } else
1439 if ((err = My_snd_pcm_hw_params_set_access(pcm_handle,
1440 hw_params, My_SND_PCM_ACCESS_RW_INTERLEAVED)) < 0)
1441 {
1442 fprintf(stderr, "cannot set access type (%s)\n",
1443 My_snd_strerror(err));
1444 } else
1445 if ((err = My_snd_pcm_hw_params_set_format(pcm_handle,
1446 hw_params, MyDesiredFormat)) < 0)
1447 {
1448 fprintf(stderr, "cannot set sample format (%s)\n",
1449 My_snd_strerror(err));
1450 } else
1451 if ((err = My_snd_pcm_hw_params_set_rate_near(pcm_handle,
1452 hw_params, &rrate, NULL)) < 0)
1453 {
1454 fprintf(stderr, "cannot set sample rate (%s)\n",
1455 My_snd_strerror(err));
1456 } else
1457 if ((err = My_snd_pcm_hw_params_set_channels(pcm_handle,
1458 hw_params, 1)) < 0)
1459 {
1460 fprintf(stderr, "cannot set channel count (%s)\n",
1461 My_snd_strerror(err));
1462 } else
1463 if ((err = My_snd_pcm_hw_params_set_buffer_size_near(pcm_handle,
1464 hw_params, &buffer_size)) < 0)
1465 {
1466 fprintf(stderr, "cannot set buffer size count (%s)\n",
1467 My_snd_strerror(err));
1468 } else
1469 if ((err = My_snd_pcm_hw_params_set_period_size_near(pcm_handle,
1470 hw_params, &period_size, NULL)) < 0)
1471 {
1472 fprintf(stderr, "cannot set period size count (%s)\n",
1473 My_snd_strerror(err));
1474 } else
1475 if ((err = My_snd_pcm_hw_params(pcm_handle, hw_params)) < 0) {
1476 fprintf(stderr, "cannot set parameters (%s)\n",
1477 My_snd_strerror(err));
1478 } else
1479 {
1480 if (rrate != SOUND_SAMPLERATE) {
1481 fprintf(stderr, "Warning: sample rate is off by %i Hz\n",
1482 SOUND_SAMPLERATE - rrate);
1483 }
1484
1485#if 0
1486 if (buffer_size != desired_alsa_buffer_size) {
1487 fprintf(stderr,
1488 "Warning: buffer size is off,"
1489 " desired %li, actual %li\n",
1490 desired_alsa_buffer_size, buffer_size);
1491 }
1492
1493 if (period_size != desired_alsa_period_size) {
1494 fprintf(stderr,
1495 "Warning: period size is off,"
1496 " desired %li, actual %li\n",
1497 desired_alsa_period_size, period_size);
1498 }
1499#endif
1500
1501 My_snd_pcm_hw_params_free(hw_params);
1502 hw_params = NULL;
1503
1504 /* Set some software parameters */
1505 if ((err = My_snd_pcm_sw_params_malloc(&sw_params)) < 0) {
1506 fprintf(stderr,
1507 "cannot allocate software parameter structure (%s)\n",
1508 My_snd_strerror(err));
1509 sw_params = NULL;
1510 } else
1511 if ((err = My_snd_pcm_sw_params_current(pcm_handle,
1512 sw_params)) < 0)
1513 {
1514 fprintf(stderr,
1515 "Unable to determine current"
1516 " sw_params for playback: %s\n",
1517 My_snd_strerror(err));
1518 } else
1519 if ((err = My_snd_pcm_sw_params_set_start_threshold(pcm_handle,
1520 sw_params, 0x7FFFFFFF /* buffer_size - period_size */)) < 0)
1521 {
1522 fprintf(stderr,
1523 "Unable to set start threshold mode for playback: %s\n",
1524 My_snd_strerror(err));
1525 } else
1526#if 0
1527 if ((err = My_snd_pcm_sw_params_set_avail_min(pcm_handle,
1528 sw_params, period_size)) < 0)
1529 {
1530 fprintf(stderr,
1531 "Unable to set avail min for playback: %s\n",
1532 My_snd_strerror(err));
1533 } else
1534#endif
1535 /*
1536 snd_pcm_sw_params_set_xfer_align deprecated, but
1537 call if available. According to one report, bad results
1538 in old version of alsa lib if not called.
1539 */
1540 if (HaveMy_snd_pcm_sw_params_set_xfer_align()
1541 && ((err = My_snd_pcm_sw_params_set_xfer_align(pcm_handle,
1542 sw_params, 1)) < 0))
1543 {
1544 fprintf(stderr,
1545 "Unable to set transfer align for playback: %s\n",
1546 My_snd_strerror(err));
1547 } else
1548 if ((err = My_snd_pcm_sw_params(pcm_handle, sw_params)) < 0) {
1549 fprintf(stderr,
1550 "Unable to set sw params for playback: %s\n",
1551 My_snd_strerror(err));
1552 } else
1553 {
1554 My_snd_pcm_sw_params_free(sw_params);
1555 sw_params = NULL;
1556
1557 My_snd_pcm_nonblock(pcm_handle, 0);
1558
1559 goto label_done; /* success */
1560 }
1561 }
1562
1563 /* clean up after failure */
1564
1565 if (sw_params != NULL) {
1566 My_snd_pcm_sw_params_free(sw_params);
1567 }
1568 if (hw_params != NULL) {
1569 My_snd_pcm_hw_params_free(hw_params);
1570 }
1571 if (pcm_handle != NULL) {
1572 My_snd_pcm_close(pcm_handle);
1573 pcm_handle = NULL;
1574 }
1575
1576label_done:
1577 ;
1578}
1579
1580LOCALFUNC blnr MySound_Init(void)
1581{
1582 if (HaveAlsaRoutines()) {
1583 MySound_Init0();
1584 }
1585
1586 return trueblnr; /* keep going, even if no sound */
1587}
1588
1589LOCALPROC MySound_UnInit(void)
1590{
1591 if (NULL != pcm_handle) {
1592 if (HaveMy_snd_pcm_close()) {
1593 My_snd_pcm_close(pcm_handle);
1594 }
1595 pcm_handle = NULL;
1596 }
1597 MyCloseAlsaLib();
1598}
1599
1600GLOBALOSGLUPROC MySound_EndWrite(ui4r actL)
1601{
1602 if (MySound_EndWrite0(actL)) {
1603 ConvertSoundBlockToNative(TheSoundBuffer
1604 + ((TheFillOffset - kOneBuffLen) & kAllBuffMask));
1605 if (NULL != pcm_handle) {
1606 MySound_WriteOut();
1607 }
1608 }
1609}
1610
1611LOCALPROC MySound_SecondNotify(void)
1612{
1613 if (NULL != pcm_handle) {
1614 MySound_SecondNotify0();
1615 }
1616}
1617
1618#define UsingAlsa 1