1 /* |
|
2 * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. |
|
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 * |
|
5 * This code is free software; you can redistribute it and/or modify it |
|
6 * under the terms of the GNU General Public License version 2 only, as |
|
7 * published by the Free Software Foundation. Oracle designates this |
|
8 * particular file as subject to the "Classpath" exception as provided |
|
9 * by Oracle in the LICENSE file that accompanied this code. |
|
10 * |
|
11 * This code is distributed in the hope that it will be useful, but WITHOUT |
|
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
14 * version 2 for more details (a copy is included in the LICENSE file that |
|
15 * accompanied this code). |
|
16 * |
|
17 * You should have received a copy of the GNU General Public License version |
|
18 * 2 along with this work; if not, write to the Free Software Foundation, |
|
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
20 * |
|
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
22 * or visit www.oracle.com if you need additional information or have any |
|
23 * questions. |
|
24 */ |
|
25 |
|
26 #define USE_ERROR |
|
27 #define USE_TRACE |
|
28 |
|
29 #include "PLATFORM_API_BsdOS_ALSA_PCMUtils.h" |
|
30 #include "PLATFORM_API_BsdOS_ALSA_CommonUtils.h" |
|
31 #include "DirectAudio.h" |
|
32 |
|
33 #if USE_DAUDIO == TRUE |
|
34 |
|
35 // GetPosition method 1: based on how many bytes are passed to the kernel driver |
|
36 // + does not need much processor resources |
|
37 // - not very exact, "jumps" |
|
38 // GetPosition method 2: ask kernel about actual position of playback. |
|
39 // - very exact |
|
40 // - switch to kernel layer for each call |
|
41 // GetPosition method 3: use snd_pcm_avail() call - not yet in official ALSA |
|
42 // quick tests on a Pentium 200MMX showed max. 1.5% processor usage |
|
43 // for playing back a CD-quality file and printing 20x per second a line |
|
44 // on the console with the current time. So I guess performance is not such a |
|
45 // factor here. |
|
46 //#define GET_POSITION_METHOD1 |
|
47 #define GET_POSITION_METHOD2 |
|
48 |
|
49 |
|
50 // The default time for a period in microseconds. |
|
51 // For very small buffers, only 2 periods are used. |
|
52 #define DEFAULT_PERIOD_TIME 20000 /* 20ms */ |
|
53 |
|
54 ///// implemented functions of DirectAudio.h |
|
55 |
|
56 INT32 DAUDIO_GetDirectAudioDeviceCount() { |
|
57 return (INT32) getAudioDeviceCount(); |
|
58 } |
|
59 |
|
60 |
|
61 INT32 DAUDIO_GetDirectAudioDeviceDescription(INT32 mixerIndex, DirectAudioDeviceDescription* description) { |
|
62 ALSA_AudioDeviceDescription adesc; |
|
63 |
|
64 adesc.index = (int) mixerIndex; |
|
65 adesc.strLen = DAUDIO_STRING_LENGTH; |
|
66 |
|
67 adesc.maxSimultaneousLines = (int*) (&(description->maxSimulLines)); |
|
68 adesc.deviceID = &(description->deviceID); |
|
69 adesc.name = description->name; |
|
70 adesc.vendor = description->vendor; |
|
71 adesc.description = description->description; |
|
72 adesc.version = description->version; |
|
73 |
|
74 return getAudioDeviceDescriptionByIndex(&adesc); |
|
75 } |
|
76 |
|
77 #define MAX_BIT_INDEX 6 |
|
78 // returns |
|
79 // 6: for anything above 24-bit |
|
80 // 5: for 4 bytes sample size, 24-bit |
|
81 // 4: for 3 bytes sample size, 24-bit |
|
82 // 3: for 3 bytes sample size, 20-bit |
|
83 // 2: for 2 bytes sample size, 16-bit |
|
84 // 1: for 1 byte sample size, 8-bit |
|
85 // 0: for anything else |
|
86 int getBitIndex(int sampleSizeInBytes, int significantBits) { |
|
87 if (significantBits > 24) return 6; |
|
88 if (sampleSizeInBytes == 4 && significantBits == 24) return 5; |
|
89 if (sampleSizeInBytes == 3) { |
|
90 if (significantBits == 24) return 4; |
|
91 if (significantBits == 20) return 3; |
|
92 } |
|
93 if (sampleSizeInBytes == 2 && significantBits == 16) return 2; |
|
94 if (sampleSizeInBytes == 1 && significantBits == 8) return 1; |
|
95 return 0; |
|
96 } |
|
97 |
|
98 int getSampleSizeInBytes(int bitIndex, int sampleSizeInBytes) { |
|
99 switch(bitIndex) { |
|
100 case 1: return 1; |
|
101 case 2: return 2; |
|
102 case 3: /* fall through */ |
|
103 case 4: return 3; |
|
104 case 5: return 4; |
|
105 } |
|
106 return sampleSizeInBytes; |
|
107 } |
|
108 |
|
109 int getSignificantBits(int bitIndex, int significantBits) { |
|
110 switch(bitIndex) { |
|
111 case 1: return 8; |
|
112 case 2: return 16; |
|
113 case 3: return 20; |
|
114 case 4: /* fall through */ |
|
115 case 5: return 24; |
|
116 } |
|
117 return significantBits; |
|
118 } |
|
119 |
|
120 void DAUDIO_GetFormats(INT32 mixerIndex, INT32 deviceID, int isSource, void* creator) { |
|
121 snd_pcm_t* handle; |
|
122 snd_pcm_format_mask_t* formatMask; |
|
123 snd_pcm_format_t format; |
|
124 snd_pcm_hw_params_t* hwParams; |
|
125 int handledBits[MAX_BIT_INDEX+1]; |
|
126 |
|
127 int ret; |
|
128 int sampleSizeInBytes, significantBits, isSigned, isBigEndian, enc; |
|
129 int origSampleSizeInBytes, origSignificantBits; |
|
130 unsigned int channels, minChannels, maxChannels; |
|
131 int rate, bitIndex; |
|
132 |
|
133 for (bitIndex = 0; bitIndex <= MAX_BIT_INDEX; bitIndex++) handledBits[bitIndex] = FALSE; |
|
134 if (openPCMfromDeviceID(deviceID, &handle, isSource, TRUE /*query hardware*/) < 0) { |
|
135 return; |
|
136 } |
|
137 ret = snd_pcm_format_mask_malloc(&formatMask); |
|
138 if (ret != 0) { |
|
139 ERROR1("snd_pcm_format_mask_malloc returned error %d\n", ret); |
|
140 } else { |
|
141 ret = snd_pcm_hw_params_malloc(&hwParams); |
|
142 if (ret != 0) { |
|
143 ERROR1("snd_pcm_hw_params_malloc returned error %d\n", ret); |
|
144 } else { |
|
145 ret = snd_pcm_hw_params_any(handle, hwParams); |
|
146 /* snd_pcm_hw_params_any can return a positive value on success too */ |
|
147 if (ret < 0) { |
|
148 ERROR1("snd_pcm_hw_params_any returned error %d\n", ret); |
|
149 } else { |
|
150 /* for the logic following this code, set ret to 0 to indicate success */ |
|
151 ret = 0; |
|
152 } |
|
153 } |
|
154 snd_pcm_hw_params_get_format_mask(hwParams, formatMask); |
|
155 if (ret == 0) { |
|
156 ret = snd_pcm_hw_params_get_channels_min(hwParams, &minChannels); |
|
157 if (ret != 0) { |
|
158 ERROR1("snd_pcm_hw_params_get_channels_min returned error %d\n", ret); |
|
159 } |
|
160 } |
|
161 if (ret == 0) { |
|
162 ret = snd_pcm_hw_params_get_channels_max(hwParams, &maxChannels); |
|
163 if (ret != 0) { |
|
164 ERROR1("snd_pcm_hw_params_get_channels_max returned error %d\n", ret); |
|
165 } |
|
166 } |
|
167 |
|
168 // since we queried the hw: device, for many soundcards, it will only |
|
169 // report the maximum number of channels (which is the only way to talk |
|
170 // to the hw: device). Since we will, however, open the plughw: device |
|
171 // when opening the Source/TargetDataLine, we can safely assume that |
|
172 // also the channels 1..maxChannels are available. |
|
173 #ifdef ALSA_PCM_USE_PLUGHW |
|
174 minChannels = 1; |
|
175 #endif |
|
176 if (ret == 0) { |
|
177 // plughw: supports any sample rate |
|
178 rate = -1; |
|
179 for (format = 0; format <= SND_PCM_FORMAT_LAST; format++) { |
|
180 if (snd_pcm_format_mask_test(formatMask, format)) { |
|
181 // format exists |
|
182 if (getFormatFromAlsaFormat(format, &origSampleSizeInBytes, |
|
183 &origSignificantBits, |
|
184 &isSigned, &isBigEndian, &enc)) { |
|
185 // now if we use plughw:, we can use any bit size below the |
|
186 // natively supported ones. Some ALSA drivers only support the maximum |
|
187 // bit size, so we add any sample rates below the reported one. |
|
188 // E.g. this iteration reports support for 16-bit. |
|
189 // getBitIndex will return 2, so it will add entries for |
|
190 // 16-bit (bitIndex=2) and in the next do-while loop iteration, |
|
191 // it will decrease bitIndex and will therefore add 8-bit support. |
|
192 bitIndex = getBitIndex(origSampleSizeInBytes, origSignificantBits); |
|
193 do { |
|
194 if (bitIndex == 0 |
|
195 || bitIndex == MAX_BIT_INDEX |
|
196 || !handledBits[bitIndex]) { |
|
197 handledBits[bitIndex] = TRUE; |
|
198 sampleSizeInBytes = getSampleSizeInBytes(bitIndex, origSampleSizeInBytes); |
|
199 significantBits = getSignificantBits(bitIndex, origSignificantBits); |
|
200 if (maxChannels - minChannels > MAXIMUM_LISTED_CHANNELS) { |
|
201 // avoid too many channels explicitly listed |
|
202 // just add -1, min, and max |
|
203 DAUDIO_AddAudioFormat(creator, significantBits, |
|
204 -1, -1, rate, |
|
205 enc, isSigned, isBigEndian); |
|
206 DAUDIO_AddAudioFormat(creator, significantBits, |
|
207 sampleSizeInBytes * minChannels, |
|
208 minChannels, rate, |
|
209 enc, isSigned, isBigEndian); |
|
210 DAUDIO_AddAudioFormat(creator, significantBits, |
|
211 sampleSizeInBytes * maxChannels, |
|
212 maxChannels, rate, |
|
213 enc, isSigned, isBigEndian); |
|
214 } else { |
|
215 for (channels = minChannels; channels <= maxChannels; channels++) { |
|
216 DAUDIO_AddAudioFormat(creator, significantBits, |
|
217 sampleSizeInBytes * channels, |
|
218 channels, rate, |
|
219 enc, isSigned, isBigEndian); |
|
220 } |
|
221 } |
|
222 } |
|
223 #ifndef ALSA_PCM_USE_PLUGHW |
|
224 // without plugin, do not add fake formats |
|
225 break; |
|
226 #endif |
|
227 } while (--bitIndex > 0); |
|
228 } else { |
|
229 TRACE1("could not get format from alsa for format %d\n", format); |
|
230 } |
|
231 } else { |
|
232 //TRACE1("Format %d not supported\n", format); |
|
233 } |
|
234 } // for loop |
|
235 snd_pcm_hw_params_free(hwParams); |
|
236 } |
|
237 snd_pcm_format_mask_free(formatMask); |
|
238 } |
|
239 snd_pcm_close(handle); |
|
240 } |
|
241 |
|
242 /** Workaround for cr 7033899, 7030629: |
|
243 * dmix plugin doesn't like flush (snd_pcm_drop) when the buffer is empty |
|
244 * (just opened, underruned or already flushed). |
|
245 * Sometimes it causes PCM falls to -EBADFD error, |
|
246 * sometimes causes bufferSize change. |
|
247 * To prevent unnecessary flushes AlsaPcmInfo::isRunning & isFlushed are used. |
|
248 */ |
|
249 /* ******* ALSA PCM INFO ******************** */ |
|
250 typedef struct tag_AlsaPcmInfo { |
|
251 snd_pcm_t* handle; |
|
252 snd_pcm_hw_params_t* hwParams; |
|
253 snd_pcm_sw_params_t* swParams; |
|
254 int bufferSizeInBytes; |
|
255 int frameSize; // storage size in Bytes |
|
256 unsigned int periods; |
|
257 snd_pcm_uframes_t periodSize; |
|
258 short int isRunning; // see comment above |
|
259 short int isFlushed; // see comment above |
|
260 #ifdef GET_POSITION_METHOD2 |
|
261 // to be used exclusively by getBytePosition! |
|
262 snd_pcm_status_t* positionStatus; |
|
263 #endif |
|
264 } AlsaPcmInfo; |
|
265 |
|
266 |
|
267 int setStartThresholdNoCommit(AlsaPcmInfo* info, int useThreshold) { |
|
268 int ret; |
|
269 int threshold; |
|
270 |
|
271 if (useThreshold) { |
|
272 // start device whenever anything is written to the buffer |
|
273 threshold = 1; |
|
274 } else { |
|
275 // never start the device automatically |
|
276 threshold = 2000000000; /* near UINT_MAX */ |
|
277 } |
|
278 ret = snd_pcm_sw_params_set_start_threshold(info->handle, info->swParams, threshold); |
|
279 if (ret < 0) { |
|
280 ERROR1("Unable to set start threshold mode: %s\n", snd_strerror(ret)); |
|
281 return FALSE; |
|
282 } |
|
283 return TRUE; |
|
284 } |
|
285 |
|
286 int setStartThreshold(AlsaPcmInfo* info, int useThreshold) { |
|
287 int ret = 0; |
|
288 |
|
289 if (!setStartThresholdNoCommit(info, useThreshold)) { |
|
290 ret = -1; |
|
291 } |
|
292 if (ret == 0) { |
|
293 // commit it |
|
294 ret = snd_pcm_sw_params(info->handle, info->swParams); |
|
295 if (ret < 0) { |
|
296 ERROR1("Unable to set sw params: %s\n", snd_strerror(ret)); |
|
297 } |
|
298 } |
|
299 return (ret == 0)?TRUE:FALSE; |
|
300 } |
|
301 |
|
302 |
|
303 // returns TRUE if successful |
|
304 int setHWParams(AlsaPcmInfo* info, |
|
305 float sampleRate, |
|
306 int channels, |
|
307 int bufferSizeInFrames, |
|
308 snd_pcm_format_t format) { |
|
309 unsigned int rrate, periodTime, periods; |
|
310 int ret, dir; |
|
311 snd_pcm_uframes_t alsaBufferSizeInFrames = (snd_pcm_uframes_t) bufferSizeInFrames; |
|
312 |
|
313 /* choose all parameters */ |
|
314 ret = snd_pcm_hw_params_any(info->handle, info->hwParams); |
|
315 if (ret < 0) { |
|
316 ERROR1("Broken configuration: no configurations available: %s\n", snd_strerror(ret)); |
|
317 return FALSE; |
|
318 } |
|
319 /* set the interleaved read/write format */ |
|
320 ret = snd_pcm_hw_params_set_access(info->handle, info->hwParams, SND_PCM_ACCESS_RW_INTERLEAVED); |
|
321 if (ret < 0) { |
|
322 ERROR1("SND_PCM_ACCESS_RW_INTERLEAVED access type not available: %s\n", snd_strerror(ret)); |
|
323 return FALSE; |
|
324 } |
|
325 /* set the sample format */ |
|
326 ret = snd_pcm_hw_params_set_format(info->handle, info->hwParams, format); |
|
327 if (ret < 0) { |
|
328 ERROR1("Sample format not available: %s\n", snd_strerror(ret)); |
|
329 return FALSE; |
|
330 } |
|
331 /* set the count of channels */ |
|
332 ret = snd_pcm_hw_params_set_channels(info->handle, info->hwParams, channels); |
|
333 if (ret < 0) { |
|
334 ERROR2("Channels count (%d) not available: %s\n", channels, snd_strerror(ret)); |
|
335 return FALSE; |
|
336 } |
|
337 /* set the stream rate */ |
|
338 rrate = (int) (sampleRate + 0.5f); |
|
339 dir = 0; |
|
340 ret = snd_pcm_hw_params_set_rate_near(info->handle, info->hwParams, &rrate, &dir); |
|
341 if (ret < 0) { |
|
342 ERROR2("Rate %dHz not available for playback: %s\n", (int) (sampleRate+0.5f), snd_strerror(ret)); |
|
343 return FALSE; |
|
344 } |
|
345 if ((rrate-sampleRate > 2) || (rrate-sampleRate < - 2)) { |
|
346 ERROR2("Rate doesn't match (requested %2.2fHz, got %dHz)\n", sampleRate, rrate); |
|
347 return FALSE; |
|
348 } |
|
349 /* set the buffer time */ |
|
350 ret = snd_pcm_hw_params_set_buffer_size_near(info->handle, info->hwParams, &alsaBufferSizeInFrames); |
|
351 if (ret < 0) { |
|
352 ERROR2("Unable to set buffer size to %d frames: %s\n", |
|
353 (int) alsaBufferSizeInFrames, snd_strerror(ret)); |
|
354 return FALSE; |
|
355 } |
|
356 bufferSizeInFrames = (int) alsaBufferSizeInFrames; |
|
357 /* set the period time */ |
|
358 if (bufferSizeInFrames > 1024) { |
|
359 dir = 0; |
|
360 periodTime = DEFAULT_PERIOD_TIME; |
|
361 ret = snd_pcm_hw_params_set_period_time_near(info->handle, info->hwParams, &periodTime, &dir); |
|
362 if (ret < 0) { |
|
363 ERROR2("Unable to set period time to %d: %s\n", DEFAULT_PERIOD_TIME, snd_strerror(ret)); |
|
364 return FALSE; |
|
365 } |
|
366 } else { |
|
367 /* set the period count for very small buffer sizes to 2 */ |
|
368 dir = 0; |
|
369 periods = 2; |
|
370 ret = snd_pcm_hw_params_set_periods_near(info->handle, info->hwParams, &periods, &dir); |
|
371 if (ret < 0) { |
|
372 ERROR2("Unable to set period count to %d: %s\n", /*periods*/ 2, snd_strerror(ret)); |
|
373 return FALSE; |
|
374 } |
|
375 } |
|
376 /* write the parameters to device */ |
|
377 ret = snd_pcm_hw_params(info->handle, info->hwParams); |
|
378 if (ret < 0) { |
|
379 ERROR1("Unable to set hw params: %s\n", snd_strerror(ret)); |
|
380 return FALSE; |
|
381 } |
|
382 return TRUE; |
|
383 } |
|
384 |
|
385 // returns 1 if successful |
|
386 int setSWParams(AlsaPcmInfo* info) { |
|
387 int ret; |
|
388 |
|
389 /* get the current swparams */ |
|
390 ret = snd_pcm_sw_params_current(info->handle, info->swParams); |
|
391 if (ret < 0) { |
|
392 ERROR1("Unable to determine current swparams: %s\n", snd_strerror(ret)); |
|
393 return FALSE; |
|
394 } |
|
395 /* never start the transfer automatically */ |
|
396 if (!setStartThresholdNoCommit(info, FALSE /* don't use threshold */)) { |
|
397 return FALSE; |
|
398 } |
|
399 |
|
400 /* allow the transfer when at least period_size samples can be processed */ |
|
401 ret = snd_pcm_sw_params_set_avail_min(info->handle, info->swParams, info->periodSize); |
|
402 if (ret < 0) { |
|
403 ERROR1("Unable to set avail min for playback: %s\n", snd_strerror(ret)); |
|
404 return FALSE; |
|
405 } |
|
406 /* write the parameters to the playback device */ |
|
407 ret = snd_pcm_sw_params(info->handle, info->swParams); |
|
408 if (ret < 0) { |
|
409 ERROR1("Unable to set sw params: %s\n", snd_strerror(ret)); |
|
410 return FALSE; |
|
411 } |
|
412 return TRUE; |
|
413 } |
|
414 |
|
415 static snd_output_t* ALSA_OUTPUT = NULL; |
|
416 |
|
417 void* DAUDIO_Open(INT32 mixerIndex, INT32 deviceID, int isSource, |
|
418 int encoding, float sampleRate, int sampleSizeInBits, |
|
419 int frameSize, int channels, |
|
420 int isSigned, int isBigEndian, int bufferSizeInBytes) { |
|
421 snd_pcm_format_mask_t* formatMask; |
|
422 snd_pcm_format_t format; |
|
423 int dir; |
|
424 int ret = 0; |
|
425 AlsaPcmInfo* info = NULL; |
|
426 /* snd_pcm_uframes_t is 64 bit on 64-bit systems */ |
|
427 snd_pcm_uframes_t alsaBufferSizeInFrames = 0; |
|
428 |
|
429 |
|
430 TRACE0("> DAUDIO_Open\n"); |
|
431 #ifdef USE_TRACE |
|
432 // for using ALSA debug dump methods |
|
433 if (ALSA_OUTPUT == NULL) { |
|
434 snd_output_stdio_attach(&ALSA_OUTPUT, stdout, 0); |
|
435 } |
|
436 #endif |
|
437 if (channels <= 0) { |
|
438 ERROR1("ERROR: Invalid number of channels=%d!\n", channels); |
|
439 return NULL; |
|
440 } |
|
441 info = (AlsaPcmInfo*) malloc(sizeof(AlsaPcmInfo)); |
|
442 if (!info) { |
|
443 ERROR0("Out of memory\n"); |
|
444 return NULL; |
|
445 } |
|
446 memset(info, 0, sizeof(AlsaPcmInfo)); |
|
447 // initial values are: stopped, flushed |
|
448 info->isRunning = 0; |
|
449 info->isFlushed = 1; |
|
450 |
|
451 ret = openPCMfromDeviceID(deviceID, &(info->handle), isSource, FALSE /* do open device*/); |
|
452 if (ret == 0) { |
|
453 // set to blocking mode |
|
454 snd_pcm_nonblock(info->handle, 0); |
|
455 ret = snd_pcm_hw_params_malloc(&(info->hwParams)); |
|
456 if (ret != 0) { |
|
457 ERROR1(" snd_pcm_hw_params_malloc returned error %d\n", ret); |
|
458 } else { |
|
459 ret = -1; |
|
460 if (getAlsaFormatFromFormat(&format, frameSize / channels, sampleSizeInBits, |
|
461 isSigned, isBigEndian, encoding)) { |
|
462 if (setHWParams(info, |
|
463 sampleRate, |
|
464 channels, |
|
465 bufferSizeInBytes / frameSize, |
|
466 format)) { |
|
467 info->frameSize = frameSize; |
|
468 ret = snd_pcm_hw_params_get_period_size(info->hwParams, &info->periodSize, &dir); |
|
469 if (ret < 0) { |
|
470 ERROR1("ERROR: snd_pcm_hw_params_get_period: %s\n", snd_strerror(ret)); |
|
471 } |
|
472 snd_pcm_hw_params_get_periods(info->hwParams, &(info->periods), &dir); |
|
473 snd_pcm_hw_params_get_buffer_size(info->hwParams, &alsaBufferSizeInFrames); |
|
474 info->bufferSizeInBytes = (int) alsaBufferSizeInFrames * frameSize; |
|
475 TRACE3(" DAUDIO_Open: period size = %d frames, periods = %d. Buffer size: %d bytes.\n", |
|
476 (int) info->periodSize, info->periods, info->bufferSizeInBytes); |
|
477 } |
|
478 } |
|
479 } |
|
480 if (ret == 0) { |
|
481 // set software parameters |
|
482 ret = snd_pcm_sw_params_malloc(&(info->swParams)); |
|
483 if (ret != 0) { |
|
484 ERROR1("snd_pcm_hw_params_malloc returned error %d\n", ret); |
|
485 } else { |
|
486 if (!setSWParams(info)) { |
|
487 ret = -1; |
|
488 } |
|
489 } |
|
490 } |
|
491 if (ret == 0) { |
|
492 // prepare device |
|
493 ret = snd_pcm_prepare(info->handle); |
|
494 if (ret < 0) { |
|
495 ERROR1("ERROR: snd_pcm_prepare: %s\n", snd_strerror(ret)); |
|
496 } |
|
497 } |
|
498 |
|
499 #ifdef GET_POSITION_METHOD2 |
|
500 if (ret == 0) { |
|
501 ret = snd_pcm_status_malloc(&(info->positionStatus)); |
|
502 if (ret != 0) { |
|
503 ERROR1("ERROR in snd_pcm_status_malloc: %s\n", snd_strerror(ret)); |
|
504 } |
|
505 } |
|
506 #endif |
|
507 } |
|
508 if (ret != 0) { |
|
509 DAUDIO_Close((void*) info, isSource); |
|
510 info = NULL; |
|
511 } else { |
|
512 // set to non-blocking mode |
|
513 snd_pcm_nonblock(info->handle, 1); |
|
514 TRACE1("< DAUDIO_Open: Opened device successfully. Handle=%p\n", |
|
515 (void*) info->handle); |
|
516 } |
|
517 return (void*) info; |
|
518 } |
|
519 |
|
520 #ifdef USE_TRACE |
|
521 void printState(snd_pcm_state_t state) { |
|
522 if (state == SND_PCM_STATE_OPEN) { |
|
523 TRACE0("State: SND_PCM_STATE_OPEN\n"); |
|
524 } |
|
525 else if (state == SND_PCM_STATE_SETUP) { |
|
526 TRACE0("State: SND_PCM_STATE_SETUP\n"); |
|
527 } |
|
528 else if (state == SND_PCM_STATE_PREPARED) { |
|
529 TRACE0("State: SND_PCM_STATE_PREPARED\n"); |
|
530 } |
|
531 else if (state == SND_PCM_STATE_RUNNING) { |
|
532 TRACE0("State: SND_PCM_STATE_RUNNING\n"); |
|
533 } |
|
534 else if (state == SND_PCM_STATE_XRUN) { |
|
535 TRACE0("State: SND_PCM_STATE_XRUN\n"); |
|
536 } |
|
537 else if (state == SND_PCM_STATE_DRAINING) { |
|
538 TRACE0("State: SND_PCM_STATE_DRAINING\n"); |
|
539 } |
|
540 else if (state == SND_PCM_STATE_PAUSED) { |
|
541 TRACE0("State: SND_PCM_STATE_PAUSED\n"); |
|
542 } |
|
543 else if (state == SND_PCM_STATE_SUSPENDED) { |
|
544 TRACE0("State: SND_PCM_STATE_SUSPENDED\n"); |
|
545 } |
|
546 } |
|
547 #endif |
|
548 |
|
549 int DAUDIO_Start(void* id, int isSource) { |
|
550 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
551 int ret; |
|
552 snd_pcm_state_t state; |
|
553 |
|
554 TRACE0("> DAUDIO_Start\n"); |
|
555 // set to blocking mode |
|
556 snd_pcm_nonblock(info->handle, 0); |
|
557 // set start mode so that it always starts as soon as data is there |
|
558 setStartThreshold(info, TRUE /* use threshold */); |
|
559 state = snd_pcm_state(info->handle); |
|
560 if (state == SND_PCM_STATE_PAUSED) { |
|
561 // in case it was stopped previously |
|
562 TRACE0(" Un-pausing...\n"); |
|
563 ret = snd_pcm_pause(info->handle, FALSE); |
|
564 if (ret != 0) { |
|
565 ERROR2(" NOTE: error in snd_pcm_pause:%d: %s\n", ret, snd_strerror(ret)); |
|
566 } |
|
567 } |
|
568 if (state == SND_PCM_STATE_SUSPENDED) { |
|
569 TRACE0(" Resuming...\n"); |
|
570 ret = snd_pcm_resume(info->handle); |
|
571 if (ret < 0) { |
|
572 if ((ret != -EAGAIN) && (ret != -ENOSYS)) { |
|
573 ERROR2(" ERROR: error in snd_pcm_resume:%d: %s\n", ret, snd_strerror(ret)); |
|
574 } |
|
575 } |
|
576 } |
|
577 if (state == SND_PCM_STATE_SETUP) { |
|
578 TRACE0("need to call prepare again...\n"); |
|
579 // prepare device |
|
580 ret = snd_pcm_prepare(info->handle); |
|
581 if (ret < 0) { |
|
582 ERROR1("ERROR: snd_pcm_prepare: %s\n", snd_strerror(ret)); |
|
583 } |
|
584 } |
|
585 // in case there is still data in the buffers |
|
586 ret = snd_pcm_start(info->handle); |
|
587 if (ret != 0) { |
|
588 if (ret != -EPIPE) { |
|
589 ERROR2(" NOTE: error in snd_pcm_start: %d: %s\n", ret, snd_strerror(ret)); |
|
590 } |
|
591 } |
|
592 // set to non-blocking mode |
|
593 ret = snd_pcm_nonblock(info->handle, 1); |
|
594 if (ret != 0) { |
|
595 ERROR1(" ERROR in snd_pcm_nonblock: %s\n", snd_strerror(ret)); |
|
596 } |
|
597 state = snd_pcm_state(info->handle); |
|
598 #ifdef USE_TRACE |
|
599 printState(state); |
|
600 #endif |
|
601 ret = (state == SND_PCM_STATE_PREPARED) |
|
602 || (state == SND_PCM_STATE_RUNNING) |
|
603 || (state == SND_PCM_STATE_XRUN) |
|
604 || (state == SND_PCM_STATE_SUSPENDED); |
|
605 if (ret) { |
|
606 info->isRunning = 1; |
|
607 // source line should keep isFlushed value until Write() is called; |
|
608 // for target data line reset it right now. |
|
609 if (!isSource) { |
|
610 info->isFlushed = 0; |
|
611 } |
|
612 } |
|
613 TRACE1("< DAUDIO_Start %s\n", ret?"success":"error"); |
|
614 return ret?TRUE:FALSE; |
|
615 } |
|
616 |
|
617 int DAUDIO_Stop(void* id, int isSource) { |
|
618 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
619 int ret; |
|
620 |
|
621 TRACE0("> DAUDIO_Stop\n"); |
|
622 // set to blocking mode |
|
623 snd_pcm_nonblock(info->handle, 0); |
|
624 setStartThreshold(info, FALSE /* don't use threshold */); // device will not start after buffer xrun |
|
625 ret = snd_pcm_pause(info->handle, 1); |
|
626 // set to non-blocking mode |
|
627 snd_pcm_nonblock(info->handle, 1); |
|
628 if (ret != 0) { |
|
629 ERROR1("ERROR in snd_pcm_pause: %s\n", snd_strerror(ret)); |
|
630 return FALSE; |
|
631 } |
|
632 info->isRunning = 0; |
|
633 TRACE0("< DAUDIO_Stop success\n"); |
|
634 return TRUE; |
|
635 } |
|
636 |
|
637 void DAUDIO_Close(void* id, int isSource) { |
|
638 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
639 |
|
640 TRACE0("DAUDIO_Close\n"); |
|
641 if (info != NULL) { |
|
642 if (info->handle != NULL) { |
|
643 snd_pcm_close(info->handle); |
|
644 } |
|
645 if (info->hwParams) { |
|
646 snd_pcm_hw_params_free(info->hwParams); |
|
647 } |
|
648 if (info->swParams) { |
|
649 snd_pcm_sw_params_free(info->swParams); |
|
650 } |
|
651 #ifdef GET_POSITION_METHOD2 |
|
652 if (info->positionStatus) { |
|
653 snd_pcm_status_free(info->positionStatus); |
|
654 } |
|
655 #endif |
|
656 free(info); |
|
657 } |
|
658 } |
|
659 |
|
660 /* |
|
661 * Underrun and suspend recovery |
|
662 * returns |
|
663 * 0: exit native and return 0 |
|
664 * 1: try again to write/read |
|
665 * -1: error - exit native with return value -1 |
|
666 */ |
|
667 int xrun_recovery(AlsaPcmInfo* info, int err) { |
|
668 int ret; |
|
669 |
|
670 if (err == -EPIPE) { /* underrun / overflow */ |
|
671 TRACE0("xrun_recovery: underrun/overflow.\n"); |
|
672 ret = snd_pcm_prepare(info->handle); |
|
673 if (ret < 0) { |
|
674 ERROR1("Can't recover from underrun/overflow, prepare failed: %s\n", snd_strerror(ret)); |
|
675 return -1; |
|
676 } |
|
677 return 1; |
|
678 } else if (err == -ESTRPIPE) { |
|
679 TRACE0("xrun_recovery: suspended.\n"); |
|
680 ret = snd_pcm_resume(info->handle); |
|
681 if (ret < 0) { |
|
682 if (ret == -EAGAIN) { |
|
683 return 0; /* wait until the suspend flag is released */ |
|
684 } |
|
685 return -1; |
|
686 } |
|
687 ret = snd_pcm_prepare(info->handle); |
|
688 if (ret < 0) { |
|
689 ERROR1("Can't recover from underrun/overflow, prepare failed: %s\n", snd_strerror(ret)); |
|
690 return -1; |
|
691 } |
|
692 return 1; |
|
693 } else if (err == -EAGAIN) { |
|
694 TRACE0("xrun_recovery: EAGAIN try again flag.\n"); |
|
695 return 0; |
|
696 } |
|
697 |
|
698 TRACE2("xrun_recovery: unexpected error %d: %s\n", err, snd_strerror(err)); |
|
699 return -1; |
|
700 } |
|
701 |
|
702 // returns -1 on error |
|
703 int DAUDIO_Write(void* id, char* data, int byteSize) { |
|
704 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
705 int ret, count; |
|
706 snd_pcm_sframes_t frameSize, writtenFrames; |
|
707 |
|
708 TRACE1("> DAUDIO_Write %d bytes\n", byteSize); |
|
709 |
|
710 /* sanity */ |
|
711 if (byteSize <= 0 || info->frameSize <= 0) { |
|
712 ERROR2(" DAUDIO_Write: byteSize=%d, frameSize=%d!\n", |
|
713 (int) byteSize, (int) info->frameSize); |
|
714 TRACE0("< DAUDIO_Write returning -1\n"); |
|
715 return -1; |
|
716 } |
|
717 |
|
718 count = 2; // maximum number of trials to recover from underrun |
|
719 //frameSize = snd_pcm_bytes_to_frames(info->handle, byteSize); |
|
720 frameSize = (snd_pcm_sframes_t) (byteSize / info->frameSize); |
|
721 do { |
|
722 writtenFrames = snd_pcm_writei(info->handle, (const void*) data, (snd_pcm_uframes_t) frameSize); |
|
723 |
|
724 if (writtenFrames < 0) { |
|
725 ret = xrun_recovery(info, (int) writtenFrames); |
|
726 if (ret <= 0) { |
|
727 TRACE1("DAUDIO_Write: xrun recovery returned %d -> return.\n", ret); |
|
728 return ret; |
|
729 } |
|
730 if (count-- <= 0) { |
|
731 ERROR0("DAUDIO_Write: too many attempts to recover from xrun/suspend\n"); |
|
732 return -1; |
|
733 } |
|
734 } else { |
|
735 break; |
|
736 } |
|
737 } while (TRUE); |
|
738 //ret = snd_pcm_frames_to_bytes(info->handle, writtenFrames); |
|
739 |
|
740 if (writtenFrames > 0) { |
|
741 // reset "flushed" flag |
|
742 info->isFlushed = 0; |
|
743 } |
|
744 |
|
745 ret = (int) (writtenFrames * info->frameSize); |
|
746 TRACE1("< DAUDIO_Write: returning %d bytes.\n", ret); |
|
747 return ret; |
|
748 } |
|
749 |
|
750 // returns -1 on error |
|
751 int DAUDIO_Read(void* id, char* data, int byteSize) { |
|
752 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
753 int ret, count; |
|
754 snd_pcm_sframes_t frameSize, readFrames; |
|
755 |
|
756 TRACE1("> DAUDIO_Read %d bytes\n", byteSize); |
|
757 /*TRACE3(" info=%p, data=%p, byteSize=%d\n", |
|
758 (void*) info, (void*) data, (int) byteSize); |
|
759 TRACE2(" info->frameSize=%d, info->handle=%p\n", |
|
760 (int) info->frameSize, (void*) info->handle); |
|
761 */ |
|
762 /* sanity */ |
|
763 if (byteSize <= 0 || info->frameSize <= 0) { |
|
764 ERROR2(" DAUDIO_Read: byteSize=%d, frameSize=%d!\n", |
|
765 (int) byteSize, (int) info->frameSize); |
|
766 TRACE0("< DAUDIO_Read returning -1\n"); |
|
767 return -1; |
|
768 } |
|
769 if (!info->isRunning && info->isFlushed) { |
|
770 // PCM has nothing to read |
|
771 return 0; |
|
772 } |
|
773 |
|
774 count = 2; // maximum number of trials to recover from error |
|
775 //frameSize = snd_pcm_bytes_to_frames(info->handle, byteSize); |
|
776 frameSize = (snd_pcm_sframes_t) (byteSize / info->frameSize); |
|
777 do { |
|
778 readFrames = snd_pcm_readi(info->handle, (void*) data, (snd_pcm_uframes_t) frameSize); |
|
779 if (readFrames < 0) { |
|
780 ret = xrun_recovery(info, (int) readFrames); |
|
781 if (ret <= 0) { |
|
782 TRACE1("DAUDIO_Read: xrun recovery returned %d -> return.\n", ret); |
|
783 return ret; |
|
784 } |
|
785 if (count-- <= 0) { |
|
786 ERROR0("DAUDIO_Read: too many attempts to recover from xrun/suspend\n"); |
|
787 return -1; |
|
788 } |
|
789 } else { |
|
790 break; |
|
791 } |
|
792 } while (TRUE); |
|
793 //ret = snd_pcm_frames_to_bytes(info->handle, readFrames); |
|
794 ret = (int) (readFrames * info->frameSize); |
|
795 TRACE1("< DAUDIO_Read: returning %d bytes.\n", ret); |
|
796 return ret; |
|
797 } |
|
798 |
|
799 |
|
800 int DAUDIO_GetBufferSize(void* id, int isSource) { |
|
801 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
802 |
|
803 return info->bufferSizeInBytes; |
|
804 } |
|
805 |
|
806 int DAUDIO_StillDraining(void* id, int isSource) { |
|
807 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
808 snd_pcm_state_t state; |
|
809 |
|
810 state = snd_pcm_state(info->handle); |
|
811 //printState(state); |
|
812 //TRACE1("Still draining: %s\n", (state != SND_PCM_STATE_XRUN)?"TRUE":"FALSE"); |
|
813 return (state == SND_PCM_STATE_RUNNING)?TRUE:FALSE; |
|
814 } |
|
815 |
|
816 |
|
817 int DAUDIO_Flush(void* id, int isSource) { |
|
818 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
819 int ret; |
|
820 |
|
821 TRACE0("DAUDIO_Flush\n"); |
|
822 |
|
823 if (info->isFlushed) { |
|
824 // nothing to drop |
|
825 return 1; |
|
826 } |
|
827 |
|
828 ret = snd_pcm_drop(info->handle); |
|
829 if (ret != 0) { |
|
830 ERROR1("ERROR in snd_pcm_drop: %s\n", snd_strerror(ret)); |
|
831 return FALSE; |
|
832 } |
|
833 |
|
834 info->isFlushed = 1; |
|
835 if (info->isRunning) { |
|
836 ret = DAUDIO_Start(id, isSource); |
|
837 } |
|
838 return ret; |
|
839 } |
|
840 |
|
841 int DAUDIO_GetAvailable(void* id, int isSource) { |
|
842 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
843 snd_pcm_sframes_t availableInFrames; |
|
844 snd_pcm_state_t state; |
|
845 int ret; |
|
846 |
|
847 state = snd_pcm_state(info->handle); |
|
848 if (info->isFlushed || state == SND_PCM_STATE_XRUN) { |
|
849 // if in xrun state then we have the entire buffer available, |
|
850 // not 0 as alsa reports |
|
851 ret = info->bufferSizeInBytes; |
|
852 } else { |
|
853 availableInFrames = snd_pcm_avail_update(info->handle); |
|
854 if (availableInFrames < 0) { |
|
855 ret = 0; |
|
856 } else { |
|
857 //ret = snd_pcm_frames_to_bytes(info->handle, availableInFrames); |
|
858 ret = (int) (availableInFrames * info->frameSize); |
|
859 } |
|
860 } |
|
861 TRACE1("DAUDIO_GetAvailable returns %d bytes\n", ret); |
|
862 return ret; |
|
863 } |
|
864 |
|
865 INT64 estimatePositionFromAvail(AlsaPcmInfo* info, int isSource, INT64 javaBytePos, int availInBytes) { |
|
866 // estimate the current position with the buffer size and |
|
867 // the available bytes to read or write in the buffer. |
|
868 // not an elegant solution - bytePos will stop on xruns, |
|
869 // and in race conditions it may jump backwards |
|
870 // Advantage is that it is indeed based on the samples that go through |
|
871 // the system (rather than time-based methods) |
|
872 if (isSource) { |
|
873 // javaBytePos is the position that is reached when the current |
|
874 // buffer is played completely |
|
875 return (INT64) (javaBytePos - info->bufferSizeInBytes + availInBytes); |
|
876 } else { |
|
877 // javaBytePos is the position that was when the current buffer was empty |
|
878 return (INT64) (javaBytePos + availInBytes); |
|
879 } |
|
880 } |
|
881 |
|
882 INT64 DAUDIO_GetBytePosition(void* id, int isSource, INT64 javaBytePos) { |
|
883 AlsaPcmInfo* info = (AlsaPcmInfo*) id; |
|
884 int ret; |
|
885 INT64 result = javaBytePos; |
|
886 snd_pcm_state_t state; |
|
887 state = snd_pcm_state(info->handle); |
|
888 |
|
889 if (!info->isFlushed && state != SND_PCM_STATE_XRUN) { |
|
890 #ifdef GET_POSITION_METHOD2 |
|
891 snd_timestamp_t* ts; |
|
892 snd_pcm_uframes_t framesAvail; |
|
893 |
|
894 // note: slight race condition if this is called simultaneously from 2 threads |
|
895 ret = snd_pcm_status(info->handle, info->positionStatus); |
|
896 if (ret != 0) { |
|
897 ERROR1("ERROR in snd_pcm_status: %s\n", snd_strerror(ret)); |
|
898 result = javaBytePos; |
|
899 } else { |
|
900 // calculate from time value, or from available bytes |
|
901 framesAvail = snd_pcm_status_get_avail(info->positionStatus); |
|
902 result = estimatePositionFromAvail(info, isSource, javaBytePos, framesAvail * info->frameSize); |
|
903 } |
|
904 #endif |
|
905 #ifdef GET_POSITION_METHOD3 |
|
906 snd_pcm_uframes_t framesAvail; |
|
907 ret = snd_pcm_avail(info->handle, &framesAvail); |
|
908 if (ret != 0) { |
|
909 ERROR1("ERROR in snd_pcm_avail: %s\n", snd_strerror(ret)); |
|
910 result = javaBytePos; |
|
911 } else { |
|
912 result = estimatePositionFromAvail(info, isSource, javaBytePos, framesAvail * info->frameSize); |
|
913 } |
|
914 #endif |
|
915 #ifdef GET_POSITION_METHOD1 |
|
916 result = estimatePositionFromAvail(info, isSource, javaBytePos, DAUDIO_GetAvailable(id, isSource)); |
|
917 #endif |
|
918 } |
|
919 //printf("getbyteposition: javaBytePos=%d , return=%d\n", (int) javaBytePos, (int) result); |
|
920 return result; |
|
921 } |
|
922 |
|
923 |
|
924 |
|
925 void DAUDIO_SetBytePosition(void* id, int isSource, INT64 javaBytePos) { |
|
926 /* save to ignore, since GetBytePosition |
|
927 * takes the javaBytePos param into account |
|
928 */ |
|
929 } |
|
930 |
|
931 int DAUDIO_RequiresServicing(void* id, int isSource) { |
|
932 // never need servicing on Bsd |
|
933 return FALSE; |
|
934 } |
|
935 |
|
936 void DAUDIO_Service(void* id, int isSource) { |
|
937 // never need servicing on Bsd |
|
938 } |
|
939 |
|
940 |
|
941 #endif // USE_DAUDIO |
|