?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
regedit: An English (United States) spelling fix.
[wine/multimedia.git] / dlls / winealsa.drv / mmdevdrv.c
blob0f710a5c89e17930a81bfece5cd430a6a149b94d
1 /*
2 * Copyright 2010 Maarten Lankhorst for CodeWeavers
3 * Copyright 2011 Andrew Eikum for CodeWeavers
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #define NONAMELESSUNION
21 #define COBJMACROS
22 #include "config.h"
23
24 #include <stdarg.h>
25 #include <math.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winnls.h"
30 #include "winreg.h"
31 #include "wine/debug.h"
32 #include "wine/unicode.h"
33 #include "wine/list.h"
34
35 #include "ole2.h"
36 #include "mmdeviceapi.h"
37 #include "devpkey.h"
38 #include "dshow.h"
39 #include "dsound.h"
40
41 #include "initguid.h"
42 #include "endpointvolume.h"
43 #include "audioclient.h"
44 #include "audiopolicy.h"
45
46 #include <alsa/asoundlib.h>
47
48 WINE_DEFAULT_DEBUG_CHANNEL(alsa);
49 WINE_DECLARE_DEBUG_CHANNEL(winediag);
50
51 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
52
53 static const REFERENCE_TIME DefaultPeriod = 100000;
54 static const REFERENCE_TIME MinimumPeriod = 50000;
55 #define EXTRA_SAFE_RT 40000
56
57 struct ACImpl;
58 typedef struct ACImpl ACImpl;
59
60 typedef struct _AudioSession {
61 GUID guid;
62 struct list clients;
63
64 IMMDevice *device;
65
66 float master_vol;
67 UINT32 channel_count;
68 float *channel_vols;
69 BOOL mute;
70
71 CRITICAL_SECTION lock;
72
73 struct list entry;
74 } AudioSession;
75
76 typedef struct _AudioSessionWrapper {
77 IAudioSessionControl2 IAudioSessionControl2_iface;
78 IChannelAudioVolume IChannelAudioVolume_iface;
79 ISimpleAudioVolume ISimpleAudioVolume_iface;
80
81 LONG ref;
82
83 ACImpl *client;
84 AudioSession *session;
85 } AudioSessionWrapper;
86
87 struct ACImpl {
88 IAudioClient IAudioClient_iface;
89 IAudioRenderClient IAudioRenderClient_iface;
90 IAudioCaptureClient IAudioCaptureClient_iface;
91 IAudioClock IAudioClock_iface;
92 IAudioClock2 IAudioClock2_iface;
93 IAudioStreamVolume IAudioStreamVolume_iface;
94
95 LONG ref;
96
97 snd_pcm_t *pcm_handle;
98 snd_pcm_uframes_t alsa_bufsize_frames, alsa_period_frames;
99 snd_pcm_hw_params_t *hw_params; /* does not hold state between calls */
100 snd_pcm_format_t alsa_format;
101
102 IMMDevice *parent;
103
104 EDataFlow dataflow;
105 WAVEFORMATEX *fmt;
106 DWORD flags;
107 AUDCLNT_SHAREMODE share;
108 HANDLE event;
109 float *vols;
110
111 BOOL initted, started;
112 REFERENCE_TIME mmdev_period_rt;
113 UINT64 written_frames, last_pos_frames;
114 UINT32 bufsize_frames, held_frames, tmp_buffer_frames, mmdev_period_frames;
115 UINT32 lcl_offs_frames; /* offs into local_buffer where valid data starts */
116 UINT32 hidden_frames; /* ALSA reserve to ensure continuous rendering */
117
118 HANDLE timer;
119 BYTE *local_buffer, *tmp_buffer;
120 LONG32 getbuf_last; /* <0 when using tmp_buffer */
121
122 CRITICAL_SECTION lock;
123
124 AudioSession *session;
125 AudioSessionWrapper *session_wrapper;
126
127 struct list entry;
128 };
129
130 typedef struct _SessionMgr {
131 IAudioSessionManager2 IAudioSessionManager2_iface;
132
133 LONG ref;
134
135 IMMDevice *device;
136 } SessionMgr;
137
138 static HANDLE g_timer_q;
139
140 static CRITICAL_SECTION g_sessions_lock;
141 static CRITICAL_SECTION_DEBUG g_sessions_lock_debug =
142 {
143 0, 0, &g_sessions_lock,
144 { &g_sessions_lock_debug.ProcessLocksList, &g_sessions_lock_debug.ProcessLocksList },
145 0, 0, { (DWORD_PTR)(__FILE__ ": g_sessions_lock") }
146 };
147 static CRITICAL_SECTION g_sessions_lock = { &g_sessions_lock_debug, -1, 0, 0, 0, 0 };
148 static struct list g_sessions = LIST_INIT(g_sessions);
149
150 static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0};
151 static const char defname[] = "default";
152
153 static const IAudioClientVtbl AudioClient_Vtbl;
154 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl;
155 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl;
156 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl;
157 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl;
158 static const IAudioClockVtbl AudioClock_Vtbl;
159 static const IAudioClock2Vtbl AudioClock2_Vtbl;
160 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl;
161 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl;
162 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl;
163
164 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client);
165
166 static inline ACImpl *impl_from_IAudioClient(IAudioClient *iface)
167 {
168 return CONTAINING_RECORD(iface, ACImpl, IAudioClient_iface);
169 }
170
171 static inline ACImpl *impl_from_IAudioRenderClient(IAudioRenderClient *iface)
172 {
173 return CONTAINING_RECORD(iface, ACImpl, IAudioRenderClient_iface);
174 }
175
176 static inline ACImpl *impl_from_IAudioCaptureClient(IAudioCaptureClient *iface)
177 {
178 return CONTAINING_RECORD(iface, ACImpl, IAudioCaptureClient_iface);
179 }
180
181 static inline AudioSessionWrapper *impl_from_IAudioSessionControl2(IAudioSessionControl2 *iface)
182 {
183 return CONTAINING_RECORD(iface, AudioSessionWrapper, IAudioSessionControl2_iface);
184 }
185
186 static inline AudioSessionWrapper *impl_from_ISimpleAudioVolume(ISimpleAudioVolume *iface)
187 {
188 return CONTAINING_RECORD(iface, AudioSessionWrapper, ISimpleAudioVolume_iface);
189 }
190
191 static inline AudioSessionWrapper *impl_from_IChannelAudioVolume(IChannelAudioVolume *iface)
192 {
193 return CONTAINING_RECORD(iface, AudioSessionWrapper, IChannelAudioVolume_iface);
194 }
195
196 static inline ACImpl *impl_from_IAudioClock(IAudioClock *iface)
197 {
198 return CONTAINING_RECORD(iface, ACImpl, IAudioClock_iface);
199 }
200
201 static inline ACImpl *impl_from_IAudioClock2(IAudioClock2 *iface)
202 {
203 return CONTAINING_RECORD(iface, ACImpl, IAudioClock2_iface);
204 }
205
206 static inline ACImpl *impl_from_IAudioStreamVolume(IAudioStreamVolume *iface)
207 {
208 return CONTAINING_RECORD(iface, ACImpl, IAudioStreamVolume_iface);
209 }
210
211 static inline SessionMgr *impl_from_IAudioSessionManager2(IAudioSessionManager2 *iface)
212 {
213 return CONTAINING_RECORD(iface, SessionMgr, IAudioSessionManager2_iface);
214 }
215
216 BOOL WINAPI DllMain(HINSTANCE dll, DWORD reason, void *reserved)
217 {
218 switch (reason)
219 {
220 case DLL_PROCESS_ATTACH:
221 g_timer_q = CreateTimerQueue();
222 if(!g_timer_q)
223 return FALSE;
224 break;
225
226 case DLL_PROCESS_DETACH:
227 DeleteCriticalSection(&g_sessions_lock);
228 break;
229 }
230 return TRUE;
231 }
232
233 /* From <dlls/mmdevapi/mmdevapi.h> */
234 enum DriverPriority {
235 Priority_Unavailable = 0,
236 Priority_Low,
237 Priority_Neutral,
238 Priority_Preferred
239 };
240
241 int WINAPI AUDDRV_GetPriority(void)
242 {
243 return Priority_Neutral;
244 }
245
246 static BOOL alsa_try_open(const char *devnode, snd_pcm_stream_t stream)
247 {
248 snd_pcm_t *handle;
249 int err;
250
251 if((err = snd_pcm_open(&handle, devnode, stream, SND_PCM_NONBLOCK)) < 0){
252 WARN("The device \"%s\" failed to open: %d (%s).\n",
253 devnode, err, snd_strerror(err));
254 return FALSE;
255 }
256
257 snd_pcm_close(handle);
258 return TRUE;
259 }
260
261 static HRESULT alsa_get_card_devices(snd_pcm_stream_t stream, WCHAR **ids, char **keys,
262 UINT *num, snd_ctl_t *ctl, int card, const WCHAR *cardnameW)
263 {
264 static const WCHAR dashW[] = {' ','-',' ',0};
265 int err, device;
266 snd_pcm_info_t *info;
267
268 info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_info_sizeof());
269 if(!info)
270 return E_OUTOFMEMORY;
271
272 snd_pcm_info_set_subdevice(info, 0);
273 snd_pcm_info_set_stream(info, stream);
274
275 device = -1;
276 for(err = snd_ctl_pcm_next_device(ctl, &device); device != -1 && err >= 0;
277 err = snd_ctl_pcm_next_device(ctl, &device)){
278 const char *devname;
279 char devnode[32];
280
281 snd_pcm_info_set_device(info, device);
282
283 if((err = snd_ctl_pcm_info(ctl, info)) < 0){
284 if(err == -ENOENT)
285 /* This device doesn't have the right stream direction */
286 continue;
287
288 WARN("Failed to get info for card %d, device %d: %d (%s)\n",
289 card, device, err, snd_strerror(err));
290 continue;
291 }
292
293 sprintf(devnode, "plughw:%d,%d", card, device);
294 if(!alsa_try_open(devnode, stream))
295 continue;
296
297 if(ids && keys){
298 DWORD len, cardlen;
299
300 devname = snd_pcm_info_get_name(info);
301 if(!devname){
302 WARN("Unable to get device name for card %d, device %d\n", card,
303 device);
304 continue;
305 }
306
307 cardlen = lstrlenW(cardnameW);
308 len = MultiByteToWideChar(CP_UNIXCP, 0, devname, -1, NULL, 0);
309 len += lstrlenW(dashW);
310 len += cardlen;
311 ids[*num] = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
312 if(!ids[*num]){
313 HeapFree(GetProcessHeap(), 0, info);
314 return E_OUTOFMEMORY;
315 }
316 memcpy(ids[*num], cardnameW, cardlen * sizeof(WCHAR));
317 memcpy(ids[*num] + cardlen, dashW, lstrlenW(dashW) * sizeof(WCHAR));
318 cardlen += lstrlenW(dashW);
319 MultiByteToWideChar(CP_UNIXCP, 0, devname, -1, ids[*num] + cardlen,
320 len - cardlen);
321
322 keys[*num] = HeapAlloc(GetProcessHeap(), 0, 32);
323 if(!keys[*num]){
324 HeapFree(GetProcessHeap(), 0, info);
325 HeapFree(GetProcessHeap(), 0, ids[*num]);
326 return E_OUTOFMEMORY;
327 }
328 memcpy(keys[*num], devnode, sizeof(devnode));
329 }
330
331 ++(*num);
332 }
333
334 HeapFree(GetProcessHeap(), 0, info);
335
336 if(err != 0)
337 WARN("Got a failure during device enumeration on card %d: %d (%s)\n",
338 card, err, snd_strerror(err));
339
340 return S_OK;
341 }
342
343 static void get_reg_devices(snd_pcm_stream_t stream, WCHAR **ids, char **keys,
344 UINT *num)
345 {
346 static const WCHAR drv_keyW[] = {'S','o','f','t','w','a','r','e','\\',
347 'W','i','n','e','\\','D','r','i','v','e','r','s','\\',
348 'w','i','n','e','a','l','s','a','.','d','r','v',0};
349 static const WCHAR ALSAOutputDevices[] = {'A','L','S','A','O','u','t','p','u','t','D','e','v','i','c','e','s',0};
350 static const WCHAR ALSAInputDevices[] = {'A','L','S','A','I','n','p','u','t','D','e','v','i','c','e','s',0};
351 HKEY key;
352 WCHAR reg_devices[256];
353 DWORD size = sizeof(reg_devices), type, len;
354 const WCHAR *value_name = (stream == SND_PCM_STREAM_PLAYBACK) ? ALSAOutputDevices : ALSAInputDevices;
355
356 /* @@ Wine registry key: HKCU\Software\Wine\Drivers\winealsa.drv */
357 if(RegOpenKeyW(HKEY_CURRENT_USER, drv_keyW, &key) == ERROR_SUCCESS){
358 if(RegQueryValueExW(key, value_name, 0, &type,
359 (BYTE*)reg_devices, &size) == ERROR_SUCCESS){
360 WCHAR *p = reg_devices;
361
362 if(type != REG_MULTI_SZ){
363 ERR("Registry ALSA device list value type must be REG_MULTI_SZ\n");
364 RegCloseKey(key);
365 return;
366 }
367
368 while(*p){
369 char devname[64];
370
371 WideCharToMultiByte(CP_UNIXCP, 0, p, -1, devname, sizeof(devname), NULL, NULL);
372
373 if(alsa_try_open(devname, stream)){
374 if(ids && keys){
375 len = lstrlenW(p) + 1;
376 ids[*num] = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
377 memcpy(ids[*num], p, len * sizeof(WCHAR));
378
379 len = strlen(devname) + 1;
380 keys[*num] = HeapAlloc(GetProcessHeap(), 0, len);
381 memcpy(keys[*num], devname, len);
382 }
383 ++*num;
384 }
385
386 p += lstrlenW(p) + 1;
387 }
388 }
389
390 RegCloseKey(key);
391 }
392 }
393
394 static HRESULT alsa_enum_devices(EDataFlow flow, WCHAR **ids, char **keys,
395 UINT *num)
396 {
397 snd_pcm_stream_t stream = (flow == eRender ? SND_PCM_STREAM_PLAYBACK :
398 SND_PCM_STREAM_CAPTURE);
399 int err, card;
400
401 card = -1;
402 *num = 0;
403
404 if(alsa_try_open(defname, stream)){
405 if(ids && keys){
406 *ids = HeapAlloc(GetProcessHeap(), 0, sizeof(defaultW));
407 memcpy(*ids, defaultW, sizeof(defaultW));
408 *keys = HeapAlloc(GetProcessHeap(), 0, sizeof(defname));
409 memcpy(*keys, defname, sizeof(defname));
410 }
411 ++*num;
412 }
413
414 get_reg_devices(stream, ids, keys, num);
415
416 for(err = snd_card_next(&card); card != -1 && err >= 0;
417 err = snd_card_next(&card)){
418 char cardpath[64];
419 char *cardname;
420 WCHAR *cardnameW;
421 snd_ctl_t *ctl;
422 DWORD len;
423
424 sprintf(cardpath, "hw:%u", card);
425
426 if((err = snd_ctl_open(&ctl, cardpath, 0)) < 0){
427 WARN("Unable to open ctl for ALSA device %s: %d (%s)\n", cardpath,
428 err, snd_strerror(err));
429 continue;
430 }
431
432 if(snd_card_get_name(card, &cardname) < 0) {
433 /* FIXME: Should be localized */
434 static const WCHAR nameW[] = {'U','n','k','n','o','w','n',' ','s','o','u','n','d','c','a','r','d',0};
435 WARN("Unable to get card name for ALSA device %s: %d (%s)\n",
436 cardpath, err, snd_strerror(err));
437 alsa_get_card_devices(stream, ids, keys, num, ctl, card, nameW);
438 }else{
439 len = MultiByteToWideChar(CP_UNIXCP, 0, cardname, -1, NULL, 0);
440 cardnameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
441
442 if(!cardnameW){
443 free(cardname);
444 snd_ctl_close(ctl);
445 return E_OUTOFMEMORY;
446 }
447 MultiByteToWideChar(CP_UNIXCP, 0, cardname, -1, cardnameW, len);
448
449 alsa_get_card_devices(stream, ids, keys, num, ctl, card, cardnameW);
450
451 HeapFree(GetProcessHeap(), 0, cardnameW);
452 free(cardname);
453 }
454
455 snd_ctl_close(ctl);
456 }
457
458 if(err != 0)
459 WARN("Got a failure during card enumeration: %d (%s)\n",
460 err, snd_strerror(err));
461
462 return S_OK;
463 }
464
465 HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids, char ***keys,
466 UINT *num, UINT *def_index)
467 {
468 HRESULT hr;
469
470 TRACE("%d %p %p %p %p\n", flow, ids, keys, num, def_index);
471
472 hr = alsa_enum_devices(flow, NULL, NULL, num);
473 if(FAILED(hr))
474 return hr;
475
476 if(*num == 0)
477 {
478 *ids = NULL;
479 *keys = NULL;
480 return S_OK;
481 }
482
483 *ids = HeapAlloc(GetProcessHeap(), 0, *num * sizeof(WCHAR *));
484 *keys = HeapAlloc(GetProcessHeap(), 0, *num * sizeof(char *));
485 if(!*ids || !*keys){
486 HeapFree(GetProcessHeap(), 0, *ids);
487 HeapFree(GetProcessHeap(), 0, *keys);
488 return E_OUTOFMEMORY;
489 }
490
491 *def_index = 0;
492
493 hr = alsa_enum_devices(flow, *ids, *keys, num);
494 if(FAILED(hr)){
495 int i;
496 for(i = 0; i < *num; ++i){
497 HeapFree(GetProcessHeap(), 0, (*ids)[i]);
498 HeapFree(GetProcessHeap(), 0, (*keys)[i]);
499 }
500 HeapFree(GetProcessHeap(), 0, *ids);
501 HeapFree(GetProcessHeap(), 0, *keys);
502 return E_OUTOFMEMORY;
503 }
504
505 return S_OK;
506 }
507
508 /* Using the pulse PCM device from alsa-plugins 1.0.24 triggers a bug
509 * which causes audio to cease playing after a few minutes of playback.
510 * Setting handle_underrun=1 on pulse-backed ALSA devices seems to work
511 * around this issue. */
512 static snd_config_t *make_handle_underrun_config(const char *name)
513 {
514 snd_config_t *lconf, *dev_node, *hu_node, *type_node;
515 char dev_node_name[64];
516 const char *type_str;
517 int err;
518
519 snd_config_update();
520
521 if((err = snd_config_copy(&lconf, snd_config)) < 0){
522 WARN("snd_config_copy failed: %d (%s)\n", err, snd_strerror(err));
523 return NULL;
524 }
525
526 sprintf(dev_node_name, "pcm.%s", name);
527 err = snd_config_search(lconf, dev_node_name, &dev_node);
528 if(err == -ENOENT){
529 snd_config_delete(lconf);
530 return NULL;
531 }
532 if(err < 0){
533 snd_config_delete(lconf);
534 WARN("snd_config_search failed: %d (%s)\n", err, snd_strerror(err));
535 return NULL;
536 }
537
538 /* ALSA is extremely fragile. If it runs into a config setting it doesn't
539 * recognize, it tends to fail or assert. So we only want to inject
540 * handle_underrun=1 on devices that we know will recognize it. */
541 err = snd_config_search(dev_node, "type", &type_node);
542 if(err == -ENOENT){
543 snd_config_delete(lconf);
544 return NULL;
545 }
546 if(err < 0){
547 snd_config_delete(lconf);
548 WARN("snd_config_search failed: %d (%s)\n", err, snd_strerror(err));
549 return NULL;
550 }
551
552 if((err = snd_config_get_string(type_node, &type_str)) < 0){
553 snd_config_delete(lconf);
554 return NULL;
555 }
556
557 if(strcmp(type_str, "pulse") != 0){
558 snd_config_delete(lconf);
559 return NULL;
560 }
561
562 err = snd_config_search(dev_node, "handle_underrun", &hu_node);
563 if(err >= 0){
564 /* user already has an explicit handle_underrun setting, so don't
565 * use a local config */
566 snd_config_delete(lconf);
567 return NULL;
568 }
569 if(err != -ENOENT){
570 snd_config_delete(lconf);
571 WARN("snd_config_search failed: %d (%s)\n", err, snd_strerror(err));
572 return NULL;
573 }
574
575 if((err = snd_config_imake_integer(&hu_node, "handle_underrun", 1)) < 0){
576 snd_config_delete(lconf);
577 WARN("snd_config_imake_integer failed: %d (%s)\n", err,
578 snd_strerror(err));
579 return NULL;
580 }
581
582 if((err = snd_config_add(dev_node, hu_node)) < 0){
583 snd_config_delete(lconf);
584 WARN("snd_config_add failed: %d (%s)\n", err, snd_strerror(err));
585 return NULL;
586 }
587
588 return lconf;
589 }
590
591 HRESULT WINAPI AUDDRV_GetAudioEndpoint(const char *key, IMMDevice *dev,
592 EDataFlow dataflow, IAudioClient **out)
593 {
594 ACImpl *This;
595 int err;
596 snd_pcm_stream_t stream;
597 snd_config_t *lconf;
598 static int handle_underrun = 1;
599
600 TRACE("\"%s\" %p %d %p\n", key, dev, dataflow, out);
601
602 This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ACImpl));
603 if(!This)
604 return E_OUTOFMEMORY;
605
606 This->IAudioClient_iface.lpVtbl = &AudioClient_Vtbl;
607 This->IAudioRenderClient_iface.lpVtbl = &AudioRenderClient_Vtbl;
608 This->IAudioCaptureClient_iface.lpVtbl = &AudioCaptureClient_Vtbl;
609 This->IAudioClock_iface.lpVtbl = &AudioClock_Vtbl;
610 This->IAudioClock2_iface.lpVtbl = &AudioClock2_Vtbl;
611 This->IAudioStreamVolume_iface.lpVtbl = &AudioStreamVolume_Vtbl;
612
613 if(dataflow == eRender)
614 stream = SND_PCM_STREAM_PLAYBACK;
615 else if(dataflow == eCapture)
616 stream = SND_PCM_STREAM_CAPTURE;
617 else{
618 HeapFree(GetProcessHeap(), 0, This);
619 return E_UNEXPECTED;
620 }
621
622 This->dataflow = dataflow;
623 if(handle_underrun && ((lconf = make_handle_underrun_config(key)))){
624 err = snd_pcm_open_lconf(&This->pcm_handle, key, stream, SND_PCM_NONBLOCK, lconf);
625 TRACE("Opening PCM device \"%s\" with handle_underrun: %d\n", key, err);
626 snd_config_delete(lconf);
627 /* Pulse <= 2010 returns EINVAL, it does not know handle_underrun. */
628 if(err == -EINVAL){
629 ERR_(winediag)("PulseAudio \"%s\" %d without handle_underrun. Audio may hang."
630 " Please upgrade to alsa_plugins >= 1.0.24\n", key, err);
631 handle_underrun = 0;
632 }
633 }else
634 err = -EINVAL;
635 if(err == -EINVAL){
636 err = snd_pcm_open(&This->pcm_handle, key, stream, SND_PCM_NONBLOCK);
637 }
638 if(err < 0){
639 HeapFree(GetProcessHeap(), 0, This);
640 WARN("Unable to open PCM \"%s\": %d (%s)\n", key, err, snd_strerror(err));
641 switch(err){
642 case -EBUSY:
643 return AUDCLNT_E_DEVICE_IN_USE;
644 default:
645 return AUDCLNT_E_ENDPOINT_CREATE_FAILED;
646 }
647 }
648
649 This->hw_params = HeapAlloc(GetProcessHeap(), 0,
650 snd_pcm_hw_params_sizeof());
651 if(!This->hw_params){
652 snd_pcm_close(This->pcm_handle);
653 HeapFree(GetProcessHeap(), 0, This);
654 return E_OUTOFMEMORY;
655 }
656
657 InitializeCriticalSection(&This->lock);
658 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ACImpl.lock");
659
660 This->parent = dev;
661 IMMDevice_AddRef(This->parent);
662
663 *out = &This->IAudioClient_iface;
664 IAudioClient_AddRef(&This->IAudioClient_iface);
665
666 return S_OK;
667 }
668
669 static HRESULT WINAPI AudioClient_QueryInterface(IAudioClient *iface,
670 REFIID riid, void **ppv)
671 {
672 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
673
674 if(!ppv)
675 return E_POINTER;
676 *ppv = NULL;
677 if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAudioClient))
678 *ppv = iface;
679 if(*ppv){
680 IUnknown_AddRef((IUnknown*)*ppv);
681 return S_OK;
682 }
683 WARN("Unknown interface %s\n", debugstr_guid(riid));
684 return E_NOINTERFACE;
685 }
686
687 static ULONG WINAPI AudioClient_AddRef(IAudioClient *iface)
688 {
689 ACImpl *This = impl_from_IAudioClient(iface);
690 ULONG ref;
691 ref = InterlockedIncrement(&This->ref);
692 TRACE("(%p) Refcount now %u\n", This, ref);
693 return ref;
694 }
695
696 static ULONG WINAPI AudioClient_Release(IAudioClient *iface)
697 {
698 ACImpl *This = impl_from_IAudioClient(iface);
699 ULONG ref;
700 ref = InterlockedDecrement(&This->ref);
701 TRACE("(%p) Refcount now %u\n", This, ref);
702 if(!ref){
703 IAudioClient_Stop(iface);
704 IMMDevice_Release(This->parent);
705 This->lock.DebugInfo->Spare[0] = 0;
706 DeleteCriticalSection(&This->lock);
707 snd_pcm_drop(This->pcm_handle);
708 snd_pcm_close(This->pcm_handle);
709 if(This->initted){
710 EnterCriticalSection(&g_sessions_lock);
711 list_remove(&This->entry);
712 LeaveCriticalSection(&g_sessions_lock);
713 }
714 HeapFree(GetProcessHeap(), 0, This->vols);
715 HeapFree(GetProcessHeap(), 0, This->local_buffer);
716 HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
717 HeapFree(GetProcessHeap(), 0, This->hw_params);
718 CoTaskMemFree(This->fmt);
719 HeapFree(GetProcessHeap(), 0, This);
720 }
721 return ref;
722 }
723
724 static void dump_fmt(const WAVEFORMATEX *fmt)
725 {
726 TRACE("wFormatTag: 0x%x (", fmt->wFormatTag);
727 switch(fmt->wFormatTag){
728 case WAVE_FORMAT_PCM:
729 TRACE("WAVE_FORMAT_PCM");
730 break;
731 case WAVE_FORMAT_IEEE_FLOAT:
732 TRACE("WAVE_FORMAT_IEEE_FLOAT");
733 break;
734 case WAVE_FORMAT_EXTENSIBLE:
735 TRACE("WAVE_FORMAT_EXTENSIBLE");
736 break;
737 default:
738 TRACE("Unknown");
739 break;
740 }
741 TRACE(")\n");
742
743 TRACE("nChannels: %u\n", fmt->nChannels);
744 TRACE("nSamplesPerSec: %u\n", fmt->nSamplesPerSec);
745 TRACE("nAvgBytesPerSec: %u\n", fmt->nAvgBytesPerSec);
746 TRACE("nBlockAlign: %u\n", fmt->nBlockAlign);
747 TRACE("wBitsPerSample: %u\n", fmt->wBitsPerSample);
748 TRACE("cbSize: %u\n", fmt->cbSize);
749
750 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
751 WAVEFORMATEXTENSIBLE *fmtex = (void*)fmt;
752 TRACE("dwChannelMask: %08x\n", fmtex->dwChannelMask);
753 TRACE("Samples: %04x\n", fmtex->Samples.wReserved);
754 TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex->SubFormat));
755 }
756 }
757
758 static WAVEFORMATEX *clone_format(const WAVEFORMATEX *fmt)
759 {
760 WAVEFORMATEX *ret;
761 size_t size;
762
763 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
764 size = sizeof(WAVEFORMATEXTENSIBLE);
765 else
766 size = sizeof(WAVEFORMATEX);
767
768 ret = CoTaskMemAlloc(size);
769 if(!ret)
770 return NULL;
771
772 memcpy(ret, fmt, size);
773
774 ret->cbSize = size - sizeof(WAVEFORMATEX);
775
776 return ret;
777 }
778
779 static snd_pcm_format_t alsa_format(const WAVEFORMATEX *fmt)
780 {
781 snd_pcm_format_t format = SND_PCM_FORMAT_UNKNOWN;
782 const WAVEFORMATEXTENSIBLE *fmtex = (const WAVEFORMATEXTENSIBLE *)fmt;
783
784 if(fmt->wFormatTag == WAVE_FORMAT_PCM ||
785 (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
786 IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))){
787 if(fmt->wBitsPerSample == 8)
788 format = SND_PCM_FORMAT_U8;
789 else if(fmt->wBitsPerSample == 16)
790 format = SND_PCM_FORMAT_S16_LE;
791 else if(fmt->wBitsPerSample == 24)
792 format = SND_PCM_FORMAT_S24_3LE;
793 else if(fmt->wBitsPerSample == 32)
794 format = SND_PCM_FORMAT_S32_LE;
795 else
796 WARN("Unsupported bit depth: %u\n", fmt->wBitsPerSample);
797 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
798 fmt->wBitsPerSample != fmtex->Samples.wValidBitsPerSample){
799 if(fmtex->Samples.wValidBitsPerSample == 20 && fmt->wBitsPerSample == 24)
800 format = SND_PCM_FORMAT_S20_3LE;
801 else{
802 WARN("Unsupported ValidBits: %u\n", fmtex->Samples.wValidBitsPerSample);
803 format = SND_PCM_FORMAT_UNKNOWN;
804 }
805 }
806 }else if(fmt->wFormatTag == WAVE_FORMAT_IEEE_FLOAT ||
807 (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
808 IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))){
809 if(fmt->wBitsPerSample == 32)
810 format = SND_PCM_FORMAT_FLOAT_LE;
811 else if(fmt->wBitsPerSample == 64)
812 format = SND_PCM_FORMAT_FLOAT64_LE;
813 else
814 WARN("Unsupported float size: %u\n", fmt->wBitsPerSample);
815 }else
816 WARN("Unknown wave format: %04x\n", fmt->wFormatTag);
817 return format;
818 }
819
820 static void session_init_vols(AudioSession *session, UINT channels)
821 {
822 if(session->channel_count < channels){
823 UINT i;
824
825 if(session->channel_vols)
826 session->channel_vols = HeapReAlloc(GetProcessHeap(), 0,
827 session->channel_vols, sizeof(float) * channels);
828 else
829 session->channel_vols = HeapAlloc(GetProcessHeap(), 0,
830 sizeof(float) * channels);
831 if(!session->channel_vols)
832 return;
833
834 for(i = session->channel_count; i < channels; ++i)
835 session->channel_vols[i] = 1.f;
836
837 session->channel_count = channels;
838 }
839 }
840
841 static AudioSession *create_session(const GUID *guid, IMMDevice *device,
842 UINT num_channels)
843 {
844 AudioSession *ret;
845
846 ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(AudioSession));
847 if(!ret)
848 return NULL;
849
850 memcpy(&ret->guid, guid, sizeof(GUID));
851
852 ret->device = device;
853
854 list_init(&ret->clients);
855
856 list_add_head(&g_sessions, &ret->entry);
857
858 InitializeCriticalSection(&ret->lock);
859 ret->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": AudioSession.lock");
860
861 session_init_vols(ret, num_channels);
862
863 ret->master_vol = 1.f;
864
865 return ret;
866 }
867
868 /* if channels == 0, then this will return or create a session with
869 * matching dataflow and GUID. otherwise, channels must also match */
870 static HRESULT get_audio_session(const GUID *sessionguid,
871 IMMDevice *device, UINT channels, AudioSession **out)
872 {
873 AudioSession *session;
874
875 if(!sessionguid || IsEqualGUID(sessionguid, &GUID_NULL)){
876 *out = create_session(&GUID_NULL, device, channels);
877 if(!*out)
878 return E_OUTOFMEMORY;
879
880 return S_OK;
881 }
882
883 *out = NULL;
884 LIST_FOR_EACH_ENTRY(session, &g_sessions, AudioSession, entry){
885 if(session->device == device &&
886 IsEqualGUID(sessionguid, &session->guid)){
887 session_init_vols(session, channels);
888 *out = session;
889 break;
890 }
891 }
892
893 if(!*out){
894 *out = create_session(sessionguid, device, channels);
895 if(!*out)
896 return E_OUTOFMEMORY;
897 }
898
899 return S_OK;
900 }
901
902 static HRESULT WINAPI AudioClient_Initialize(IAudioClient *iface,
903 AUDCLNT_SHAREMODE mode, DWORD flags, REFERENCE_TIME duration,
904 REFERENCE_TIME period, const WAVEFORMATEX *fmt,
905 const GUID *sessionguid)
906 {
907 ACImpl *This = impl_from_IAudioClient(iface);
908 snd_pcm_sw_params_t *sw_params = NULL;
909 snd_pcm_format_t format;
910 unsigned int rate, alsa_period_us;
911 int err, i;
912 HRESULT hr = S_OK;
913
914 TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This, mode, flags,
915 wine_dbgstr_longlong(duration), wine_dbgstr_longlong(period), fmt, debugstr_guid(sessionguid));
916
917 if(!fmt)
918 return E_POINTER;
919
920 if(mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
921 return AUDCLNT_E_NOT_INITIALIZED;
922
923 if(flags & ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS |
924 AUDCLNT_STREAMFLAGS_LOOPBACK |
925 AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
926 AUDCLNT_STREAMFLAGS_NOPERSIST |
927 AUDCLNT_STREAMFLAGS_RATEADJUST |
928 AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED |
929 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE |
930 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED)){
931 TRACE("Unknown flags: %08x\n", flags);
932 return E_INVALIDARG;
933 }
934
935 if(mode == AUDCLNT_SHAREMODE_SHARED){
936 period = DefaultPeriod;
937 if( duration < 3 * period)
938 duration = 3 * period;
939 }else{
940 if(!period)
941 period = DefaultPeriod; /* not minimum */
942 if(period < MinimumPeriod || period > 5000000)
943 return AUDCLNT_E_INVALID_DEVICE_PERIOD;
944 if(duration > 20000000) /* the smaller the period, the lower this limit */
945 return AUDCLNT_E_BUFFER_SIZE_ERROR;
946 if(flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK){
947 if(duration != period)
948 return AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL;
949 FIXME("EXCLUSIVE mode with EVENTCALLBACK\n");
950 return AUDCLNT_E_DEVICE_IN_USE;
951 }else{
952 if( duration < 8 * period)
953 duration = 8 * period; /* may grow above 2s */
954 }
955 }
956
957 EnterCriticalSection(&This->lock);
958
959 if(This->initted){
960 LeaveCriticalSection(&This->lock);
961 return AUDCLNT_E_ALREADY_INITIALIZED;
962 }
963
964 dump_fmt(fmt);
965
966 if((err = snd_pcm_hw_params_any(This->pcm_handle, This->hw_params)) < 0){
967 WARN("Unable to get hw_params: %d (%s)\n", err, snd_strerror(err));
968 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
969 goto exit;
970 }
971
972 if((err = snd_pcm_hw_params_set_access(This->pcm_handle, This->hw_params,
973 SND_PCM_ACCESS_RW_INTERLEAVED)) < 0){
974 WARN("Unable to set access: %d (%s)\n", err, snd_strerror(err));
975 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
976 goto exit;
977 }
978
979 format = alsa_format(fmt);
980 if (format == SND_PCM_FORMAT_UNKNOWN){
981 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
982 goto exit;
983 }
984
985 if((err = snd_pcm_hw_params_set_format(This->pcm_handle, This->hw_params,
986 format)) < 0){
987 WARN("Unable to set ALSA format to %u: %d (%s)\n", format, err,
988 snd_strerror(err));
989 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
990 goto exit;
991 }
992
993 This->alsa_format = format;
994
995 rate = fmt->nSamplesPerSec;
996 if((err = snd_pcm_hw_params_set_rate_near(This->pcm_handle, This->hw_params,
997 &rate, NULL)) < 0){
998 WARN("Unable to set rate to %u: %d (%s)\n", rate, err,
999 snd_strerror(err));
1000 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1001 goto exit;
1002 }
1003
1004 if((err = snd_pcm_hw_params_set_channels(This->pcm_handle, This->hw_params,
1005 fmt->nChannels)) < 0){
1006 WARN("Unable to set channels to %u: %d (%s)\n", fmt->nChannels, err,
1007 snd_strerror(err));
1008 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1009 goto exit;
1010 }
1011
1012 This->mmdev_period_rt = period;
1013 alsa_period_us = This->mmdev_period_rt / 10;
1014 if((err = snd_pcm_hw_params_set_period_time_near(This->pcm_handle,
1015 This->hw_params, &alsa_period_us, NULL)) < 0)
1016 WARN("Unable to set period time near %u: %d (%s)\n", alsa_period_us,
1017 err, snd_strerror(err));
1018 /* ALSA updates the output variable alsa_period_us */
1019
1020 This->mmdev_period_frames = MulDiv(fmt->nSamplesPerSec,
1021 This->mmdev_period_rt, 10000000);
1022
1023 /* Buffer 4 ALSA periods if large enough, else 4 mmdevapi periods */
1024 This->alsa_bufsize_frames = This->mmdev_period_frames * 4;
1025 if(err < 0 || alsa_period_us < period / 10)
1026 err = snd_pcm_hw_params_set_buffer_size_near(This->pcm_handle,
1027 This->hw_params, &This->alsa_bufsize_frames);
1028 else{
1029 unsigned int periods = 4;
1030 err = snd_pcm_hw_params_set_periods_near(This->pcm_handle, This->hw_params, &periods, NULL);
1031 }
1032 if(err < 0)
1033 WARN("Unable to set buffer size: %d (%s)\n", err, snd_strerror(err));
1034
1035 if((err = snd_pcm_hw_params(This->pcm_handle, This->hw_params)) < 0){
1036 WARN("Unable to set hw params: %d (%s)\n", err, snd_strerror(err));
1037 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1038 goto exit;
1039 }
1040
1041 if((err = snd_pcm_hw_params_get_period_size(This->hw_params,
1042 &This->alsa_period_frames, NULL)) < 0){
1043 WARN("Unable to get period size: %d (%s)\n", err, snd_strerror(err));
1044 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1045 goto exit;
1046 }
1047
1048 if((err = snd_pcm_hw_params_get_buffer_size(This->hw_params,
1049 &This->alsa_bufsize_frames)) < 0){
1050 WARN("Unable to get buffer size: %d (%s)\n", err, snd_strerror(err));
1051 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1052 goto exit;
1053 }
1054
1055 sw_params = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_sw_params_sizeof());
1056 if(!sw_params){
1057 hr = E_OUTOFMEMORY;
1058 goto exit;
1059 }
1060
1061 if((err = snd_pcm_sw_params_current(This->pcm_handle, sw_params)) < 0){
1062 WARN("Unable to get sw_params: %d (%s)\n", err, snd_strerror(err));
1063 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1064 goto exit;
1065 }
1066
1067 if((err = snd_pcm_sw_params_set_start_threshold(This->pcm_handle,
1068 sw_params, 1)) < 0){
1069 WARN("Unable set start threshold to 0: %d (%s)\n", err, snd_strerror(err));
1070 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1071 goto exit;
1072 }
1073
1074 if((err = snd_pcm_sw_params_set_stop_threshold(This->pcm_handle,
1075 sw_params, This->alsa_bufsize_frames)) < 0){
1076 WARN("Unable set stop threshold to %lu: %d (%s)\n",
1077 This->alsa_bufsize_frames, err, snd_strerror(err));
1078 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1079 goto exit;
1080 }
1081
1082 if((err = snd_pcm_sw_params(This->pcm_handle, sw_params)) < 0){
1083 WARN("Unable to set sw params: %d (%s)\n", err, snd_strerror(err));
1084 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1085 goto exit;
1086 }
1087
1088 if((err = snd_pcm_prepare(This->pcm_handle)) < 0){
1089 WARN("Unable to prepare device: %d (%s)\n", err, snd_strerror(err));
1090 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1091 goto exit;
1092 }
1093
1094 /* Bear in mind weird situations where
1095 * ALSA period (50ms) > mmdevapi buffer (3x10ms)
1096 * or surprising rounding as seen with 22050x8x1 with Pulse:
1097 * ALSA period 220 vs. 221 frames in mmdevapi and
1098 * buffer 883 vs. 2205 frames in mmdevapi! */
1099 This->bufsize_frames = MulDiv(duration, fmt->nSamplesPerSec, 10000000);
1100 This->hidden_frames = This->alsa_period_frames + This->mmdev_period_frames +
1101 MulDiv(fmt->nSamplesPerSec, EXTRA_SAFE_RT, 10000000);
1102
1103 /* Check if the ALSA buffer is so small that it will run out before
1104 * the next MMDevAPI period tick occurs. Allow a little wiggle room
1105 * with 120% of the period time. */
1106 if(This->alsa_bufsize_frames < 1.2 * This->mmdev_period_frames)
1107 FIXME("ALSA buffer time is too small. Expect underruns. (%lu < %u * 1.2)\n",
1108 This->alsa_bufsize_frames, This->mmdev_period_frames);
1109
1110 This->local_buffer = HeapAlloc(GetProcessHeap(), 0,
1111 This->bufsize_frames * fmt->nBlockAlign);
1112 if(!This->local_buffer){
1113 hr = E_OUTOFMEMORY;
1114 goto exit;
1115 }
1116 if (fmt->wBitsPerSample == 8)
1117 memset(This->local_buffer, 128, This->bufsize_frames * fmt->nBlockAlign);
1118 else
1119 memset(This->local_buffer, 0, This->bufsize_frames * fmt->nBlockAlign);
1120
1121 This->fmt = clone_format(fmt);
1122 if(!This->fmt){
1123 hr = E_OUTOFMEMORY;
1124 goto exit;
1125 }
1126
1127 This->vols = HeapAlloc(GetProcessHeap(), 0, fmt->nChannels * sizeof(float));
1128 if(!This->vols){
1129 hr = E_OUTOFMEMORY;
1130 goto exit;
1131 }
1132
1133 for(i = 0; i < fmt->nChannels; ++i)
1134 This->vols[i] = 1.f;
1135
1136 This->share = mode;
1137 This->flags = flags;
1138
1139 EnterCriticalSection(&g_sessions_lock);
1140
1141 hr = get_audio_session(sessionguid, This->parent, fmt->nChannels,
1142 &This->session);
1143 if(FAILED(hr)){
1144 LeaveCriticalSection(&g_sessions_lock);
1145 goto exit;
1146 }
1147
1148 list_add_tail(&This->session->clients, &This->entry);
1149
1150 LeaveCriticalSection(&g_sessions_lock);
1151
1152 This->initted = TRUE;
1153
1154 TRACE("ALSA period: %lu frames\n", This->alsa_period_frames);
1155 TRACE("ALSA buffer: %lu frames\n", This->alsa_bufsize_frames);
1156 TRACE("MMDevice period: %u frames\n", This->mmdev_period_frames);
1157 TRACE("MMDevice buffer: %u frames\n", This->bufsize_frames);
1158
1159 exit:
1160 HeapFree(GetProcessHeap(), 0, sw_params);
1161 if(FAILED(hr)){
1162 HeapFree(GetProcessHeap(), 0, This->local_buffer);
1163 This->local_buffer = NULL;
1164 CoTaskMemFree(This->fmt);
1165 This->fmt = NULL;
1166 HeapFree(GetProcessHeap(), 0, This->vols);
1167 This->vols = NULL;
1168 }
1169
1170 LeaveCriticalSection(&This->lock);
1171
1172 return hr;
1173 }
1174
1175 static HRESULT WINAPI AudioClient_GetBufferSize(IAudioClient *iface,
1176 UINT32 *out)
1177 {
1178 ACImpl *This = impl_from_IAudioClient(iface);
1179
1180 TRACE("(%p)->(%p)\n", This, out);
1181
1182 if(!out)
1183 return E_POINTER;
1184
1185 EnterCriticalSection(&This->lock);
1186
1187 if(!This->initted){
1188 LeaveCriticalSection(&This->lock);
1189 return AUDCLNT_E_NOT_INITIALIZED;
1190 }
1191
1192 *out = This->bufsize_frames;
1193
1194 LeaveCriticalSection(&This->lock);
1195
1196 return S_OK;
1197 }
1198
1199 static HRESULT WINAPI AudioClient_GetStreamLatency(IAudioClient *iface,
1200 REFERENCE_TIME *latency)
1201 {
1202 ACImpl *This = impl_from_IAudioClient(iface);
1203
1204 TRACE("(%p)->(%p)\n", This, latency);
1205
1206 if(!latency)
1207 return E_POINTER;
1208
1209 EnterCriticalSection(&This->lock);
1210
1211 if(!This->initted){
1212 LeaveCriticalSection(&This->lock);
1213 return AUDCLNT_E_NOT_INITIALIZED;
1214 }
1215
1216 /* Hide some frames in the ALSA buffer. Allows to return GetCurrentPadding=0
1217 * yet have enough data left to play (as if it were in native's mixer). Add:
1218 * + mmdevapi_period such that at the end of it, ALSA still has data;
1219 * + EXTRA_SAFE (~4ms) to allow for late callback invocation / fluctuation;
1220 * + alsa_period such that ALSA always has at least one period to play. */
1221 if(This->dataflow == eRender)
1222 *latency = MulDiv(This->hidden_frames, 10000000, This->fmt->nSamplesPerSec);
1223 else
1224 *latency = MulDiv(This->alsa_period_frames, 10000000, This->fmt->nSamplesPerSec)
1225 + This->mmdev_period_rt;
1226
1227 LeaveCriticalSection(&This->lock);
1228
1229 return S_OK;
1230 }
1231
1232 static HRESULT WINAPI AudioClient_GetCurrentPadding(IAudioClient *iface,
1233 UINT32 *out)
1234 {
1235 ACImpl *This = impl_from_IAudioClient(iface);
1236
1237 TRACE("(%p)->(%p)\n", This, out);
1238
1239 if(!out)
1240 return E_POINTER;
1241
1242 EnterCriticalSection(&This->lock);
1243
1244 if(!This->initted){
1245 LeaveCriticalSection(&This->lock);
1246 return AUDCLNT_E_NOT_INITIALIZED;
1247 }
1248
1249 /* padding is solely updated at callback time in shared mode */
1250 *out = This->held_frames;
1251
1252 LeaveCriticalSection(&This->lock);
1253
1254 TRACE("pad: %u\n", *out);
1255
1256 return S_OK;
1257 }
1258
1259 static DWORD get_channel_mask(unsigned int channels)
1260 {
1261 switch(channels){
1262 case 0:
1263 return 0;
1264 case 1:
1265 return KSAUDIO_SPEAKER_MONO;
1266 case 2:
1267 return KSAUDIO_SPEAKER_STEREO;
1268 case 3:
1269 return KSAUDIO_SPEAKER_STEREO | SPEAKER_LOW_FREQUENCY;
1270 case 4:
1271 return KSAUDIO_SPEAKER_QUAD; /* not _SURROUND */
1272 case 5:
1273 return KSAUDIO_SPEAKER_QUAD | SPEAKER_LOW_FREQUENCY;
1274 case 6:
1275 return KSAUDIO_SPEAKER_5POINT1; /* not 5POINT1_SURROUND */
1276 case 7:
1277 return KSAUDIO_SPEAKER_5POINT1 | SPEAKER_BACK_CENTER;
1278 case 8:
1279 return KSAUDIO_SPEAKER_7POINT1_SURROUND; /* Vista deprecates 7POINT1 */
1280 }
1281 FIXME("Unknown speaker configuration: %u\n", channels);
1282 return 0;
1283 }
1284
1285 static HRESULT WINAPI AudioClient_IsFormatSupported(IAudioClient *iface,
1286 AUDCLNT_SHAREMODE mode, const WAVEFORMATEX *fmt,
1287 WAVEFORMATEX **out)
1288 {
1289 ACImpl *This = impl_from_IAudioClient(iface);
1290 snd_pcm_format_mask_t *formats = NULL;
1291 snd_pcm_format_t format;
1292 HRESULT hr = S_OK;
1293 WAVEFORMATEX *closest = NULL;
1294 const WAVEFORMATEXTENSIBLE *fmtex = (const WAVEFORMATEXTENSIBLE *)fmt;
1295 unsigned int max = 0, min = 0;
1296 int err;
1297
1298 TRACE("(%p)->(%x, %p, %p)\n", This, mode, fmt, out);
1299
1300 if(!fmt || (mode == AUDCLNT_SHAREMODE_SHARED && !out))
1301 return E_POINTER;
1302
1303 if(mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
1304 return E_INVALIDARG;
1305
1306 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1307 fmt->cbSize < sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX))
1308 return E_INVALIDARG;
1309
1310 dump_fmt(fmt);
1311
1312 if(out){
1313 *out = NULL;
1314 if(mode != AUDCLNT_SHAREMODE_SHARED)
1315 out = NULL;
1316 }
1317
1318 EnterCriticalSection(&This->lock);
1319
1320 if((err = snd_pcm_hw_params_any(This->pcm_handle, This->hw_params)) < 0){
1321 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1322 goto exit;
1323 }
1324
1325 formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1326 snd_pcm_format_mask_sizeof());
1327 if(!formats){
1328 hr = E_OUTOFMEMORY;
1329 goto exit;
1330 }
1331
1332 snd_pcm_hw_params_get_format_mask(This->hw_params, formats);
1333 format = alsa_format(fmt);
1334 if (format == SND_PCM_FORMAT_UNKNOWN ||
1335 !snd_pcm_format_mask_test(formats, format)){
1336 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1337 goto exit;
1338 }
1339
1340 closest = clone_format(fmt);
1341 if(!closest){
1342 hr = E_OUTOFMEMORY;
1343 goto exit;
1344 }
1345
1346 if((err = snd_pcm_hw_params_get_rate_min(This->hw_params, &min, NULL)) < 0){
1347 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1348 WARN("Unable to get min rate: %d (%s)\n", err, snd_strerror(err));
1349 goto exit;
1350 }
1351
1352 if((err = snd_pcm_hw_params_get_rate_max(This->hw_params, &max, NULL)) < 0){
1353 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1354 WARN("Unable to get max rate: %d (%s)\n", err, snd_strerror(err));
1355 goto exit;
1356 }
1357
1358 if(fmt->nSamplesPerSec < min || fmt->nSamplesPerSec > max){
1359 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1360 goto exit;
1361 }
1362
1363 if((err = snd_pcm_hw_params_get_channels_min(This->hw_params, &min)) < 0){
1364 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1365 WARN("Unable to get min channels: %d (%s)\n", err, snd_strerror(err));
1366 goto exit;
1367 }
1368
1369 if((err = snd_pcm_hw_params_get_channels_max(This->hw_params, &max)) < 0){
1370 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1371 WARN("Unable to get max channels: %d (%s)\n", err, snd_strerror(err));
1372 goto exit;
1373 }
1374 if(max > 8)
1375 max = 2;
1376 if(fmt->nChannels > max){
1377 hr = S_FALSE;
1378 closest->nChannels = max;
1379 }else if(fmt->nChannels < min){
1380 hr = S_FALSE;
1381 closest->nChannels = min;
1382 }
1383
1384 if(closest->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
1385 DWORD mask = get_channel_mask(closest->nChannels);
1386
1387 ((WAVEFORMATEXTENSIBLE*)closest)->dwChannelMask = mask;
1388
1389 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1390 fmtex->dwChannelMask != 0 &&
1391 fmtex->dwChannelMask != mask)
1392 hr = S_FALSE;
1393 }
1394
1395 exit:
1396 LeaveCriticalSection(&This->lock);
1397 HeapFree(GetProcessHeap(), 0, formats);
1398
1399 if(hr == S_FALSE && !out)
1400 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1401
1402 if(hr == S_FALSE && out) {
1403 closest->nBlockAlign =
1404 closest->nChannels * closest->wBitsPerSample / 8;
1405 closest->nAvgBytesPerSec =
1406 closest->nBlockAlign * closest->nSamplesPerSec;
1407 *out = closest;
1408 } else
1409 CoTaskMemFree(closest);
1410
1411 TRACE("returning: %08x\n", hr);
1412 return hr;
1413 }
1414
1415 static HRESULT WINAPI AudioClient_GetMixFormat(IAudioClient *iface,
1416 WAVEFORMATEX **pwfx)
1417 {
1418 ACImpl *This = impl_from_IAudioClient(iface);
1419 WAVEFORMATEXTENSIBLE *fmt;
1420 snd_pcm_format_mask_t *formats;
1421 unsigned int max_rate, max_channels;
1422 int err;
1423 HRESULT hr = S_OK;
1424
1425 TRACE("(%p)->(%p)\n", This, pwfx);
1426
1427 if(!pwfx)
1428 return E_POINTER;
1429 *pwfx = NULL;
1430
1431 fmt = CoTaskMemAlloc(sizeof(WAVEFORMATEXTENSIBLE));
1432 if(!fmt)
1433 return E_OUTOFMEMORY;
1434
1435 formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_format_mask_sizeof());
1436 if(!formats){
1437 CoTaskMemFree(fmt);
1438 return E_OUTOFMEMORY;
1439 }
1440
1441 EnterCriticalSection(&This->lock);
1442
1443 if((err = snd_pcm_hw_params_any(This->pcm_handle, This->hw_params)) < 0){
1444 WARN("Unable to get hw_params: %d (%s)\n", err, snd_strerror(err));
1445 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1446 goto exit;
1447 }
1448
1449 snd_pcm_hw_params_get_format_mask(This->hw_params, formats);
1450
1451 fmt->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
1452 if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_FLOAT_LE)){
1453 fmt->Format.wBitsPerSample = 32;
1454 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
1455 }else if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_S16_LE)){
1456 fmt->Format.wBitsPerSample = 16;
1457 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1458 }else if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_U8)){
1459 fmt->Format.wBitsPerSample = 8;
1460 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1461 }else if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_S32_LE)){
1462 fmt->Format.wBitsPerSample = 32;
1463 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1464 }else if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_S24_3LE)){
1465 fmt->Format.wBitsPerSample = 24;
1466 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1467 }else{
1468 ERR("Didn't recognize any available ALSA formats\n");
1469 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1470 goto exit;
1471 }
1472
1473 if((err = snd_pcm_hw_params_get_channels_max(This->hw_params,
1474 &max_channels)) < 0){
1475 WARN("Unable to get max channels: %d (%s)\n", err, snd_strerror(err));
1476 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1477 goto exit;
1478 }
1479
1480 if(max_channels > 2)
1481 fmt->Format.nChannels = 2;
1482 else
1483 fmt->Format.nChannels = max_channels;
1484
1485 fmt->dwChannelMask = get_channel_mask(fmt->Format.nChannels);
1486
1487 if((err = snd_pcm_hw_params_get_rate_max(This->hw_params, &max_rate,
1488 NULL)) < 0){
1489 WARN("Unable to get max rate: %d (%s)\n", err, snd_strerror(err));
1490 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1491 goto exit;
1492 }
1493
1494 if(max_rate >= 48000)
1495 fmt->Format.nSamplesPerSec = 48000;
1496 else if(max_rate >= 44100)
1497 fmt->Format.nSamplesPerSec = 44100;
1498 else if(max_rate >= 22050)
1499 fmt->Format.nSamplesPerSec = 22050;
1500 else if(max_rate >= 11025)
1501 fmt->Format.nSamplesPerSec = 11025;
1502 else if(max_rate >= 8000)
1503 fmt->Format.nSamplesPerSec = 8000;
1504 else{
1505 ERR("Unknown max rate: %u\n", max_rate);
1506 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1507 goto exit;
1508 }
1509
1510 fmt->Format.nBlockAlign = (fmt->Format.wBitsPerSample *
1511 fmt->Format.nChannels) / 8;
1512 fmt->Format.nAvgBytesPerSec = fmt->Format.nSamplesPerSec *
1513 fmt->Format.nBlockAlign;
1514
1515 fmt->Samples.wValidBitsPerSample = fmt->Format.wBitsPerSample;
1516 fmt->Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
1517
1518 dump_fmt((WAVEFORMATEX*)fmt);
1519 *pwfx = (WAVEFORMATEX*)fmt;
1520
1521 exit:
1522 LeaveCriticalSection(&This->lock);
1523 if(FAILED(hr))
1524 CoTaskMemFree(fmt);
1525 HeapFree(GetProcessHeap(), 0, formats);
1526
1527 return hr;
1528 }
1529
1530 static HRESULT WINAPI AudioClient_GetDevicePeriod(IAudioClient *iface,
1531 REFERENCE_TIME *defperiod, REFERENCE_TIME *minperiod)
1532 {
1533 ACImpl *This = impl_from_IAudioClient(iface);
1534
1535 TRACE("(%p)->(%p, %p)\n", This, defperiod, minperiod);
1536
1537 if(!defperiod && !minperiod)
1538 return E_POINTER;
1539
1540 if(defperiod)
1541 *defperiod = DefaultPeriod;
1542 if(minperiod)
1543 *minperiod = MinimumPeriod;
1544
1545 return S_OK;
1546 }
1547
1548 static snd_pcm_sframes_t alsa_write_best_effort(snd_pcm_t *handle, BYTE *buf,
1549 snd_pcm_uframes_t frames, ACImpl *This, BOOL mute)
1550 {
1551 snd_pcm_sframes_t written;
1552
1553 if(mute){
1554 int err;
1555 if((err = snd_pcm_format_set_silence(This->alsa_format, buf,
1556 frames * This->fmt->nChannels)) < 0)
1557 WARN("Setting buffer to silence failed: %d (%s)\n", err,
1558 snd_strerror(err));
1559 }
1560
1561 written = snd_pcm_writei(handle, buf, frames);
1562 if(written < 0){
1563 int ret;
1564
1565 if(written == -EAGAIN)
1566 /* buffer full */
1567 return 0;
1568
1569 WARN("writei failed, recovering: %ld (%s)\n", written,
1570 snd_strerror(written));
1571
1572 ret = snd_pcm_recover(handle, written, 0);
1573 if(ret < 0){
1574 WARN("Could not recover: %d (%s)\n", ret, snd_strerror(ret));
1575 return ret;
1576 }
1577
1578 written = snd_pcm_writei(handle, buf, frames);
1579 }
1580
1581 return written;
1582 }
1583
1584 static void alsa_write_data(ACImpl *This)
1585 {
1586 snd_pcm_sframes_t written, in_alsa;
1587 snd_pcm_uframes_t to_write, avail, write_limit, max_period;
1588 int err;
1589 BYTE *buf =
1590 This->local_buffer + (This->lcl_offs_frames * This->fmt->nBlockAlign);
1591
1592 /* this call seems to be required to get an accurate snd_pcm_state() */
1593 avail = snd_pcm_avail_update(This->pcm_handle);
1594
1595 if(snd_pcm_state(This->pcm_handle) == SND_PCM_STATE_XRUN ||
1596 avail > This->alsa_bufsize_frames){
1597 TRACE("XRun state avail %ld, recovering\n", avail);
1598
1599 avail = This->alsa_bufsize_frames;
1600
1601 if((err = snd_pcm_recover(This->pcm_handle, -EPIPE, 1)) < 0)
1602 WARN("snd_pcm_recover failed: %d (%s)\n", err, snd_strerror(err));
1603
1604 if((err = snd_pcm_reset(This->pcm_handle)) < 0)
1605 WARN("snd_pcm_reset failed: %d (%s)\n", err, snd_strerror(err));
1606
1607 if((err = snd_pcm_prepare(This->pcm_handle)) < 0)
1608 WARN("snd_pcm_prepare failed: %d (%s)\n", err, snd_strerror(err));
1609 }else
1610 TRACE("pad: %ld\n", This->alsa_bufsize_frames - avail);
1611
1612 if(This->held_frames == 0)
1613 return;
1614
1615 if(This->lcl_offs_frames + This->held_frames > This->bufsize_frames)
1616 to_write = This->bufsize_frames - This->lcl_offs_frames;
1617 else
1618 to_write = This->held_frames;
1619
1620 max_period = max(This->mmdev_period_frames, This->alsa_period_frames);
1621
1622 /* try to keep 3 ALSA periods or 3 MMDevAPI periods in the ALSA buffer and
1623 * no more */
1624 write_limit = 0;
1625 in_alsa = This->alsa_bufsize_frames - avail;
1626 while(in_alsa + write_limit < max_period * 3)
1627 write_limit += max_period;
1628 if(write_limit == 0)
1629 return;
1630
1631 to_write = min(to_write, write_limit);
1632
1633 /* Add a lead-in when starting with too few frames to ensure
1634 * continuous rendering. Additional benefit: Force ALSA to start.
1635 * GetPosition continues to reflect the speaker position because
1636 * snd_pcm_delay includes buffered frames in its total delay
1637 * and last_pos_frames prevents moving backwards. */
1638 if(!in_alsa && This->held_frames < This->hidden_frames){
1639 UINT32 s_frames = This->hidden_frames - This->held_frames;
1640 BYTE *silence = HeapAlloc(GetProcessHeap(), 0,
1641 s_frames * This->fmt->nBlockAlign);
1642
1643 if(silence){
1644 in_alsa = alsa_write_best_effort(This->pcm_handle,
1645 silence, s_frames, This, TRUE);
1646 TRACE("lead-in %ld\n", in_alsa);
1647 HeapFree(GetProcessHeap(), 0, silence);
1648 if(in_alsa <= 0)
1649 return;
1650 }else
1651 WARN("Couldn't allocate lead-in, expect underrun\n");
1652 }
1653
1654 written = alsa_write_best_effort(This->pcm_handle, buf, to_write, This,
1655 This->session->mute);
1656 if(written < 0){
1657 WARN("Couldn't write: %ld (%s)\n", written, snd_strerror(written));
1658 return;
1659 }
1660
1661 This->lcl_offs_frames += written;
1662 This->lcl_offs_frames %= This->bufsize_frames;
1663 This->held_frames -= written;
1664
1665 if(written < to_write){
1666 /* ALSA buffer probably full */
1667 return;
1668 }
1669
1670 if(This->held_frames && (written < write_limit)){
1671 /* wrapped and have some data back at the start to write */
1672 written = alsa_write_best_effort(This->pcm_handle, This->local_buffer,
1673 min(This->held_frames, write_limit - written), This,
1674 This->session->mute);
1675 if(written < 0){
1676 WARN("Couldn't write: %ld (%s)\n", written, snd_strerror(written));
1677 return;
1678 }
1679
1680 This->lcl_offs_frames += written;
1681 This->lcl_offs_frames %= This->bufsize_frames;
1682 This->held_frames -= written;
1683 }
1684 }
1685
1686 static void alsa_read_data(ACImpl *This)
1687 {
1688 snd_pcm_sframes_t pos, readable, nread;
1689
1690 pos = (This->held_frames + This->lcl_offs_frames) % This->bufsize_frames;
1691 readable = This->bufsize_frames - pos;
1692
1693 nread = snd_pcm_readi(This->pcm_handle,
1694 This->local_buffer + pos * This->fmt->nBlockAlign, readable);
1695 if(nread < 0){
1696 int ret;
1697
1698 WARN("read failed, recovering: %ld (%s)\n", nread, snd_strerror(nread));
1699
1700 ret = snd_pcm_recover(This->pcm_handle, nread, 0);
1701 if(ret < 0){
1702 WARN("Recover failed: %d (%s)\n", ret, snd_strerror(ret));
1703 return;
1704 }
1705
1706 nread = snd_pcm_readi(This->pcm_handle,
1707 This->local_buffer + pos * This->fmt->nBlockAlign, readable);
1708 if(nread < 0){
1709 WARN("read failed: %ld (%s)\n", nread, snd_strerror(nread));
1710 return;
1711 }
1712 }
1713
1714 if(This->session->mute){
1715 int err;
1716 if((err = snd_pcm_format_set_silence(This->alsa_format,
1717 This->local_buffer + pos * This->fmt->nBlockAlign,
1718 nread)) < 0)
1719 WARN("Setting buffer to silence failed: %d (%s)\n", err,
1720 snd_strerror(err));
1721 }
1722
1723 This->held_frames += nread;
1724
1725 if(This->held_frames > This->bufsize_frames){
1726 WARN("Overflow of unread data\n");
1727 This->lcl_offs_frames += This->held_frames;
1728 This->lcl_offs_frames %= This->bufsize_frames;
1729 This->held_frames = This->bufsize_frames;
1730 }
1731 }
1732
1733 static void CALLBACK alsa_push_buffer_data(void *user, BOOLEAN timer)
1734 {
1735 ACImpl *This = user;
1736
1737 EnterCriticalSection(&This->lock);
1738
1739 if(This->started){
1740 if(This->dataflow == eRender)
1741 alsa_write_data(This);
1742 else if(This->dataflow == eCapture)
1743 alsa_read_data(This);
1744
1745 if(This->event)
1746 SetEvent(This->event);
1747 }
1748
1749 LeaveCriticalSection(&This->lock);
1750 }
1751
1752 static HRESULT WINAPI AudioClient_Start(IAudioClient *iface)
1753 {
1754 ACImpl *This = impl_from_IAudioClient(iface);
1755
1756 TRACE("(%p)\n", This);
1757
1758 EnterCriticalSection(&This->lock);
1759
1760 if(!This->initted){
1761 LeaveCriticalSection(&This->lock);
1762 return AUDCLNT_E_NOT_INITIALIZED;
1763 }
1764
1765 if((This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK) && !This->event){
1766 LeaveCriticalSection(&This->lock);
1767 return AUDCLNT_E_EVENTHANDLE_NOT_SET;
1768 }
1769
1770 if(This->started){
1771 LeaveCriticalSection(&This->lock);
1772 return AUDCLNT_E_NOT_STOPPED;
1773 }
1774
1775 if(This->dataflow == eCapture){
1776 /* dump any data that might be leftover in the ALSA capture buffer */
1777 snd_pcm_readi(This->pcm_handle, This->local_buffer,
1778 This->bufsize_frames);
1779 }
1780
1781 if(!CreateTimerQueueTimer(&This->timer, g_timer_q, alsa_push_buffer_data,
1782 This, 0, This->mmdev_period_rt / 10000, WT_EXECUTEINTIMERTHREAD)){
1783 LeaveCriticalSection(&This->lock);
1784 WARN("Unable to create timer: %u\n", GetLastError());
1785 return E_OUTOFMEMORY;
1786 }
1787
1788 This->started = TRUE;
1789
1790 LeaveCriticalSection(&This->lock);
1791
1792 return S_OK;
1793 }
1794
1795 static HRESULT WINAPI AudioClient_Stop(IAudioClient *iface)
1796 {
1797 ACImpl *This = impl_from_IAudioClient(iface);
1798 HANDLE event;
1799 BOOL wait;
1800
1801 TRACE("(%p)\n", This);
1802
1803 EnterCriticalSection(&This->lock);
1804
1805 if(!This->initted){
1806 LeaveCriticalSection(&This->lock);
1807 return AUDCLNT_E_NOT_INITIALIZED;
1808 }
1809
1810 if(!This->started){
1811 LeaveCriticalSection(&This->lock);
1812 return S_FALSE;
1813 }
1814
1815 /* Stop without losing written frames or position.
1816 * snd_pcm_pause would be appropriate but is unsupported by dmix.
1817 * snd_pcm_drain yields EAGAIN in NONBLOCK mode, except with Pulse. */
1818
1819 event = CreateEventW(NULL, TRUE, FALSE, NULL);
1820 wait = !DeleteTimerQueueTimer(g_timer_q, This->timer, event);
1821 if(wait)
1822 WARN("DeleteTimerQueueTimer error %u\n", GetLastError());
1823 wait = wait && GetLastError() == ERROR_IO_PENDING;
1824
1825 This->started = FALSE;
1826
1827 LeaveCriticalSection(&This->lock);
1828
1829 if(event && wait)
1830 WaitForSingleObject(event, INFINITE);
1831 CloseHandle(event);
1832
1833 return S_OK;
1834 }
1835
1836 static HRESULT WINAPI AudioClient_Reset(IAudioClient *iface)
1837 {
1838 ACImpl *This = impl_from_IAudioClient(iface);
1839
1840 TRACE("(%p)\n", This);
1841
1842 EnterCriticalSection(&This->lock);
1843
1844 if(!This->initted){
1845 LeaveCriticalSection(&This->lock);
1846 return AUDCLNT_E_NOT_INITIALIZED;
1847 }
1848
1849 if(This->started){
1850 LeaveCriticalSection(&This->lock);
1851 return AUDCLNT_E_NOT_STOPPED;
1852 }
1853
1854 if(This->getbuf_last){
1855 LeaveCriticalSection(&This->lock);
1856 return AUDCLNT_E_BUFFER_OPERATION_PENDING;
1857 }
1858
1859 if(snd_pcm_drop(This->pcm_handle) < 0)
1860 WARN("snd_pcm_drop failed\n");
1861
1862 if(snd_pcm_reset(This->pcm_handle) < 0)
1863 WARN("snd_pcm_reset failed\n");
1864
1865 if(snd_pcm_prepare(This->pcm_handle) < 0)
1866 WARN("snd_pcm_prepare failed\n");
1867
1868 if(This->dataflow == eRender){
1869 This->written_frames = 0;
1870 This->last_pos_frames = 0;
1871 }else{
1872 This->written_frames += This->held_frames;
1873 }
1874 This->held_frames = 0;
1875 This->lcl_offs_frames = 0;
1876
1877 LeaveCriticalSection(&This->lock);
1878
1879 return S_OK;
1880 }
1881
1882 static HRESULT WINAPI AudioClient_SetEventHandle(IAudioClient *iface,
1883 HANDLE event)
1884 {
1885 ACImpl *This = impl_from_IAudioClient(iface);
1886
1887 TRACE("(%p)->(%p)\n", This, event);
1888
1889 if(!event)
1890 return E_INVALIDARG;
1891
1892 EnterCriticalSection(&This->lock);
1893
1894 if(!This->initted){
1895 LeaveCriticalSection(&This->lock);
1896 return AUDCLNT_E_NOT_INITIALIZED;
1897 }
1898
1899 if(!(This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK)){
1900 LeaveCriticalSection(&This->lock);
1901 return AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED;
1902 }
1903
1904 This->event = event;
1905
1906 LeaveCriticalSection(&This->lock);
1907
1908 return S_OK;
1909 }
1910
1911 static HRESULT WINAPI AudioClient_GetService(IAudioClient *iface, REFIID riid,
1912 void **ppv)
1913 {
1914 ACImpl *This = impl_from_IAudioClient(iface);
1915
1916 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
1917
1918 if(!ppv)
1919 return E_POINTER;
1920 *ppv = NULL;
1921
1922 EnterCriticalSection(&This->lock);
1923
1924 if(!This->initted){
1925 LeaveCriticalSection(&This->lock);
1926 return AUDCLNT_E_NOT_INITIALIZED;
1927 }
1928
1929 if(IsEqualIID(riid, &IID_IAudioRenderClient)){
1930 if(This->dataflow != eRender){
1931 LeaveCriticalSection(&This->lock);
1932 return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
1933 }
1934 IAudioRenderClient_AddRef(&This->IAudioRenderClient_iface);
1935 *ppv = &This->IAudioRenderClient_iface;
1936 }else if(IsEqualIID(riid, &IID_IAudioCaptureClient)){
1937 if(This->dataflow != eCapture){
1938 LeaveCriticalSection(&This->lock);
1939 return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
1940 }
1941 IAudioCaptureClient_AddRef(&This->IAudioCaptureClient_iface);
1942 *ppv = &This->IAudioCaptureClient_iface;
1943 }else if(IsEqualIID(riid, &IID_IAudioClock)){
1944 IAudioClock_AddRef(&This->IAudioClock_iface);
1945 *ppv = &This->IAudioClock_iface;
1946 }else if(IsEqualIID(riid, &IID_IAudioStreamVolume)){
1947 IAudioStreamVolume_AddRef(&This->IAudioStreamVolume_iface);
1948 *ppv = &This->IAudioStreamVolume_iface;
1949 }else if(IsEqualIID(riid, &IID_IAudioSessionControl)){
1950 if(!This->session_wrapper){
1951 This->session_wrapper = AudioSessionWrapper_Create(This);
1952 if(!This->session_wrapper){
1953 LeaveCriticalSection(&This->lock);
1954 return E_OUTOFMEMORY;
1955 }
1956 }else
1957 IAudioSessionControl2_AddRef(&This->session_wrapper->IAudioSessionControl2_iface);
1958
1959 *ppv = &This->session_wrapper->IAudioSessionControl2_iface;
1960 }else if(IsEqualIID(riid, &IID_IChannelAudioVolume)){
1961 if(!This->session_wrapper){
1962 This->session_wrapper = AudioSessionWrapper_Create(This);
1963 if(!This->session_wrapper){
1964 LeaveCriticalSection(&This->lock);
1965 return E_OUTOFMEMORY;
1966 }
1967 }else
1968 IChannelAudioVolume_AddRef(&This->session_wrapper->IChannelAudioVolume_iface);
1969
1970 *ppv = &This->session_wrapper->IChannelAudioVolume_iface;
1971 }else if(IsEqualIID(riid, &IID_ISimpleAudioVolume)){
1972 if(!This->session_wrapper){
1973 This->session_wrapper = AudioSessionWrapper_Create(This);
1974 if(!This->session_wrapper){
1975 LeaveCriticalSection(&This->lock);
1976 return E_OUTOFMEMORY;
1977 }
1978 }else
1979 ISimpleAudioVolume_AddRef(&This->session_wrapper->ISimpleAudioVolume_iface);
1980
1981 *ppv = &This->session_wrapper->ISimpleAudioVolume_iface;
1982 }
1983
1984 if(*ppv){
1985 LeaveCriticalSection(&This->lock);
1986 return S_OK;
1987 }
1988
1989 LeaveCriticalSection(&This->lock);
1990
1991 FIXME("stub %s\n", debugstr_guid(riid));
1992 return E_NOINTERFACE;
1993 }
1994
1995 static const IAudioClientVtbl AudioClient_Vtbl =
1996 {
1997 AudioClient_QueryInterface,
1998 AudioClient_AddRef,
1999 AudioClient_Release,
2000 AudioClient_Initialize,
2001 AudioClient_GetBufferSize,
2002 AudioClient_GetStreamLatency,
2003 AudioClient_GetCurrentPadding,
2004 AudioClient_IsFormatSupported,
2005 AudioClient_GetMixFormat,
2006 AudioClient_GetDevicePeriod,
2007 AudioClient_Start,
2008 AudioClient_Stop,
2009 AudioClient_Reset,
2010 AudioClient_SetEventHandle,
2011 AudioClient_GetService
2012 };
2013
2014 static HRESULT WINAPI AudioRenderClient_QueryInterface(
2015 IAudioRenderClient *iface, REFIID riid, void **ppv)
2016 {
2017 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2018
2019 if(!ppv)
2020 return E_POINTER;
2021 *ppv = NULL;
2022
2023 if(IsEqualIID(riid, &IID_IUnknown) ||
2024 IsEqualIID(riid, &IID_IAudioRenderClient))
2025 *ppv = iface;
2026 if(*ppv){
2027 IUnknown_AddRef((IUnknown*)*ppv);
2028 return S_OK;
2029 }
2030
2031 WARN("Unknown interface %s\n", debugstr_guid(riid));
2032 return E_NOINTERFACE;
2033 }
2034
2035 static ULONG WINAPI AudioRenderClient_AddRef(IAudioRenderClient *iface)
2036 {
2037 ACImpl *This = impl_from_IAudioRenderClient(iface);
2038 return AudioClient_AddRef(&This->IAudioClient_iface);
2039 }
2040
2041 static ULONG WINAPI AudioRenderClient_Release(IAudioRenderClient *iface)
2042 {
2043 ACImpl *This = impl_from_IAudioRenderClient(iface);
2044 return AudioClient_Release(&This->IAudioClient_iface);
2045 }
2046
2047 static HRESULT WINAPI AudioRenderClient_GetBuffer(IAudioRenderClient *iface,
2048 UINT32 frames, BYTE **data)
2049 {
2050 ACImpl *This = impl_from_IAudioRenderClient(iface);
2051 UINT32 write_pos;
2052
2053 TRACE("(%p)->(%u, %p)\n", This, frames, data);
2054
2055 if(!data)
2056 return E_POINTER;
2057 *data = NULL;
2058
2059 EnterCriticalSection(&This->lock);
2060
2061 if(This->getbuf_last){
2062 LeaveCriticalSection(&This->lock);
2063 return AUDCLNT_E_OUT_OF_ORDER;
2064 }
2065
2066 if(!frames){
2067 LeaveCriticalSection(&This->lock);
2068 return S_OK;
2069 }
2070
2071 /* held_frames == GetCurrentPadding_nolock(); */
2072 if(This->held_frames + frames > This->bufsize_frames){
2073 LeaveCriticalSection(&This->lock);
2074 return AUDCLNT_E_BUFFER_TOO_LARGE;
2075 }
2076
2077 write_pos =
2078 (This->lcl_offs_frames + This->held_frames) % This->bufsize_frames;
2079 if(write_pos + frames > This->bufsize_frames){
2080 if(This->tmp_buffer_frames < frames){
2081 HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
2082 This->tmp_buffer = HeapAlloc(GetProcessHeap(), 0,
2083 frames * This->fmt->nBlockAlign);
2084 if(!This->tmp_buffer){
2085 LeaveCriticalSection(&This->lock);
2086 return E_OUTOFMEMORY;
2087 }
2088 This->tmp_buffer_frames = frames;
2089 }
2090 *data = This->tmp_buffer;
2091 This->getbuf_last = -frames;
2092 }else{
2093 *data = This->local_buffer + write_pos * This->fmt->nBlockAlign;
2094 This->getbuf_last = frames;
2095 }
2096
2097 LeaveCriticalSection(&This->lock);
2098
2099 return S_OK;
2100 }
2101
2102 static void alsa_wrap_buffer(ACImpl *This, BYTE *buffer, UINT32 written_frames)
2103 {
2104 snd_pcm_uframes_t write_offs_frames =
2105 (This->lcl_offs_frames + This->held_frames) % This->bufsize_frames;
2106 UINT32 write_offs_bytes = write_offs_frames * This->fmt->nBlockAlign;
2107 snd_pcm_uframes_t chunk_frames = This->bufsize_frames - write_offs_frames;
2108 UINT32 chunk_bytes = chunk_frames * This->fmt->nBlockAlign;
2109 UINT32 written_bytes = written_frames * This->fmt->nBlockAlign;
2110
2111 if(written_bytes <= chunk_bytes){
2112 memcpy(This->local_buffer + write_offs_bytes, buffer, written_bytes);
2113 }else{
2114 memcpy(This->local_buffer + write_offs_bytes, buffer, chunk_bytes);
2115 memcpy(This->local_buffer, buffer + chunk_bytes,
2116 written_bytes - chunk_bytes);
2117 }
2118 }
2119
2120 static HRESULT WINAPI AudioRenderClient_ReleaseBuffer(
2121 IAudioRenderClient *iface, UINT32 written_frames, DWORD flags)
2122 {
2123 ACImpl *This = impl_from_IAudioRenderClient(iface);
2124 BYTE *buffer;
2125
2126 TRACE("(%p)->(%u, %x)\n", This, written_frames, flags);
2127
2128 EnterCriticalSection(&This->lock);
2129
2130 if(!written_frames){
2131 This->getbuf_last = 0;
2132 LeaveCriticalSection(&This->lock);
2133 return S_OK;
2134 }
2135
2136 if(!This->getbuf_last){
2137 LeaveCriticalSection(&This->lock);
2138 return AUDCLNT_E_OUT_OF_ORDER;
2139 }
2140
2141 if(written_frames > (This->getbuf_last >= 0 ? This->getbuf_last : -This->getbuf_last)){
2142 LeaveCriticalSection(&This->lock);
2143 return AUDCLNT_E_INVALID_SIZE;
2144 }
2145
2146 if(This->getbuf_last >= 0)
2147 buffer = This->local_buffer + This->fmt->nBlockAlign *
2148 ((This->lcl_offs_frames + This->held_frames) % This->bufsize_frames);
2149 else
2150 buffer = This->tmp_buffer;
2151
2152 if(flags & AUDCLNT_BUFFERFLAGS_SILENT){
2153 if(This->fmt->wBitsPerSample == 8)
2154 memset(buffer, 128, written_frames * This->fmt->nBlockAlign);
2155 else
2156 memset(buffer, 0, written_frames * This->fmt->nBlockAlign);
2157 }
2158
2159 if(This->getbuf_last < 0)
2160 alsa_wrap_buffer(This, buffer, written_frames);
2161
2162 This->held_frames += written_frames;
2163 This->written_frames += written_frames;
2164 This->getbuf_last = 0;
2165
2166 LeaveCriticalSection(&This->lock);
2167
2168 return S_OK;
2169 }
2170
2171 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl = {
2172 AudioRenderClient_QueryInterface,
2173 AudioRenderClient_AddRef,
2174 AudioRenderClient_Release,
2175 AudioRenderClient_GetBuffer,
2176 AudioRenderClient_ReleaseBuffer
2177 };
2178
2179 static HRESULT WINAPI AudioCaptureClient_QueryInterface(
2180 IAudioCaptureClient *iface, REFIID riid, void **ppv)
2181 {
2182 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2183
2184 if(!ppv)
2185 return E_POINTER;
2186 *ppv = NULL;
2187
2188 if(IsEqualIID(riid, &IID_IUnknown) ||
2189 IsEqualIID(riid, &IID_IAudioCaptureClient))
2190 *ppv = iface;
2191 if(*ppv){
2192 IUnknown_AddRef((IUnknown*)*ppv);
2193 return S_OK;
2194 }
2195
2196 WARN("Unknown interface %s\n", debugstr_guid(riid));
2197 return E_NOINTERFACE;
2198 }
2199
2200 static ULONG WINAPI AudioCaptureClient_AddRef(IAudioCaptureClient *iface)
2201 {
2202 ACImpl *This = impl_from_IAudioCaptureClient(iface);
2203 return IAudioClient_AddRef(&This->IAudioClient_iface);
2204 }
2205
2206 static ULONG WINAPI AudioCaptureClient_Release(IAudioCaptureClient *iface)
2207 {
2208 ACImpl *This = impl_from_IAudioCaptureClient(iface);
2209 return IAudioClient_Release(&This->IAudioClient_iface);
2210 }
2211
2212 static HRESULT WINAPI AudioCaptureClient_GetBuffer(IAudioCaptureClient *iface,
2213 BYTE **data, UINT32 *frames, DWORD *flags, UINT64 *devpos,
2214 UINT64 *qpcpos)
2215 {
2216 ACImpl *This = impl_from_IAudioCaptureClient(iface);
2217
2218 TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This, data, frames, flags,
2219 devpos, qpcpos);
2220
2221 if(!data || !frames || !flags)
2222 return E_POINTER;
2223
2224 EnterCriticalSection(&This->lock);
2225
2226 if(This->getbuf_last){
2227 LeaveCriticalSection(&This->lock);
2228 return AUDCLNT_E_OUT_OF_ORDER;
2229 }
2230
2231 /* hr = GetNextPacketSize(iface, frames); */
2232 if(This->held_frames < This->mmdev_period_frames){
2233 *frames = 0;
2234 LeaveCriticalSection(&This->lock);
2235 return AUDCLNT_S_BUFFER_EMPTY;
2236 }
2237 *frames = This->mmdev_period_frames;
2238
2239 if(This->lcl_offs_frames + *frames > This->bufsize_frames){
2240 UINT32 chunk_bytes, offs_bytes, frames_bytes;
2241 if(This->tmp_buffer_frames < *frames){
2242 HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
2243 This->tmp_buffer = HeapAlloc(GetProcessHeap(), 0,
2244 *frames * This->fmt->nBlockAlign);
2245 if(!This->tmp_buffer){
2246 LeaveCriticalSection(&This->lock);
2247 return E_OUTOFMEMORY;
2248 }
2249 This->tmp_buffer_frames = *frames;
2250 }
2251
2252 *data = This->tmp_buffer;
2253 chunk_bytes = (This->bufsize_frames - This->lcl_offs_frames) *
2254 This->fmt->nBlockAlign;
2255 offs_bytes = This->lcl_offs_frames * This->fmt->nBlockAlign;
2256 frames_bytes = *frames * This->fmt->nBlockAlign;
2257 memcpy(This->tmp_buffer, This->local_buffer + offs_bytes, chunk_bytes);
2258 memcpy(This->tmp_buffer + chunk_bytes, This->local_buffer,
2259 frames_bytes - chunk_bytes);
2260 }else
2261 *data = This->local_buffer +
2262 This->lcl_offs_frames * This->fmt->nBlockAlign;
2263
2264 This->getbuf_last = *frames;
2265 *flags = 0;
2266
2267 if(devpos)
2268 *devpos = This->written_frames;
2269 if(qpcpos){ /* fixme: qpc of recording time */
2270 LARGE_INTEGER stamp, freq;
2271 QueryPerformanceCounter(&stamp);
2272 QueryPerformanceFrequency(&freq);
2273 *qpcpos = (stamp.QuadPart * (INT64)10000000) / freq.QuadPart;
2274 }
2275
2276 LeaveCriticalSection(&This->lock);
2277
2278 return *frames ? S_OK : AUDCLNT_S_BUFFER_EMPTY;
2279 }
2280
2281 static HRESULT WINAPI AudioCaptureClient_ReleaseBuffer(
2282 IAudioCaptureClient *iface, UINT32 done)
2283 {
2284 ACImpl *This = impl_from_IAudioCaptureClient(iface);
2285
2286 TRACE("(%p)->(%u)\n", This, done);
2287
2288 EnterCriticalSection(&This->lock);
2289
2290 if(!done){
2291 This->getbuf_last = 0;
2292 LeaveCriticalSection(&This->lock);
2293 return S_OK;
2294 }
2295
2296 if(!This->getbuf_last){
2297 LeaveCriticalSection(&This->lock);
2298 return AUDCLNT_E_OUT_OF_ORDER;
2299 }
2300
2301 if(This->getbuf_last != done){
2302 LeaveCriticalSection(&This->lock);
2303 return AUDCLNT_E_INVALID_SIZE;
2304 }
2305
2306 This->written_frames += done;
2307 This->held_frames -= done;
2308 This->lcl_offs_frames += done;
2309 This->lcl_offs_frames %= This->bufsize_frames;
2310 This->getbuf_last = 0;
2311
2312 LeaveCriticalSection(&This->lock);
2313
2314 return S_OK;
2315 }
2316
2317 static HRESULT WINAPI AudioCaptureClient_GetNextPacketSize(
2318 IAudioCaptureClient *iface, UINT32 *frames)
2319 {
2320 ACImpl *This = impl_from_IAudioCaptureClient(iface);
2321
2322 TRACE("(%p)->(%p)\n", This, frames);
2323
2324 if(!frames)
2325 return E_POINTER;
2326
2327 EnterCriticalSection(&This->lock);
2328
2329 *frames = This->held_frames < This->mmdev_period_frames ? 0 : This->mmdev_period_frames;
2330
2331 LeaveCriticalSection(&This->lock);
2332
2333 return S_OK;
2334 }
2335
2336 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl =
2337 {
2338 AudioCaptureClient_QueryInterface,
2339 AudioCaptureClient_AddRef,
2340 AudioCaptureClient_Release,
2341 AudioCaptureClient_GetBuffer,
2342 AudioCaptureClient_ReleaseBuffer,
2343 AudioCaptureClient_GetNextPacketSize
2344 };
2345
2346 static HRESULT WINAPI AudioClock_QueryInterface(IAudioClock *iface,
2347 REFIID riid, void **ppv)
2348 {
2349 ACImpl *This = impl_from_IAudioClock(iface);
2350
2351 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2352
2353 if(!ppv)
2354 return E_POINTER;
2355 *ppv = NULL;
2356
2357 if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAudioClock))
2358 *ppv = iface;
2359 else if(IsEqualIID(riid, &IID_IAudioClock2))
2360 *ppv = &This->IAudioClock2_iface;
2361 if(*ppv){
2362 IUnknown_AddRef((IUnknown*)*ppv);
2363 return S_OK;
2364 }
2365
2366 WARN("Unknown interface %s\n", debugstr_guid(riid));
2367 return E_NOINTERFACE;
2368 }
2369
2370 static ULONG WINAPI AudioClock_AddRef(IAudioClock *iface)
2371 {
2372 ACImpl *This = impl_from_IAudioClock(iface);
2373 return IAudioClient_AddRef(&This->IAudioClient_iface);
2374 }
2375
2376 static ULONG WINAPI AudioClock_Release(IAudioClock *iface)
2377 {
2378 ACImpl *This = impl_from_IAudioClock(iface);
2379 return IAudioClient_Release(&This->IAudioClient_iface);
2380 }
2381
2382 static HRESULT WINAPI AudioClock_GetFrequency(IAudioClock *iface, UINT64 *freq)
2383 {
2384 ACImpl *This = impl_from_IAudioClock(iface);
2385
2386 TRACE("(%p)->(%p)\n", This, freq);
2387
2388 *freq = This->fmt->nSamplesPerSec;
2389
2390 return S_OK;
2391 }
2392
2393 static HRESULT WINAPI AudioClock_GetPosition(IAudioClock *iface, UINT64 *pos,
2394 UINT64 *qpctime)
2395 {
2396 ACImpl *This = impl_from_IAudioClock(iface);
2397 UINT64 written_frames, position;
2398 UINT32 held_frames;
2399 int err;
2400 snd_pcm_state_t alsa_state;
2401 snd_pcm_uframes_t avail_frames;
2402 snd_pcm_sframes_t delay_frames;
2403
2404 TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
2405
2406 if(!pos)
2407 return E_POINTER;
2408
2409 EnterCriticalSection(&This->lock);
2410
2411 /* call required to get accurate snd_pcm_state() */
2412 avail_frames = snd_pcm_avail_update(This->pcm_handle);
2413 alsa_state = snd_pcm_state(This->pcm_handle);
2414 written_frames = This->written_frames;
2415 held_frames = This->held_frames;
2416
2417 err = snd_pcm_delay(This->pcm_handle, &delay_frames);
2418 if(err < 0){
2419 /* old Pulse, shortly after start */
2420 WARN("snd_pcm_delay failed in state %u: %d (%s)\n", alsa_state, err, snd_strerror(err));
2421 }
2422
2423 if(This->dataflow == eRender){
2424 position = written_frames - held_frames; /* maximum */
2425 if(!This->started || alsa_state > SND_PCM_STATE_RUNNING)
2426 ; /* mmdevapi stopped or ALSA underrun: pretend everything was played */
2427 else if(err<0 || delay_frames > position - This->last_pos_frames)
2428 /* Pulse bug: past underrun, despite recovery, avail_frames & delay
2429 * may be larger than alsa_bufsize_frames, as if cumulating frames. */
2430 /* Pulse bug: EIO(-5) shortly after starting: nothing played */
2431 position = This->last_pos_frames;
2432 else if(delay_frames > 0)
2433 position -= delay_frames;
2434 }else
2435 position = written_frames + held_frames;
2436
2437 /* ensure monotic growth */
2438 This->last_pos_frames = position;
2439
2440 LeaveCriticalSection(&This->lock);
2441
2442 TRACE("frames written: %u, held: %u, avail: %ld, delay: %ld state %d, pos: %u\n",
2443 (UINT32)(written_frames%1000000000), held_frames,
2444 avail_frames, delay_frames, alsa_state, (UINT32)(position%1000000000));
2445 *pos = position;
2446
2447 if(qpctime){
2448 LARGE_INTEGER stamp, freq;
2449 QueryPerformanceCounter(&stamp);
2450 QueryPerformanceFrequency(&freq);
2451 *qpctime = (stamp.QuadPart * (INT64)10000000) / freq.QuadPart;
2452 }
2453
2454 return S_OK;
2455 }
2456
2457 static HRESULT WINAPI AudioClock_GetCharacteristics(IAudioClock *iface,
2458 DWORD *chars)
2459 {
2460 ACImpl *This = impl_from_IAudioClock(iface);
2461
2462 TRACE("(%p)->(%p)\n", This, chars);
2463
2464 if(!chars)
2465 return E_POINTER;
2466
2467 *chars = AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ;
2468
2469 return S_OK;
2470 }
2471
2472 static const IAudioClockVtbl AudioClock_Vtbl =
2473 {
2474 AudioClock_QueryInterface,
2475 AudioClock_AddRef,
2476 AudioClock_Release,
2477 AudioClock_GetFrequency,
2478 AudioClock_GetPosition,
2479 AudioClock_GetCharacteristics
2480 };
2481
2482 static HRESULT WINAPI AudioClock2_QueryInterface(IAudioClock2 *iface,
2483 REFIID riid, void **ppv)
2484 {
2485 ACImpl *This = impl_from_IAudioClock2(iface);
2486 return IAudioClock_QueryInterface(&This->IAudioClock_iface, riid, ppv);
2487 }
2488
2489 static ULONG WINAPI AudioClock2_AddRef(IAudioClock2 *iface)
2490 {
2491 ACImpl *This = impl_from_IAudioClock2(iface);
2492 return IAudioClient_AddRef(&This->IAudioClient_iface);
2493 }
2494
2495 static ULONG WINAPI AudioClock2_Release(IAudioClock2 *iface)
2496 {
2497 ACImpl *This = impl_from_IAudioClock2(iface);
2498 return IAudioClient_Release(&This->IAudioClient_iface);
2499 }
2500
2501 static HRESULT WINAPI AudioClock2_GetDevicePosition(IAudioClock2 *iface,
2502 UINT64 *pos, UINT64 *qpctime)
2503 {
2504 ACImpl *This = impl_from_IAudioClock2(iface);
2505
2506 FIXME("(%p)->(%p, %p)\n", This, pos, qpctime);
2507
2508 return E_NOTIMPL;
2509 }
2510
2511 static const IAudioClock2Vtbl AudioClock2_Vtbl =
2512 {
2513 AudioClock2_QueryInterface,
2514 AudioClock2_AddRef,
2515 AudioClock2_Release,
2516 AudioClock2_GetDevicePosition
2517 };
2518
2519 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client)
2520 {
2521 AudioSessionWrapper *ret;
2522
2523 ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2524 sizeof(AudioSessionWrapper));
2525 if(!ret)
2526 return NULL;
2527
2528 ret->IAudioSessionControl2_iface.lpVtbl = &AudioSessionControl2_Vtbl;
2529 ret->ISimpleAudioVolume_iface.lpVtbl = &SimpleAudioVolume_Vtbl;
2530 ret->IChannelAudioVolume_iface.lpVtbl = &ChannelAudioVolume_Vtbl;
2531
2532 ret->ref = 1;
2533
2534 ret->client = client;
2535 if(client){
2536 ret->session = client->session;
2537 AudioClient_AddRef(&client->IAudioClient_iface);
2538 }
2539
2540 return ret;
2541 }
2542
2543 static HRESULT WINAPI AudioSessionControl_QueryInterface(
2544 IAudioSessionControl2 *iface, REFIID riid, void **ppv)
2545 {
2546 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2547
2548 if(!ppv)
2549 return E_POINTER;
2550 *ppv = NULL;
2551
2552 if(IsEqualIID(riid, &IID_IUnknown) ||
2553 IsEqualIID(riid, &IID_IAudioSessionControl) ||
2554 IsEqualIID(riid, &IID_IAudioSessionControl2))
2555 *ppv = iface;
2556 if(*ppv){
2557 IUnknown_AddRef((IUnknown*)*ppv);
2558 return S_OK;
2559 }
2560
2561 WARN("Unknown interface %s\n", debugstr_guid(riid));
2562 return E_NOINTERFACE;
2563 }
2564
2565 static ULONG WINAPI AudioSessionControl_AddRef(IAudioSessionControl2 *iface)
2566 {
2567 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2568 ULONG ref;
2569 ref = InterlockedIncrement(&This->ref);
2570 TRACE("(%p) Refcount now %u\n", This, ref);
2571 return ref;
2572 }
2573
2574 static ULONG WINAPI AudioSessionControl_Release(IAudioSessionControl2 *iface)
2575 {
2576 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2577 ULONG ref;
2578 ref = InterlockedDecrement(&This->ref);
2579 TRACE("(%p) Refcount now %u\n", This, ref);
2580 if(!ref){
2581 if(This->client){
2582 EnterCriticalSection(&This->client->lock);
2583 This->client->session_wrapper = NULL;
2584 LeaveCriticalSection(&This->client->lock);
2585 AudioClient_Release(&This->client->IAudioClient_iface);
2586 }
2587 HeapFree(GetProcessHeap(), 0, This);
2588 }
2589 return ref;
2590 }
2591
2592 static HRESULT WINAPI AudioSessionControl_GetState(IAudioSessionControl2 *iface,
2593 AudioSessionState *state)
2594 {
2595 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2596 ACImpl *client;
2597
2598 TRACE("(%p)->(%p)\n", This, state);
2599
2600 if(!state)
2601 return NULL_PTR_ERR;
2602
2603 EnterCriticalSection(&g_sessions_lock);
2604
2605 if(list_empty(&This->session->clients)){
2606 *state = AudioSessionStateExpired;
2607 LeaveCriticalSection(&g_sessions_lock);
2608 return S_OK;
2609 }
2610
2611 LIST_FOR_EACH_ENTRY(client, &This->session->clients, ACImpl, entry){
2612 EnterCriticalSection(&client->lock);
2613 if(client->started){
2614 *state = AudioSessionStateActive;
2615 LeaveCriticalSection(&client->lock);
2616 LeaveCriticalSection(&g_sessions_lock);
2617 return S_OK;
2618 }
2619 LeaveCriticalSection(&client->lock);
2620 }
2621
2622 LeaveCriticalSection(&g_sessions_lock);
2623
2624 *state = AudioSessionStateInactive;
2625
2626 return S_OK;
2627 }
2628
2629 static HRESULT WINAPI AudioSessionControl_GetDisplayName(
2630 IAudioSessionControl2 *iface, WCHAR **name)
2631 {
2632 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2633
2634 FIXME("(%p)->(%p) - stub\n", This, name);
2635
2636 return E_NOTIMPL;
2637 }
2638
2639 static HRESULT WINAPI AudioSessionControl_SetDisplayName(
2640 IAudioSessionControl2 *iface, const WCHAR *name, const GUID *session)
2641 {
2642 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2643
2644 FIXME("(%p)->(%p, %s) - stub\n", This, name, debugstr_guid(session));
2645
2646 return E_NOTIMPL;
2647 }
2648
2649 static HRESULT WINAPI AudioSessionControl_GetIconPath(
2650 IAudioSessionControl2 *iface, WCHAR **path)
2651 {
2652 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2653
2654 FIXME("(%p)->(%p) - stub\n", This, path);
2655
2656 return E_NOTIMPL;
2657 }
2658
2659 static HRESULT WINAPI AudioSessionControl_SetIconPath(
2660 IAudioSessionControl2 *iface, const WCHAR *path, const GUID *session)
2661 {
2662 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2663
2664 FIXME("(%p)->(%p, %s) - stub\n", This, path, debugstr_guid(session));
2665
2666 return E_NOTIMPL;
2667 }
2668
2669 static HRESULT WINAPI AudioSessionControl_GetGroupingParam(
2670 IAudioSessionControl2 *iface, GUID *group)
2671 {
2672 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2673
2674 FIXME("(%p)->(%p) - stub\n", This, group);
2675
2676 return E_NOTIMPL;
2677 }
2678
2679 static HRESULT WINAPI AudioSessionControl_SetGroupingParam(
2680 IAudioSessionControl2 *iface, const GUID *group, const GUID *session)
2681 {
2682 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2683
2684 FIXME("(%p)->(%s, %s) - stub\n", This, debugstr_guid(group),
2685 debugstr_guid(session));
2686
2687 return E_NOTIMPL;
2688 }
2689
2690 static HRESULT WINAPI AudioSessionControl_RegisterAudioSessionNotification(
2691 IAudioSessionControl2 *iface, IAudioSessionEvents *events)
2692 {
2693 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2694
2695 FIXME("(%p)->(%p) - stub\n", This, events);
2696
2697 return S_OK;
2698 }
2699
2700 static HRESULT WINAPI AudioSessionControl_UnregisterAudioSessionNotification(
2701 IAudioSessionControl2 *iface, IAudioSessionEvents *events)
2702 {
2703 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2704
2705 FIXME("(%p)->(%p) - stub\n", This, events);
2706
2707 return S_OK;
2708 }
2709
2710 static HRESULT WINAPI AudioSessionControl_GetSessionIdentifier(
2711 IAudioSessionControl2 *iface, WCHAR **id)
2712 {
2713 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2714
2715 FIXME("(%p)->(%p) - stub\n", This, id);
2716
2717 return E_NOTIMPL;
2718 }
2719
2720 static HRESULT WINAPI AudioSessionControl_GetSessionInstanceIdentifier(
2721 IAudioSessionControl2 *iface, WCHAR **id)
2722 {
2723 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2724
2725 FIXME("(%p)->(%p) - stub\n", This, id);
2726
2727 return E_NOTIMPL;
2728 }
2729
2730 static HRESULT WINAPI AudioSessionControl_GetProcessId(
2731 IAudioSessionControl2 *iface, DWORD *pid)
2732 {
2733 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2734
2735 TRACE("(%p)->(%p)\n", This, pid);
2736
2737 if(!pid)
2738 return E_POINTER;
2739
2740 *pid = GetCurrentProcessId();
2741
2742 return S_OK;
2743 }
2744
2745 static HRESULT WINAPI AudioSessionControl_IsSystemSoundsSession(
2746 IAudioSessionControl2 *iface)
2747 {
2748 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2749
2750 TRACE("(%p)\n", This);
2751
2752 return S_FALSE;
2753 }
2754
2755 static HRESULT WINAPI AudioSessionControl_SetDuckingPreference(
2756 IAudioSessionControl2 *iface, BOOL optout)
2757 {
2758 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2759
2760 TRACE("(%p)->(%d)\n", This, optout);
2761
2762 return S_OK;
2763 }
2764
2765 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl =
2766 {
2767 AudioSessionControl_QueryInterface,
2768 AudioSessionControl_AddRef,
2769 AudioSessionControl_Release,
2770 AudioSessionControl_GetState,
2771 AudioSessionControl_GetDisplayName,
2772 AudioSessionControl_SetDisplayName,
2773 AudioSessionControl_GetIconPath,
2774 AudioSessionControl_SetIconPath,
2775 AudioSessionControl_GetGroupingParam,
2776 AudioSessionControl_SetGroupingParam,
2777 AudioSessionControl_RegisterAudioSessionNotification,
2778 AudioSessionControl_UnregisterAudioSessionNotification,
2779 AudioSessionControl_GetSessionIdentifier,
2780 AudioSessionControl_GetSessionInstanceIdentifier,
2781 AudioSessionControl_GetProcessId,
2782 AudioSessionControl_IsSystemSoundsSession,
2783 AudioSessionControl_SetDuckingPreference
2784 };
2785
2786 static HRESULT WINAPI SimpleAudioVolume_QueryInterface(
2787 ISimpleAudioVolume *iface, REFIID riid, void **ppv)
2788 {
2789 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2790
2791 if(!ppv)
2792 return E_POINTER;
2793 *ppv = NULL;
2794
2795 if(IsEqualIID(riid, &IID_IUnknown) ||
2796 IsEqualIID(riid, &IID_ISimpleAudioVolume))
2797 *ppv = iface;
2798 if(*ppv){
2799 IUnknown_AddRef((IUnknown*)*ppv);
2800 return S_OK;
2801 }
2802
2803 WARN("Unknown interface %s\n", debugstr_guid(riid));
2804 return E_NOINTERFACE;
2805 }
2806
2807 static ULONG WINAPI SimpleAudioVolume_AddRef(ISimpleAudioVolume *iface)
2808 {
2809 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2810 return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
2811 }
2812
2813 static ULONG WINAPI SimpleAudioVolume_Release(ISimpleAudioVolume *iface)
2814 {
2815 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2816 return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
2817 }
2818
2819 static HRESULT WINAPI SimpleAudioVolume_SetMasterVolume(
2820 ISimpleAudioVolume *iface, float level, const GUID *context)
2821 {
2822 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2823 AudioSession *session = This->session;
2824
2825 TRACE("(%p)->(%f, %s)\n", session, level, wine_dbgstr_guid(context));
2826
2827 if(level < 0.f || level > 1.f)
2828 return E_INVALIDARG;
2829
2830 if(context)
2831 FIXME("Notifications not supported yet\n");
2832
2833 TRACE("ALSA does not support volume control\n");
2834
2835 EnterCriticalSection(&session->lock);
2836
2837 session->master_vol = level;
2838
2839 LeaveCriticalSection(&session->lock);
2840
2841 return S_OK;
2842 }
2843
2844 static HRESULT WINAPI SimpleAudioVolume_GetMasterVolume(
2845 ISimpleAudioVolume *iface, float *level)
2846 {
2847 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2848 AudioSession *session = This->session;
2849
2850 TRACE("(%p)->(%p)\n", session, level);
2851
2852 if(!level)
2853 return NULL_PTR_ERR;
2854
2855 *level = session->master_vol;
2856
2857 return S_OK;
2858 }
2859
2860 static HRESULT WINAPI SimpleAudioVolume_SetMute(ISimpleAudioVolume *iface,
2861 BOOL mute, const GUID *context)
2862 {
2863 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2864 AudioSession *session = This->session;
2865
2866 TRACE("(%p)->(%u, %p)\n", session, mute, context);
2867
2868 if(context)
2869 FIXME("Notifications not supported yet\n");
2870
2871 session->mute = mute;
2872
2873 return S_OK;
2874 }
2875
2876 static HRESULT WINAPI SimpleAudioVolume_GetMute(ISimpleAudioVolume *iface,
2877 BOOL *mute)
2878 {
2879 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2880 AudioSession *session = This->session;
2881
2882 TRACE("(%p)->(%p)\n", session, mute);
2883
2884 if(!mute)
2885 return NULL_PTR_ERR;
2886
2887 *mute = session->mute;
2888
2889 return S_OK;
2890 }
2891
2892 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl =
2893 {
2894 SimpleAudioVolume_QueryInterface,
2895 SimpleAudioVolume_AddRef,
2896 SimpleAudioVolume_Release,
2897 SimpleAudioVolume_SetMasterVolume,
2898 SimpleAudioVolume_GetMasterVolume,
2899 SimpleAudioVolume_SetMute,
2900 SimpleAudioVolume_GetMute
2901 };
2902
2903 static HRESULT WINAPI AudioStreamVolume_QueryInterface(
2904 IAudioStreamVolume *iface, REFIID riid, void **ppv)
2905 {
2906 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2907
2908 if(!ppv)
2909 return E_POINTER;
2910 *ppv = NULL;
2911
2912 if(IsEqualIID(riid, &IID_IUnknown) ||
2913 IsEqualIID(riid, &IID_IAudioStreamVolume))
2914 *ppv = iface;
2915 if(*ppv){
2916 IUnknown_AddRef((IUnknown*)*ppv);
2917 return S_OK;
2918 }
2919
2920 WARN("Unknown interface %s\n", debugstr_guid(riid));
2921 return E_NOINTERFACE;
2922 }
2923
2924 static ULONG WINAPI AudioStreamVolume_AddRef(IAudioStreamVolume *iface)
2925 {
2926 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2927 return IAudioClient_AddRef(&This->IAudioClient_iface);
2928 }
2929
2930 static ULONG WINAPI AudioStreamVolume_Release(IAudioStreamVolume *iface)
2931 {
2932 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2933 return IAudioClient_Release(&This->IAudioClient_iface);
2934 }
2935
2936 static HRESULT WINAPI AudioStreamVolume_GetChannelCount(
2937 IAudioStreamVolume *iface, UINT32 *out)
2938 {
2939 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2940
2941 TRACE("(%p)->(%p)\n", This, out);
2942
2943 if(!out)
2944 return E_POINTER;
2945
2946 *out = This->fmt->nChannels;
2947
2948 return S_OK;
2949 }
2950
2951 static HRESULT WINAPI AudioStreamVolume_SetChannelVolume(
2952 IAudioStreamVolume *iface, UINT32 index, float level)
2953 {
2954 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2955
2956 TRACE("(%p)->(%d, %f)\n", This, index, level);
2957
2958 if(level < 0.f || level > 1.f)
2959 return E_INVALIDARG;
2960
2961 if(index >= This->fmt->nChannels)
2962 return E_INVALIDARG;
2963
2964 TRACE("ALSA does not support volume control\n");
2965
2966 EnterCriticalSection(&This->lock);
2967
2968 This->vols[index] = level;
2969
2970 LeaveCriticalSection(&This->lock);
2971
2972 return S_OK;
2973 }
2974
2975 static HRESULT WINAPI AudioStreamVolume_GetChannelVolume(
2976 IAudioStreamVolume *iface, UINT32 index, float *level)
2977 {
2978 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2979
2980 TRACE("(%p)->(%d, %p)\n", This, index, level);
2981
2982 if(!level)
2983 return E_POINTER;
2984
2985 if(index >= This->fmt->nChannels)
2986 return E_INVALIDARG;
2987
2988 *level = This->vols[index];
2989
2990 return S_OK;
2991 }
2992
2993 static HRESULT WINAPI AudioStreamVolume_SetAllVolumes(
2994 IAudioStreamVolume *iface, UINT32 count, const float *levels)
2995 {
2996 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2997 int i;
2998
2999 TRACE("(%p)->(%d, %p)\n", This, count, levels);
3000
3001 if(!levels)
3002 return E_POINTER;
3003
3004 if(count != This->fmt->nChannels)
3005 return E_INVALIDARG;
3006
3007 TRACE("ALSA does not support volume control\n");
3008
3009 EnterCriticalSection(&This->lock);
3010
3011 for(i = 0; i < count; ++i)
3012 This->vols[i] = levels[i];
3013
3014 LeaveCriticalSection(&This->lock);
3015
3016 return S_OK;
3017 }
3018
3019 static HRESULT WINAPI AudioStreamVolume_GetAllVolumes(
3020 IAudioStreamVolume *iface, UINT32 count, float *levels)
3021 {
3022 ACImpl *This = impl_from_IAudioStreamVolume(iface);
3023 int i;
3024
3025 TRACE("(%p)->(%d, %p)\n", This, count, levels);
3026
3027 if(!levels)
3028 return E_POINTER;
3029
3030 if(count != This->fmt->nChannels)
3031 return E_INVALIDARG;
3032
3033 EnterCriticalSection(&This->lock);
3034
3035 for(i = 0; i < count; ++i)
3036 levels[i] = This->vols[i];
3037
3038 LeaveCriticalSection(&This->lock);
3039
3040 return S_OK;
3041 }
3042
3043 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl =
3044 {
3045 AudioStreamVolume_QueryInterface,
3046 AudioStreamVolume_AddRef,
3047 AudioStreamVolume_Release,
3048 AudioStreamVolume_GetChannelCount,
3049 AudioStreamVolume_SetChannelVolume,
3050 AudioStreamVolume_GetChannelVolume,
3051 AudioStreamVolume_SetAllVolumes,
3052 AudioStreamVolume_GetAllVolumes
3053 };
3054
3055 static HRESULT WINAPI ChannelAudioVolume_QueryInterface(
3056 IChannelAudioVolume *iface, REFIID riid, void **ppv)
3057 {
3058 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3059
3060 if(!ppv)
3061 return E_POINTER;
3062 *ppv = NULL;
3063
3064 if(IsEqualIID(riid, &IID_IUnknown) ||
3065 IsEqualIID(riid, &IID_IChannelAudioVolume))
3066 *ppv = iface;
3067 if(*ppv){
3068 IUnknown_AddRef((IUnknown*)*ppv);
3069 return S_OK;
3070 }
3071
3072 WARN("Unknown interface %s\n", debugstr_guid(riid));
3073 return E_NOINTERFACE;
3074 }
3075
3076 static ULONG WINAPI ChannelAudioVolume_AddRef(IChannelAudioVolume *iface)
3077 {
3078 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3079 return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
3080 }
3081
3082 static ULONG WINAPI ChannelAudioVolume_Release(IChannelAudioVolume *iface)
3083 {
3084 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3085 return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
3086 }
3087
3088 static HRESULT WINAPI ChannelAudioVolume_GetChannelCount(
3089 IChannelAudioVolume *iface, UINT32 *out)
3090 {
3091 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3092 AudioSession *session = This->session;
3093
3094 TRACE("(%p)->(%p)\n", session, out);
3095
3096 if(!out)
3097 return NULL_PTR_ERR;
3098
3099 *out = session->channel_count;
3100
3101 return S_OK;
3102 }
3103
3104 static HRESULT WINAPI ChannelAudioVolume_SetChannelVolume(
3105 IChannelAudioVolume *iface, UINT32 index, float level,
3106 const GUID *context)
3107 {
3108 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3109 AudioSession *session = This->session;
3110
3111 TRACE("(%p)->(%d, %f, %s)\n", session, index, level,
3112 wine_dbgstr_guid(context));
3113
3114 if(level < 0.f || level > 1.f)
3115 return E_INVALIDARG;
3116
3117 if(index >= session->channel_count)
3118 return E_INVALIDARG;
3119
3120 if(context)
3121 FIXME("Notifications not supported yet\n");
3122
3123 TRACE("ALSA does not support volume control\n");
3124
3125 EnterCriticalSection(&session->lock);
3126
3127 session->channel_vols[index] = level;
3128
3129 LeaveCriticalSection(&session->lock);
3130
3131 return S_OK;
3132 }
3133
3134 static HRESULT WINAPI ChannelAudioVolume_GetChannelVolume(
3135 IChannelAudioVolume *iface, UINT32 index, float *level)
3136 {
3137 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3138 AudioSession *session = This->session;
3139
3140 TRACE("(%p)->(%d, %p)\n", session, index, level);
3141
3142 if(!level)
3143 return NULL_PTR_ERR;
3144
3145 if(index >= session->channel_count)
3146 return E_INVALIDARG;
3147
3148 *level = session->channel_vols[index];
3149
3150 return S_OK;
3151 }
3152
3153 static HRESULT WINAPI ChannelAudioVolume_SetAllVolumes(
3154 IChannelAudioVolume *iface, UINT32 count, const float *levels,
3155 const GUID *context)
3156 {
3157 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3158 AudioSession *session = This->session;
3159 int i;
3160
3161 TRACE("(%p)->(%d, %p, %s)\n", session, count, levels,
3162 wine_dbgstr_guid(context));
3163
3164 if(!levels)
3165 return NULL_PTR_ERR;
3166
3167 if(count != session->channel_count)
3168 return E_INVALIDARG;
3169
3170 if(context)
3171 FIXME("Notifications not supported yet\n");
3172
3173 TRACE("ALSA does not support volume control\n");
3174
3175 EnterCriticalSection(&session->lock);
3176
3177 for(i = 0; i < count; ++i)
3178 session->channel_vols[i] = levels[i];
3179
3180 LeaveCriticalSection(&session->lock);
3181
3182 return S_OK;
3183 }
3184
3185 static HRESULT WINAPI ChannelAudioVolume_GetAllVolumes(
3186 IChannelAudioVolume *iface, UINT32 count, float *levels)
3187 {
3188 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3189 AudioSession *session = This->session;
3190 int i;
3191
3192 TRACE("(%p)->(%d, %p)\n", session, count, levels);
3193
3194 if(!levels)
3195 return NULL_PTR_ERR;
3196
3197 if(count != session->channel_count)
3198 return E_INVALIDARG;
3199
3200 for(i = 0; i < count; ++i)
3201 levels[i] = session->channel_vols[i];
3202
3203 return S_OK;
3204 }
3205
3206 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl =
3207 {
3208 ChannelAudioVolume_QueryInterface,
3209 ChannelAudioVolume_AddRef,
3210 ChannelAudioVolume_Release,
3211 ChannelAudioVolume_GetChannelCount,
3212 ChannelAudioVolume_SetChannelVolume,
3213 ChannelAudioVolume_GetChannelVolume,
3214 ChannelAudioVolume_SetAllVolumes,
3215 ChannelAudioVolume_GetAllVolumes
3216 };
3217
3218 static HRESULT WINAPI AudioSessionManager_QueryInterface(IAudioSessionManager2 *iface,
3219 REFIID riid, void **ppv)
3220 {
3221 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3222
3223 if(!ppv)
3224 return E_POINTER;
3225 *ppv = NULL;
3226
3227 if(IsEqualIID(riid, &IID_IUnknown) ||
3228 IsEqualIID(riid, &IID_IAudioSessionManager) ||
3229 IsEqualIID(riid, &IID_IAudioSessionManager2))
3230 *ppv = iface;
3231 if(*ppv){
3232 IUnknown_AddRef((IUnknown*)*ppv);
3233 return S_OK;
3234 }
3235
3236 WARN("Unknown interface %s\n", debugstr_guid(riid));
3237 return E_NOINTERFACE;
3238 }
3239
3240 static ULONG WINAPI AudioSessionManager_AddRef(IAudioSessionManager2 *iface)
3241 {
3242 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3243 ULONG ref;
3244 ref = InterlockedIncrement(&This->ref);
3245 TRACE("(%p) Refcount now %u\n", This, ref);
3246 return ref;
3247 }
3248
3249 static ULONG WINAPI AudioSessionManager_Release(IAudioSessionManager2 *iface)
3250 {
3251 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3252 ULONG ref;
3253 ref = InterlockedDecrement(&This->ref);
3254 TRACE("(%p) Refcount now %u\n", This, ref);
3255 if(!ref)
3256 HeapFree(GetProcessHeap(), 0, This);
3257 return ref;
3258 }
3259
3260 static HRESULT WINAPI AudioSessionManager_GetAudioSessionControl(
3261 IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
3262 IAudioSessionControl **out)
3263 {
3264 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3265 AudioSession *session;
3266 AudioSessionWrapper *wrapper;
3267 HRESULT hr;
3268
3269 TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
3270 flags, out);
3271
3272 hr = get_audio_session(session_guid, This->device, 0, &session);
3273 if(FAILED(hr))
3274 return hr;
3275
3276 wrapper = AudioSessionWrapper_Create(NULL);
3277 if(!wrapper)
3278 return E_OUTOFMEMORY;
3279
3280 wrapper->session = session;
3281
3282 *out = (IAudioSessionControl*)&wrapper->IAudioSessionControl2_iface;
3283
3284 return S_OK;
3285 }
3286
3287 static HRESULT WINAPI AudioSessionManager_GetSimpleAudioVolume(
3288 IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
3289 ISimpleAudioVolume **out)
3290 {
3291 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3292 AudioSession *session;
3293 AudioSessionWrapper *wrapper;
3294 HRESULT hr;
3295
3296 TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
3297 flags, out);
3298
3299 hr = get_audio_session(session_guid, This->device, 0, &session);
3300 if(FAILED(hr))
3301 return hr;
3302
3303 wrapper = AudioSessionWrapper_Create(NULL);
3304 if(!wrapper)
3305 return E_OUTOFMEMORY;
3306
3307 wrapper->session = session;
3308
3309 *out = &wrapper->ISimpleAudioVolume_iface;
3310
3311 return S_OK;
3312 }
3313
3314 static HRESULT WINAPI AudioSessionManager_GetSessionEnumerator(
3315 IAudioSessionManager2 *iface, IAudioSessionEnumerator **out)
3316 {
3317 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3318 FIXME("(%p)->(%p) - stub\n", This, out);
3319 return E_NOTIMPL;
3320 }
3321
3322 static HRESULT WINAPI AudioSessionManager_RegisterSessionNotification(
3323 IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
3324 {
3325 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3326 FIXME("(%p)->(%p) - stub\n", This, notification);
3327 return E_NOTIMPL;
3328 }
3329
3330 static HRESULT WINAPI AudioSessionManager_UnregisterSessionNotification(
3331 IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
3332 {
3333 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3334 FIXME("(%p)->(%p) - stub\n", This, notification);
3335 return E_NOTIMPL;
3336 }
3337
3338 static HRESULT WINAPI AudioSessionManager_RegisterDuckNotification(
3339 IAudioSessionManager2 *iface, const WCHAR *session_id,
3340 IAudioVolumeDuckNotification *notification)
3341 {
3342 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3343 FIXME("(%p)->(%p) - stub\n", This, notification);
3344 return E_NOTIMPL;
3345 }
3346
3347 static HRESULT WINAPI AudioSessionManager_UnregisterDuckNotification(
3348 IAudioSessionManager2 *iface,
3349 IAudioVolumeDuckNotification *notification)
3350 {
3351 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3352 FIXME("(%p)->(%p) - stub\n", This, notification);
3353 return E_NOTIMPL;
3354 }
3355
3356 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl =
3357 {
3358 AudioSessionManager_QueryInterface,
3359 AudioSessionManager_AddRef,
3360 AudioSessionManager_Release,
3361 AudioSessionManager_GetAudioSessionControl,
3362 AudioSessionManager_GetSimpleAudioVolume,
3363 AudioSessionManager_GetSessionEnumerator,
3364 AudioSessionManager_RegisterSessionNotification,
3365 AudioSessionManager_UnregisterSessionNotification,
3366 AudioSessionManager_RegisterDuckNotification,
3367 AudioSessionManager_UnregisterDuckNotification
3368 };
3369
3370 HRESULT WINAPI AUDDRV_GetAudioSessionManager(IMMDevice *device,
3371 IAudioSessionManager2 **out)
3372 {
3373 SessionMgr *This;
3374
3375 This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SessionMgr));
3376 if(!This)
3377 return E_OUTOFMEMORY;
3378
3379 This->IAudioSessionManager2_iface.lpVtbl = &AudioSessionManager2_Vtbl;
3380 This->device = device;
3381 This->ref = 1;
3382
3383 *out = &This->IAudioSessionManager2_iface;
3384
3385 return S_OK;
3386 }
Maarten's multimedia branch