?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3dx10: Check device in d3dx10_sprite_GetDevice().
[wine.git] / dlls / winealsa.drv / mmdevdrv.c
blob5f7d277ce9a354194123dbf3b01ef04f1c31db2d
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 #define _GNU_SOURCE
26 #include <stdio.h>
27 #include <math.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winnls.h"
32 #include "winreg.h"
33 #include "wine/debug.h"
34 #include "wine/unicode.h"
35 #include "wine/list.h"
36
37 #include "propsys.h"
38 #include "initguid.h"
39 #include "ole2.h"
40 #include "propkey.h"
41 #include "mmdeviceapi.h"
42 #include "devpkey.h"
43 #include "mmsystem.h"
44 #include "dsound.h"
45
46 #include "initguid.h"
47 #include "endpointvolume.h"
48 #include "audioclient.h"
49 #include "audiopolicy.h"
50
51 #include <alsa/asoundlib.h>
52
53 WINE_DEFAULT_DEBUG_CHANNEL(alsa);
54 WINE_DECLARE_DEBUG_CHANNEL(winediag);
55
56 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
57
58 static const REFERENCE_TIME DefaultPeriod = 100000;
59 static const REFERENCE_TIME MinimumPeriod = 50000;
60 #define EXTRA_SAFE_RT 40000
61
62 struct ACImpl;
63 typedef struct ACImpl ACImpl;
64
65 typedef struct _AudioSession {
66 GUID guid;
67 struct list clients;
68
69 IMMDevice *device;
70
71 float master_vol;
72 UINT32 channel_count;
73 float *channel_vols;
74 BOOL mute;
75
76 CRITICAL_SECTION lock;
77
78 struct list entry;
79 } AudioSession;
80
81 typedef struct _AudioSessionWrapper {
82 IAudioSessionControl2 IAudioSessionControl2_iface;
83 IChannelAudioVolume IChannelAudioVolume_iface;
84 ISimpleAudioVolume ISimpleAudioVolume_iface;
85
86 LONG ref;
87
88 ACImpl *client;
89 AudioSession *session;
90 } AudioSessionWrapper;
91
92 struct ACImpl {
93 IAudioClient3 IAudioClient3_iface;
94 IAudioRenderClient IAudioRenderClient_iface;
95 IAudioCaptureClient IAudioCaptureClient_iface;
96 IAudioClock IAudioClock_iface;
97 IAudioClock2 IAudioClock2_iface;
98 IAudioStreamVolume IAudioStreamVolume_iface;
99
100 LONG ref;
101
102 snd_pcm_t *pcm_handle;
103 snd_pcm_uframes_t alsa_bufsize_frames, alsa_period_frames, safe_rewind_frames;
104 snd_pcm_hw_params_t *hw_params; /* does not hold state between calls */
105 snd_pcm_format_t alsa_format;
106
107 LARGE_INTEGER last_period_time;
108
109 IMMDevice *parent;
110 IUnknown *pUnkFTMarshal;
111
112 EDataFlow dataflow;
113 WAVEFORMATEX *fmt;
114 DWORD flags;
115 AUDCLNT_SHAREMODE share;
116 HANDLE event;
117 float *vols;
118
119 BOOL need_remapping;
120 int alsa_channels;
121 int alsa_channel_map[32];
122
123 BOOL initted, started;
124 REFERENCE_TIME mmdev_period_rt;
125 UINT64 written_frames, last_pos_frames;
126 UINT32 bufsize_frames, held_frames, tmp_buffer_frames, mmdev_period_frames;
127 snd_pcm_uframes_t remapping_buf_frames;
128 UINT32 lcl_offs_frames; /* offs into local_buffer where valid data starts */
129 UINT32 wri_offs_frames; /* where to write fresh data in local_buffer */
130 UINT32 hidden_frames; /* ALSA reserve to ensure continuous rendering */
131 UINT32 vol_adjusted_frames; /* Frames we've already adjusted the volume of but didn't write yet */
132 UINT32 data_in_alsa_frames;
133
134 HANDLE timer;
135 BYTE *local_buffer, *tmp_buffer, *remapping_buf, *silence_buf;
136 LONG32 getbuf_last; /* <0 when using tmp_buffer */
137
138 CRITICAL_SECTION lock;
139
140 AudioSession *session;
141 AudioSessionWrapper *session_wrapper;
142
143 struct list entry;
144 };
145
146 typedef struct _SessionMgr {
147 IAudioSessionManager2 IAudioSessionManager2_iface;
148
149 LONG ref;
150
151 IMMDevice *device;
152 } SessionMgr;
153
154 static HANDLE g_timer_q;
155
156 static CRITICAL_SECTION g_sessions_lock;
157 static CRITICAL_SECTION_DEBUG g_sessions_lock_debug =
158 {
159 0, 0, &g_sessions_lock,
160 { &g_sessions_lock_debug.ProcessLocksList, &g_sessions_lock_debug.ProcessLocksList },
161 0, 0, { (DWORD_PTR)(__FILE__ ": g_sessions_lock") }
162 };
163 static CRITICAL_SECTION g_sessions_lock = { &g_sessions_lock_debug, -1, 0, 0, 0, 0 };
164 static struct list g_sessions = LIST_INIT(g_sessions);
165
166 static const WCHAR defaultW[] = {'d','e','f','a','u','l','t',0};
167 static const char defname[] = "default";
168
169 static const WCHAR drv_keyW[] = {'S','o','f','t','w','a','r','e','\\',
170 'W','i','n','e','\\','D','r','i','v','e','r','s','\\',
171 'w','i','n','e','a','l','s','a','.','d','r','v',0};
172 static const WCHAR drv_key_devicesW[] = {'S','o','f','t','w','a','r','e','\\',
173 'W','i','n','e','\\','D','r','i','v','e','r','s','\\',
174 'w','i','n','e','a','l','s','a','.','d','r','v','\\','d','e','v','i','c','e','s',0};
175 static const WCHAR guidW[] = {'g','u','i','d',0};
176
177 static const IAudioClient3Vtbl AudioClient3_Vtbl;
178 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl;
179 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl;
180 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl;
181 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl;
182 static const IAudioClockVtbl AudioClock_Vtbl;
183 static const IAudioClock2Vtbl AudioClock2_Vtbl;
184 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl;
185 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl;
186 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl;
187
188 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client);
189
190 static inline ACImpl *impl_from_IAudioClient3(IAudioClient3 *iface)
191 {
192 return CONTAINING_RECORD(iface, ACImpl, IAudioClient3_iface);
193 }
194
195 static inline ACImpl *impl_from_IAudioRenderClient(IAudioRenderClient *iface)
196 {
197 return CONTAINING_RECORD(iface, ACImpl, IAudioRenderClient_iface);
198 }
199
200 static inline ACImpl *impl_from_IAudioCaptureClient(IAudioCaptureClient *iface)
201 {
202 return CONTAINING_RECORD(iface, ACImpl, IAudioCaptureClient_iface);
203 }
204
205 static inline AudioSessionWrapper *impl_from_IAudioSessionControl2(IAudioSessionControl2 *iface)
206 {
207 return CONTAINING_RECORD(iface, AudioSessionWrapper, IAudioSessionControl2_iface);
208 }
209
210 static inline AudioSessionWrapper *impl_from_ISimpleAudioVolume(ISimpleAudioVolume *iface)
211 {
212 return CONTAINING_RECORD(iface, AudioSessionWrapper, ISimpleAudioVolume_iface);
213 }
214
215 static inline AudioSessionWrapper *impl_from_IChannelAudioVolume(IChannelAudioVolume *iface)
216 {
217 return CONTAINING_RECORD(iface, AudioSessionWrapper, IChannelAudioVolume_iface);
218 }
219
220 static inline ACImpl *impl_from_IAudioClock(IAudioClock *iface)
221 {
222 return CONTAINING_RECORD(iface, ACImpl, IAudioClock_iface);
223 }
224
225 static inline ACImpl *impl_from_IAudioClock2(IAudioClock2 *iface)
226 {
227 return CONTAINING_RECORD(iface, ACImpl, IAudioClock2_iface);
228 }
229
230 static inline ACImpl *impl_from_IAudioStreamVolume(IAudioStreamVolume *iface)
231 {
232 return CONTAINING_RECORD(iface, ACImpl, IAudioStreamVolume_iface);
233 }
234
235 static inline SessionMgr *impl_from_IAudioSessionManager2(IAudioSessionManager2 *iface)
236 {
237 return CONTAINING_RECORD(iface, SessionMgr, IAudioSessionManager2_iface);
238 }
239
240 BOOL WINAPI DllMain(HINSTANCE dll, DWORD reason, void *reserved)
241 {
242 switch (reason)
243 {
244 case DLL_PROCESS_ATTACH:
245 g_timer_q = CreateTimerQueue();
246 if(!g_timer_q)
247 return FALSE;
248 break;
249
250 case DLL_PROCESS_DETACH:
251 if (reserved) break;
252 DeleteCriticalSection(&g_sessions_lock);
253 break;
254 }
255 return TRUE;
256 }
257
258 /* From <dlls/mmdevapi/mmdevapi.h> */
259 enum DriverPriority {
260 Priority_Unavailable = 0,
261 Priority_Low,
262 Priority_Neutral,
263 Priority_Preferred
264 };
265
266 int WINAPI AUDDRV_GetPriority(void)
267 {
268 return Priority_Neutral;
269 }
270
271 static void set_device_guid(EDataFlow flow, HKEY drv_key, const WCHAR *key_name,
272 GUID *guid)
273 {
274 HKEY key;
275 BOOL opened = FALSE;
276 LONG lr;
277
278 if(!drv_key){
279 lr = RegCreateKeyExW(HKEY_CURRENT_USER, drv_key_devicesW, 0, NULL, 0, KEY_WRITE,
280 NULL, &drv_key, NULL);
281 if(lr != ERROR_SUCCESS){
282 ERR("RegCreateKeyEx(drv_key) failed: %u\n", lr);
283 return;
284 }
285 opened = TRUE;
286 }
287
288 lr = RegCreateKeyExW(drv_key, key_name, 0, NULL, 0, KEY_WRITE,
289 NULL, &key, NULL);
290 if(lr != ERROR_SUCCESS){
291 ERR("RegCreateKeyEx(%s) failed: %u\n", wine_dbgstr_w(key_name), lr);
292 goto exit;
293 }
294
295 lr = RegSetValueExW(key, guidW, 0, REG_BINARY, (BYTE*)guid,
296 sizeof(GUID));
297 if(lr != ERROR_SUCCESS)
298 ERR("RegSetValueEx(%s\\guid) failed: %u\n", wine_dbgstr_w(key_name), lr);
299
300 RegCloseKey(key);
301 exit:
302 if(opened)
303 RegCloseKey(drv_key);
304 }
305
306 static void get_device_guid(EDataFlow flow, const char *device, GUID *guid)
307 {
308 HKEY key = NULL, dev_key;
309 DWORD type, size = sizeof(*guid);
310 WCHAR key_name[256];
311
312 if(flow == eCapture)
313 key_name[0] = '1';
314 else
315 key_name[0] = '0';
316 key_name[1] = ',';
317 MultiByteToWideChar(CP_UNIXCP, 0, device, -1, key_name + 2, ARRAY_SIZE(key_name) - 2);
318
319 if(RegOpenKeyExW(HKEY_CURRENT_USER, drv_key_devicesW, 0, KEY_WRITE|KEY_READ, &key) == ERROR_SUCCESS){
320 if(RegOpenKeyExW(key, key_name, 0, KEY_READ, &dev_key) == ERROR_SUCCESS){
321 if(RegQueryValueExW(dev_key, guidW, 0, &type,
322 (BYTE*)guid, &size) == ERROR_SUCCESS){
323 if(type == REG_BINARY){
324 RegCloseKey(dev_key);
325 RegCloseKey(key);
326 return;
327 }
328 ERR("Invalid type for device %s GUID: %u; ignoring and overwriting\n",
329 wine_dbgstr_w(key_name), type);
330 }
331 RegCloseKey(dev_key);
332 }
333 }
334
335 CoCreateGuid(guid);
336
337 set_device_guid(flow, key, key_name, guid);
338
339 if(key)
340 RegCloseKey(key);
341 }
342
343 static BOOL alsa_try_open(const char *devnode, snd_pcm_stream_t stream)
344 {
345 snd_pcm_t *handle;
346 int err;
347
348 TRACE("devnode: %s, stream: %d\n", devnode, stream);
349
350 if((err = snd_pcm_open(&handle, devnode, stream, SND_PCM_NONBLOCK)) < 0){
351 WARN("The device \"%s\" failed to open: %d (%s).\n",
352 devnode, err, snd_strerror(err));
353 return FALSE;
354 }
355
356 snd_pcm_close(handle);
357 return TRUE;
358 }
359
360 static WCHAR *construct_device_id(EDataFlow flow, const WCHAR *chunk1, const char *chunk2)
361 {
362 WCHAR *ret;
363 const WCHAR *prefix;
364 DWORD len_wchars = 0, chunk1_len = 0, copied = 0, prefix_len;
365
366 static const WCHAR dashW[] = {' ','-',' ',0};
367 static const size_t dashW_len = ARRAY_SIZE(dashW) - 1;
368 static const WCHAR outW[] = {'O','u','t',':',' ',0};
369 static const WCHAR inW[] = {'I','n',':',' ',0};
370
371 if(flow == eRender){
372 prefix = outW;
373 prefix_len = ARRAY_SIZE(outW) - 1;
374 len_wchars += prefix_len;
375 }else{
376 prefix = inW;
377 prefix_len = ARRAY_SIZE(inW) - 1;
378 len_wchars += prefix_len;
379 }
380 if(chunk1){
381 chunk1_len = strlenW(chunk1);
382 len_wchars += chunk1_len;
383 }
384 if(chunk1 && chunk2)
385 len_wchars += dashW_len;
386 if(chunk2)
387 len_wchars += MultiByteToWideChar(CP_UNIXCP, 0, chunk2, -1, NULL, 0) - 1;
388 len_wchars += 1; /* NULL byte */
389
390 ret = HeapAlloc(GetProcessHeap(), 0, len_wchars * sizeof(WCHAR));
391
392 memcpy(ret, prefix, prefix_len * sizeof(WCHAR));
393 copied += prefix_len;
394 if(chunk1){
395 memcpy(ret + copied, chunk1, chunk1_len * sizeof(WCHAR));
396 copied += chunk1_len;
397 }
398 if(chunk1 && chunk2){
399 memcpy(ret + copied, dashW, dashW_len * sizeof(WCHAR));
400 copied += dashW_len;
401 }
402 if(chunk2){
403 MultiByteToWideChar(CP_UNIXCP, 0, chunk2, -1, ret + copied, len_wchars - copied);
404 }else
405 ret[copied] = 0;
406
407 TRACE("Enumerated device: %s\n", wine_dbgstr_w(ret));
408
409 return ret;
410 }
411
412 static HRESULT alsa_get_card_devices(EDataFlow flow, snd_pcm_stream_t stream,
413 WCHAR ***ids, GUID **guids, UINT *num, snd_ctl_t *ctl, int card,
414 const WCHAR *cardnameW)
415 {
416 int err, device;
417 snd_pcm_info_t *info;
418
419 info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_info_sizeof());
420 if(!info)
421 return E_OUTOFMEMORY;
422
423 snd_pcm_info_set_subdevice(info, 0);
424 snd_pcm_info_set_stream(info, stream);
425
426 device = -1;
427 for(err = snd_ctl_pcm_next_device(ctl, &device); device != -1 && err >= 0;
428 err = snd_ctl_pcm_next_device(ctl, &device)){
429 const char *devname;
430 char devnode[32];
431
432 snd_pcm_info_set_device(info, device);
433
434 if((err = snd_ctl_pcm_info(ctl, info)) < 0){
435 if(err == -ENOENT)
436 /* This device doesn't have the right stream direction */
437 continue;
438
439 WARN("Failed to get info for card %d, device %d: %d (%s)\n",
440 card, device, err, snd_strerror(err));
441 continue;
442 }
443
444 sprintf(devnode, "plughw:%d,%d", card, device);
445 if(!alsa_try_open(devnode, stream))
446 continue;
447
448 if(*num){
449 *ids = HeapReAlloc(GetProcessHeap(), 0, *ids, sizeof(WCHAR *) * (*num + 1));
450 *guids = HeapReAlloc(GetProcessHeap(), 0, *guids, sizeof(GUID) * (*num + 1));
451 }else{
452 *ids = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR *));
453 *guids = HeapAlloc(GetProcessHeap(), 0, sizeof(GUID));
454 }
455
456 devname = snd_pcm_info_get_name(info);
457 if(!devname){
458 WARN("Unable to get device name for card %d, device %d\n", card,
459 device);
460 continue;
461 }
462
463 (*ids)[*num] = construct_device_id(flow, cardnameW, devname);
464 get_device_guid(flow, devnode, &(*guids)[*num]);
465
466 ++(*num);
467 }
468
469 HeapFree(GetProcessHeap(), 0, info);
470
471 if(err != 0)
472 WARN("Got a failure during device enumeration on card %d: %d (%s)\n",
473 card, err, snd_strerror(err));
474
475 return S_OK;
476 }
477
478 static void get_reg_devices(EDataFlow flow, snd_pcm_stream_t stream, WCHAR ***ids,
479 GUID **guids, UINT *num)
480 {
481 static const WCHAR ALSAOutputDevices[] = {'A','L','S','A','O','u','t','p','u','t','D','e','v','i','c','e','s',0};
482 static const WCHAR ALSAInputDevices[] = {'A','L','S','A','I','n','p','u','t','D','e','v','i','c','e','s',0};
483 HKEY key;
484 WCHAR reg_devices[256];
485 DWORD size = sizeof(reg_devices), type;
486 const WCHAR *value_name = (stream == SND_PCM_STREAM_PLAYBACK) ? ALSAOutputDevices : ALSAInputDevices;
487
488 /* @@ Wine registry key: HKCU\Software\Wine\Drivers\winealsa.drv */
489 if(RegOpenKeyW(HKEY_CURRENT_USER, drv_keyW, &key) == ERROR_SUCCESS){
490 if(RegQueryValueExW(key, value_name, 0, &type,
491 (BYTE*)reg_devices, &size) == ERROR_SUCCESS){
492 WCHAR *p = reg_devices;
493
494 if(type != REG_MULTI_SZ){
495 ERR("Registry ALSA device list value type must be REG_MULTI_SZ\n");
496 RegCloseKey(key);
497 return;
498 }
499
500 while(*p){
501 char devname[64];
502
503 WideCharToMultiByte(CP_UNIXCP, 0, p, -1, devname, sizeof(devname), NULL, NULL);
504
505 if(alsa_try_open(devname, stream)){
506 if(*num){
507 *ids = HeapReAlloc(GetProcessHeap(), 0, *ids, sizeof(WCHAR *) * (*num + 1));
508 *guids = HeapReAlloc(GetProcessHeap(), 0, *guids, sizeof(GUID) * (*num + 1));
509 }else{
510 *ids = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR *));
511 *guids = HeapAlloc(GetProcessHeap(), 0, sizeof(GUID));
512 }
513 (*ids)[*num] = construct_device_id(flow, p, NULL);
514 get_device_guid(flow, devname, &(*guids)[*num]);
515 ++*num;
516 }
517
518 p += lstrlenW(p) + 1;
519 }
520 }
521
522 RegCloseKey(key);
523 }
524 }
525
526 struct card_type {
527 struct list entry;
528 int first_card_number;
529 char string[1];
530 };
531
532 static struct list card_types = LIST_INIT(card_types);
533
534 static BOOL need_card_number(int card, const char *string)
535 {
536 struct card_type *cptr;
537
538 LIST_FOR_EACH_ENTRY(cptr, &card_types, struct card_type, entry)
539 {
540 if(!strcmp(string, cptr->string))
541 return card != cptr->first_card_number;
542 }
543
544 /* this is the first instance of string */
545 cptr = HeapAlloc(GetProcessHeap(), 0, sizeof(struct card_type) + strlen(string));
546 if(!cptr)
547 /* Default to displaying card number if we can't track cards */
548 return TRUE;
549
550 cptr->first_card_number = card;
551 strcpy(cptr->string, string);
552 list_add_head(&card_types, &cptr->entry);
553 return FALSE;
554 }
555
556 static HRESULT alsa_enum_devices(EDataFlow flow, WCHAR ***ids, GUID **guids,
557 UINT *num)
558 {
559 snd_pcm_stream_t stream = (flow == eRender ? SND_PCM_STREAM_PLAYBACK :
560 SND_PCM_STREAM_CAPTURE);
561 int err, card;
562
563 card = -1;
564 *num = 0;
565
566 if(alsa_try_open(defname, stream)){
567 *ids = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR *));
568 (*ids)[0] = construct_device_id(flow, defaultW, NULL);
569 *guids = HeapAlloc(GetProcessHeap(), 0, sizeof(GUID));
570 get_device_guid(flow, defname, &(*guids)[0]);
571 ++*num;
572 }
573
574 get_reg_devices(flow, stream, ids, guids, num);
575
576 for(err = snd_card_next(&card); card != -1 && err >= 0;
577 err = snd_card_next(&card)){
578 char cardpath[64];
579 char *cardname;
580 WCHAR *cardnameW;
581 snd_ctl_t *ctl;
582 DWORD len;
583
584 sprintf(cardpath, "hw:%u", card);
585
586 if((err = snd_ctl_open(&ctl, cardpath, 0)) < 0){
587 WARN("Unable to open ctl for ALSA device %s: %d (%s)\n", cardpath,
588 err, snd_strerror(err));
589 continue;
590 }
591
592 if(snd_card_get_name(card, &cardname) < 0) {
593 /* FIXME: Should be localized */
594 static const WCHAR nameW[] = {'U','n','k','n','o','w','n',' ','s','o','u','n','d','c','a','r','d',0};
595 WARN("Unable to get card name for ALSA device %s: %d (%s)\n",
596 cardpath, err, snd_strerror(err));
597 alsa_get_card_devices(flow, stream, ids, guids, num, ctl, card, nameW);
598 }else{
599 if(need_card_number(card, cardname)){
600 char *cardnameN;
601 /*
602 * For identical card names, second and subsequent instances get
603 * card number prefix to distinguish them (like Windows).
604 */
605 if(asprintf(&cardnameN, "%u-%s", card, cardname) > 0){
606 free(cardname);
607 cardname = cardnameN;
608 }
609 }
610 len = MultiByteToWideChar(CP_UNIXCP, 0, cardname, -1, NULL, 0);
611 cardnameW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
612
613 if(!cardnameW){
614 free(cardname);
615 snd_ctl_close(ctl);
616 return E_OUTOFMEMORY;
617 }
618 MultiByteToWideChar(CP_UNIXCP, 0, cardname, -1, cardnameW, len);
619
620 alsa_get_card_devices(flow, stream, ids, guids, num, ctl, card, cardnameW);
621
622 HeapFree(GetProcessHeap(), 0, cardnameW);
623 free(cardname);
624 }
625
626 snd_ctl_close(ctl);
627 }
628
629 if(err != 0)
630 WARN("Got a failure during card enumeration: %d (%s)\n",
631 err, snd_strerror(err));
632
633 return S_OK;
634 }
635
636 HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids, GUID **guids,
637 UINT *num, UINT *def_index)
638 {
639 HRESULT hr;
640
641 TRACE("%d %p %p %p %p\n", flow, ids, guids, num, def_index);
642
643 *ids = NULL;
644 *guids = NULL;
645
646 hr = alsa_enum_devices(flow, ids, guids, num);
647 if(FAILED(hr)){
648 UINT i;
649 for(i = 0; i < *num; ++i)
650 HeapFree(GetProcessHeap(), 0, (*ids)[i]);
651 HeapFree(GetProcessHeap(), 0, *ids);
652 HeapFree(GetProcessHeap(), 0, *guids);
653 return E_OUTOFMEMORY;
654 }
655
656 TRACE("Enumerated %u devices\n", *num);
657
658 if(*num == 0){
659 HeapFree(GetProcessHeap(), 0, *ids);
660 *ids = NULL;
661 HeapFree(GetProcessHeap(), 0, *guids);
662 *guids = NULL;
663 }
664
665 *def_index = 0;
666
667 return S_OK;
668 }
669
670 /* Using the pulse PCM device from alsa-plugins 1.0.24 triggers a bug
671 * which causes audio to cease playing after a few minutes of playback.
672 * Setting handle_underrun=1 on pulse-backed ALSA devices seems to work
673 * around this issue. */
674 static snd_config_t *make_handle_underrun_config(const char *name)
675 {
676 snd_config_t *lconf, *dev_node, *hu_node, *type_node;
677 char dev_node_name[260];
678 const char *type_str;
679 int err;
680
681 snd_config_update();
682
683 if((err = snd_config_copy(&lconf, snd_config)) < 0){
684 WARN("snd_config_copy failed: %d (%s)\n", err, snd_strerror(err));
685 return NULL;
686 }
687
688 sprintf(dev_node_name, "pcm.%s", name);
689 err = snd_config_search(lconf, dev_node_name, &dev_node);
690 if(err == -ENOENT){
691 snd_config_delete(lconf);
692 return NULL;
693 }
694 if(err < 0){
695 snd_config_delete(lconf);
696 WARN("snd_config_search failed: %d (%s)\n", err, snd_strerror(err));
697 return NULL;
698 }
699
700 /* ALSA is extremely fragile. If it runs into a config setting it doesn't
701 * recognize, it tends to fail or assert. So we only want to inject
702 * handle_underrun=1 on devices that we know will recognize it. */
703 err = snd_config_search(dev_node, "type", &type_node);
704 if(err == -ENOENT){
705 snd_config_delete(lconf);
706 return NULL;
707 }
708 if(err < 0){
709 snd_config_delete(lconf);
710 WARN("snd_config_search failed: %d (%s)\n", err, snd_strerror(err));
711 return NULL;
712 }
713
714 if((err = snd_config_get_string(type_node, &type_str)) < 0){
715 snd_config_delete(lconf);
716 return NULL;
717 }
718
719 if(strcmp(type_str, "pulse") != 0){
720 snd_config_delete(lconf);
721 return NULL;
722 }
723
724 err = snd_config_search(dev_node, "handle_underrun", &hu_node);
725 if(err >= 0){
726 /* user already has an explicit handle_underrun setting, so don't
727 * use a local config */
728 snd_config_delete(lconf);
729 return NULL;
730 }
731 if(err != -ENOENT){
732 snd_config_delete(lconf);
733 WARN("snd_config_search failed: %d (%s)\n", err, snd_strerror(err));
734 return NULL;
735 }
736
737 if((err = snd_config_imake_integer(&hu_node, "handle_underrun", 1)) < 0){
738 snd_config_delete(lconf);
739 WARN("snd_config_imake_integer failed: %d (%s)\n", err,
740 snd_strerror(err));
741 return NULL;
742 }
743
744 if((err = snd_config_add(dev_node, hu_node)) < 0){
745 snd_config_delete(lconf);
746 WARN("snd_config_add failed: %d (%s)\n", err, snd_strerror(err));
747 return NULL;
748 }
749
750 return lconf;
751 }
752
753 static BOOL get_alsa_name_by_guid(GUID *guid, char *name, DWORD name_size, EDataFlow *flow)
754 {
755 HKEY devices_key;
756 UINT i = 0;
757 WCHAR key_name[256];
758 DWORD key_name_size;
759
760 if(RegOpenKeyExW(HKEY_CURRENT_USER, drv_key_devicesW, 0, KEY_READ, &devices_key) != ERROR_SUCCESS){
761 ERR("No devices found in registry?\n");
762 return FALSE;
763 }
764
765 while(1){
766 HKEY key;
767 DWORD size, type;
768 GUID reg_guid;
769
770 key_name_size = ARRAY_SIZE(key_name);
771 if(RegEnumKeyExW(devices_key, i++, key_name, &key_name_size, NULL,
772 NULL, NULL, NULL) != ERROR_SUCCESS)
773 break;
774
775 if(RegOpenKeyExW(devices_key, key_name, 0, KEY_READ, &key) != ERROR_SUCCESS){
776 WARN("Couldn't open key: %s\n", wine_dbgstr_w(key_name));
777 continue;
778 }
779
780 size = sizeof(reg_guid);
781 if(RegQueryValueExW(key, guidW, 0, &type,
782 (BYTE*)&reg_guid, &size) == ERROR_SUCCESS){
783 if(IsEqualGUID(&reg_guid, guid)){
784 RegCloseKey(key);
785 RegCloseKey(devices_key);
786
787 TRACE("Found matching device key: %s\n", wine_dbgstr_w(key_name));
788
789 if(key_name[0] == '0')
790 *flow = eRender;
791 else if(key_name[0] == '1')
792 *flow = eCapture;
793 else{
794 ERR("Unknown device type: %c\n", key_name[0]);
795 return FALSE;
796 }
797
798 WideCharToMultiByte(CP_UNIXCP, 0, key_name + 2, -1, name, name_size, NULL, NULL);
799
800 return TRUE;
801 }
802 }
803
804 RegCloseKey(key);
805 }
806
807 RegCloseKey(devices_key);
808
809 WARN("No matching device in registry for GUID %s\n", debugstr_guid(guid));
810
811 return FALSE;
812 }
813
814 HRESULT WINAPI AUDDRV_GetAudioEndpoint(GUID *guid, IMMDevice *dev, IAudioClient **out)
815 {
816 ACImpl *This;
817 int err;
818 snd_pcm_stream_t stream;
819 snd_config_t *lconf;
820 static BOOL handle_underrun = TRUE;
821 char alsa_name[256];
822 EDataFlow dataflow;
823 HRESULT hr;
824
825 TRACE("%s %p %p\n", debugstr_guid(guid), dev, out);
826
827 if(!get_alsa_name_by_guid(guid, alsa_name, sizeof(alsa_name), &dataflow))
828 return AUDCLNT_E_DEVICE_INVALIDATED;
829
830 This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ACImpl));
831 if(!This)
832 return E_OUTOFMEMORY;
833
834 This->IAudioClient3_iface.lpVtbl = &AudioClient3_Vtbl;
835 This->IAudioRenderClient_iface.lpVtbl = &AudioRenderClient_Vtbl;
836 This->IAudioCaptureClient_iface.lpVtbl = &AudioCaptureClient_Vtbl;
837 This->IAudioClock_iface.lpVtbl = &AudioClock_Vtbl;
838 This->IAudioClock2_iface.lpVtbl = &AudioClock2_Vtbl;
839 This->IAudioStreamVolume_iface.lpVtbl = &AudioStreamVolume_Vtbl;
840
841 if(dataflow == eRender)
842 stream = SND_PCM_STREAM_PLAYBACK;
843 else if(dataflow == eCapture)
844 stream = SND_PCM_STREAM_CAPTURE;
845 else{
846 HeapFree(GetProcessHeap(), 0, This);
847 return E_UNEXPECTED;
848 }
849
850 hr = CoCreateFreeThreadedMarshaler((IUnknown *)&This->IAudioClient3_iface, &This->pUnkFTMarshal);
851 if (FAILED(hr)) {
852 HeapFree(GetProcessHeap(), 0, This);
853 return hr;
854 }
855
856 This->dataflow = dataflow;
857 if(handle_underrun && ((lconf = make_handle_underrun_config(alsa_name)))){
858 err = snd_pcm_open_lconf(&This->pcm_handle, alsa_name, stream, SND_PCM_NONBLOCK, lconf);
859 TRACE("Opening PCM device \"%s\" with handle_underrun: %d\n", alsa_name, err);
860 snd_config_delete(lconf);
861 /* Pulse <= 2010 returns EINVAL, it does not know handle_underrun. */
862 if(err == -EINVAL){
863 ERR_(winediag)("PulseAudio \"%s\" %d without handle_underrun. Audio may hang."
864 " Please upgrade to alsa_plugins >= 1.0.24\n", alsa_name, err);
865 handle_underrun = FALSE;
866 }
867 }else
868 err = -EINVAL;
869 if(err == -EINVAL){
870 err = snd_pcm_open(&This->pcm_handle, alsa_name, stream, SND_PCM_NONBLOCK);
871 }
872 if(err < 0){
873 HeapFree(GetProcessHeap(), 0, This);
874 WARN("Unable to open PCM \"%s\": %d (%s)\n", alsa_name, err, snd_strerror(err));
875 switch(err){
876 case -EBUSY:
877 return AUDCLNT_E_DEVICE_IN_USE;
878 default:
879 return AUDCLNT_E_ENDPOINT_CREATE_FAILED;
880 }
881 }
882
883 This->hw_params = HeapAlloc(GetProcessHeap(), 0,
884 snd_pcm_hw_params_sizeof());
885 if(!This->hw_params){
886 snd_pcm_close(This->pcm_handle);
887 HeapFree(GetProcessHeap(), 0, This);
888 return E_OUTOFMEMORY;
889 }
890
891 InitializeCriticalSection(&This->lock);
892 This->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": ACImpl.lock");
893
894 This->parent = dev;
895 IMMDevice_AddRef(This->parent);
896
897 *out = (IAudioClient *)&This->IAudioClient3_iface;
898 IAudioClient3_AddRef(&This->IAudioClient3_iface);
899
900 return S_OK;
901 }
902
903 static HRESULT WINAPI AudioClient_QueryInterface(IAudioClient3 *iface,
904 REFIID riid, void **ppv)
905 {
906 ACImpl *This = impl_from_IAudioClient3(iface);
907 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
908
909 if(!ppv)
910 return E_POINTER;
911 *ppv = NULL;
912 if(IsEqualIID(riid, &IID_IUnknown) ||
913 IsEqualIID(riid, &IID_IAudioClient) ||
914 IsEqualIID(riid, &IID_IAudioClient2) ||
915 IsEqualIID(riid, &IID_IAudioClient3))
916 *ppv = iface;
917 else if(IsEqualIID(riid, &IID_IMarshal))
918 return IUnknown_QueryInterface(This->pUnkFTMarshal, riid, ppv);
919
920 if(*ppv){
921 IUnknown_AddRef((IUnknown*)*ppv);
922 return S_OK;
923 }
924 WARN("Unknown interface %s\n", debugstr_guid(riid));
925 return E_NOINTERFACE;
926 }
927
928 static ULONG WINAPI AudioClient_AddRef(IAudioClient3 *iface)
929 {
930 ACImpl *This = impl_from_IAudioClient3(iface);
931 ULONG ref;
932 ref = InterlockedIncrement(&This->ref);
933 TRACE("(%p) Refcount now %u\n", This, ref);
934 return ref;
935 }
936
937 static ULONG WINAPI AudioClient_Release(IAudioClient3 *iface)
938 {
939 ACImpl *This = impl_from_IAudioClient3(iface);
940 ULONG ref;
941
942 ref = InterlockedDecrement(&This->ref);
943 TRACE("(%p) Refcount now %u\n", This, ref);
944 if(!ref){
945 if(This->timer){
946 HANDLE event;
947 DWORD wait;
948 event = CreateEventW(NULL, TRUE, FALSE, NULL);
949 wait = !DeleteTimerQueueTimer(g_timer_q, This->timer, event);
950 wait = wait && GetLastError() == ERROR_IO_PENDING;
951 if(event && wait)
952 WaitForSingleObject(event, INFINITE);
953 CloseHandle(event);
954 }
955
956 IAudioClient3_Stop(iface);
957 IMMDevice_Release(This->parent);
958 IUnknown_Release(This->pUnkFTMarshal);
959 This->lock.DebugInfo->Spare[0] = 0;
960 DeleteCriticalSection(&This->lock);
961 snd_pcm_drop(This->pcm_handle);
962 snd_pcm_close(This->pcm_handle);
963 if(This->initted){
964 EnterCriticalSection(&g_sessions_lock);
965 list_remove(&This->entry);
966 LeaveCriticalSection(&g_sessions_lock);
967 }
968 HeapFree(GetProcessHeap(), 0, This->vols);
969 HeapFree(GetProcessHeap(), 0, This->local_buffer);
970 HeapFree(GetProcessHeap(), 0, This->remapping_buf);
971 HeapFree(GetProcessHeap(), 0, This->silence_buf);
972 HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
973 HeapFree(GetProcessHeap(), 0, This->hw_params);
974 CoTaskMemFree(This->fmt);
975 HeapFree(GetProcessHeap(), 0, This);
976 }
977 return ref;
978 }
979
980 static void dump_fmt(const WAVEFORMATEX *fmt)
981 {
982 TRACE("wFormatTag: 0x%x (", fmt->wFormatTag);
983 switch(fmt->wFormatTag){
984 case WAVE_FORMAT_PCM:
985 TRACE("WAVE_FORMAT_PCM");
986 break;
987 case WAVE_FORMAT_IEEE_FLOAT:
988 TRACE("WAVE_FORMAT_IEEE_FLOAT");
989 break;
990 case WAVE_FORMAT_EXTENSIBLE:
991 TRACE("WAVE_FORMAT_EXTENSIBLE");
992 break;
993 default:
994 TRACE("Unknown");
995 break;
996 }
997 TRACE(")\n");
998
999 TRACE("nChannels: %u\n", fmt->nChannels);
1000 TRACE("nSamplesPerSec: %u\n", fmt->nSamplesPerSec);
1001 TRACE("nAvgBytesPerSec: %u\n", fmt->nAvgBytesPerSec);
1002 TRACE("nBlockAlign: %u\n", fmt->nBlockAlign);
1003 TRACE("wBitsPerSample: %u\n", fmt->wBitsPerSample);
1004 TRACE("cbSize: %u\n", fmt->cbSize);
1005
1006 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
1007 WAVEFORMATEXTENSIBLE *fmtex = (void*)fmt;
1008 TRACE("dwChannelMask: %08x\n", fmtex->dwChannelMask);
1009 TRACE("Samples: %04x\n", fmtex->Samples.wReserved);
1010 TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex->SubFormat));
1011 }
1012 }
1013
1014 static WAVEFORMATEX *clone_format(const WAVEFORMATEX *fmt)
1015 {
1016 WAVEFORMATEX *ret;
1017 size_t size;
1018
1019 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
1020 size = sizeof(WAVEFORMATEXTENSIBLE);
1021 else
1022 size = sizeof(WAVEFORMATEX);
1023
1024 ret = CoTaskMemAlloc(size);
1025 if(!ret)
1026 return NULL;
1027
1028 memcpy(ret, fmt, size);
1029
1030 ret->cbSize = size - sizeof(WAVEFORMATEX);
1031
1032 return ret;
1033 }
1034
1035 static snd_pcm_format_t alsa_format(const WAVEFORMATEX *fmt)
1036 {
1037 snd_pcm_format_t format = SND_PCM_FORMAT_UNKNOWN;
1038 const WAVEFORMATEXTENSIBLE *fmtex = (const WAVEFORMATEXTENSIBLE *)fmt;
1039
1040 if(fmt->wFormatTag == WAVE_FORMAT_PCM ||
1041 (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1042 IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))){
1043 if(fmt->wBitsPerSample == 8)
1044 format = SND_PCM_FORMAT_U8;
1045 else if(fmt->wBitsPerSample == 16)
1046 format = SND_PCM_FORMAT_S16_LE;
1047 else if(fmt->wBitsPerSample == 24)
1048 format = SND_PCM_FORMAT_S24_3LE;
1049 else if(fmt->wBitsPerSample == 32)
1050 format = SND_PCM_FORMAT_S32_LE;
1051 else
1052 WARN("Unsupported bit depth: %u\n", fmt->wBitsPerSample);
1053 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1054 fmt->wBitsPerSample != fmtex->Samples.wValidBitsPerSample){
1055 if(fmtex->Samples.wValidBitsPerSample == 20 && fmt->wBitsPerSample == 24)
1056 format = SND_PCM_FORMAT_S20_3LE;
1057 else
1058 WARN("Unsupported ValidBits: %u\n", fmtex->Samples.wValidBitsPerSample);
1059 }
1060 }else if(fmt->wFormatTag == WAVE_FORMAT_IEEE_FLOAT ||
1061 (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1062 IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))){
1063 if(fmt->wBitsPerSample == 32)
1064 format = SND_PCM_FORMAT_FLOAT_LE;
1065 else if(fmt->wBitsPerSample == 64)
1066 format = SND_PCM_FORMAT_FLOAT64_LE;
1067 else
1068 WARN("Unsupported float size: %u\n", fmt->wBitsPerSample);
1069 }else
1070 WARN("Unknown wave format: %04x\n", fmt->wFormatTag);
1071 return format;
1072 }
1073
1074 static void session_init_vols(AudioSession *session, UINT channels)
1075 {
1076 if(session->channel_count < channels){
1077 UINT i;
1078
1079 if(session->channel_vols)
1080 session->channel_vols = HeapReAlloc(GetProcessHeap(), 0,
1081 session->channel_vols, sizeof(float) * channels);
1082 else
1083 session->channel_vols = HeapAlloc(GetProcessHeap(), 0,
1084 sizeof(float) * channels);
1085 if(!session->channel_vols)
1086 return;
1087
1088 for(i = session->channel_count; i < channels; ++i)
1089 session->channel_vols[i] = 1.f;
1090
1091 session->channel_count = channels;
1092 }
1093 }
1094
1095 static AudioSession *create_session(const GUID *guid, IMMDevice *device,
1096 UINT num_channels)
1097 {
1098 AudioSession *ret;
1099
1100 ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(AudioSession));
1101 if(!ret)
1102 return NULL;
1103
1104 memcpy(&ret->guid, guid, sizeof(GUID));
1105
1106 ret->device = device;
1107
1108 list_init(&ret->clients);
1109
1110 list_add_head(&g_sessions, &ret->entry);
1111
1112 InitializeCriticalSection(&ret->lock);
1113 ret->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": AudioSession.lock");
1114
1115 session_init_vols(ret, num_channels);
1116
1117 ret->master_vol = 1.f;
1118
1119 return ret;
1120 }
1121
1122 /* if channels == 0, then this will return or create a session with
1123 * matching dataflow and GUID. otherwise, channels must also match */
1124 static HRESULT get_audio_session(const GUID *sessionguid,
1125 IMMDevice *device, UINT channels, AudioSession **out)
1126 {
1127 AudioSession *session;
1128
1129 if(!sessionguid || IsEqualGUID(sessionguid, &GUID_NULL)){
1130 *out = create_session(&GUID_NULL, device, channels);
1131 if(!*out)
1132 return E_OUTOFMEMORY;
1133
1134 return S_OK;
1135 }
1136
1137 *out = NULL;
1138 LIST_FOR_EACH_ENTRY(session, &g_sessions, AudioSession, entry){
1139 if(session->device == device &&
1140 IsEqualGUID(sessionguid, &session->guid)){
1141 session_init_vols(session, channels);
1142 *out = session;
1143 break;
1144 }
1145 }
1146
1147 if(!*out){
1148 *out = create_session(sessionguid, device, channels);
1149 if(!*out)
1150 return E_OUTOFMEMORY;
1151 }
1152
1153 return S_OK;
1154 }
1155
1156 static int alsa_channel_index(DWORD flag)
1157 {
1158 switch(flag){
1159 case SPEAKER_FRONT_LEFT:
1160 return 0;
1161 case SPEAKER_FRONT_RIGHT:
1162 return 1;
1163 case SPEAKER_BACK_LEFT:
1164 return 2;
1165 case SPEAKER_BACK_RIGHT:
1166 return 3;
1167 case SPEAKER_FRONT_CENTER:
1168 return 4;
1169 case SPEAKER_LOW_FREQUENCY:
1170 return 5;
1171 case SPEAKER_SIDE_LEFT:
1172 return 6;
1173 case SPEAKER_SIDE_RIGHT:
1174 return 7;
1175 }
1176 return -1;
1177 }
1178
1179 static BOOL need_remapping(ACImpl *This, const WAVEFORMATEX *fmt, int *map)
1180 {
1181 unsigned int i;
1182 for(i = 0; i < fmt->nChannels; ++i){
1183 if(map[i] != i)
1184 return TRUE;
1185 }
1186 return FALSE;
1187 }
1188
1189 static DWORD get_channel_mask(unsigned int channels)
1190 {
1191 switch(channels){
1192 case 0:
1193 return 0;
1194 case 1:
1195 return KSAUDIO_SPEAKER_MONO;
1196 case 2:
1197 return KSAUDIO_SPEAKER_STEREO;
1198 case 3:
1199 return KSAUDIO_SPEAKER_STEREO | SPEAKER_LOW_FREQUENCY;
1200 case 4:
1201 return KSAUDIO_SPEAKER_QUAD; /* not _SURROUND */
1202 case 5:
1203 return KSAUDIO_SPEAKER_QUAD | SPEAKER_LOW_FREQUENCY;
1204 case 6:
1205 return KSAUDIO_SPEAKER_5POINT1; /* not 5POINT1_SURROUND */
1206 case 7:
1207 return KSAUDIO_SPEAKER_5POINT1 | SPEAKER_BACK_CENTER;
1208 case 8:
1209 return KSAUDIO_SPEAKER_7POINT1_SURROUND; /* Vista deprecates 7POINT1 */
1210 }
1211 FIXME("Unknown speaker configuration: %u\n", channels);
1212 return 0;
1213 }
1214
1215 static HRESULT map_channels(ACImpl *This, const WAVEFORMATEX *fmt, int *alsa_channels, int *map)
1216 {
1217 BOOL need_remap;
1218
1219 if(This->dataflow != eCapture && (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE || fmt->nChannels > 2) ){
1220 WAVEFORMATEXTENSIBLE *fmtex = (void*)fmt;
1221 DWORD mask, flag = SPEAKER_FRONT_LEFT;
1222 UINT i = 0;
1223
1224 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1225 fmtex->dwChannelMask != 0)
1226 mask = fmtex->dwChannelMask;
1227 else
1228 mask = get_channel_mask(fmt->nChannels);
1229
1230 *alsa_channels = 0;
1231
1232 while(i < fmt->nChannels && !(flag & SPEAKER_RESERVED)){
1233 if(mask & flag){
1234 map[i] = alsa_channel_index(flag);
1235 TRACE("Mapping mmdevapi channel %u (0x%x) to ALSA channel %d\n",
1236 i, flag, map[i]);
1237 if(map[i] >= *alsa_channels)
1238 *alsa_channels = map[i] + 1;
1239 ++i;
1240 }
1241 flag <<= 1;
1242 }
1243
1244 while(i < fmt->nChannels){
1245 map[i] = *alsa_channels;
1246 TRACE("Mapping mmdevapi channel %u to ALSA channel %d\n",
1247 i, map[i]);
1248 ++*alsa_channels;
1249 ++i;
1250 }
1251
1252 for(i = 0; i < fmt->nChannels; ++i){
1253 if(map[i] == -1){
1254 map[i] = *alsa_channels;
1255 ++*alsa_channels;
1256 TRACE("Remapping mmdevapi channel %u to ALSA channel %d\n",
1257 i, map[i]);
1258 }
1259 }
1260
1261 need_remap = need_remapping(This, fmt, map);
1262 }else{
1263 *alsa_channels = fmt->nChannels;
1264
1265 need_remap = FALSE;
1266 }
1267
1268 TRACE("need_remapping: %u, alsa_channels: %d\n", need_remap, *alsa_channels);
1269
1270 return need_remap ? S_OK : S_FALSE;
1271 }
1272
1273 static void silence_buffer(ACImpl *This, BYTE *buffer, UINT32 frames)
1274 {
1275 WAVEFORMATEXTENSIBLE *fmtex = (WAVEFORMATEXTENSIBLE*)This->fmt;
1276 if((This->fmt->wFormatTag == WAVE_FORMAT_PCM ||
1277 (This->fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1278 IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))) &&
1279 This->fmt->wBitsPerSample == 8)
1280 memset(buffer, 128, frames * This->fmt->nBlockAlign);
1281 else
1282 memset(buffer, 0, frames * This->fmt->nBlockAlign);
1283 }
1284
1285 static HRESULT WINAPI AudioClient_Initialize(IAudioClient3 *iface,
1286 AUDCLNT_SHAREMODE mode, DWORD flags, REFERENCE_TIME duration,
1287 REFERENCE_TIME period, const WAVEFORMATEX *fmt,
1288 const GUID *sessionguid)
1289 {
1290 ACImpl *This = impl_from_IAudioClient3(iface);
1291 snd_pcm_sw_params_t *sw_params = NULL;
1292 snd_pcm_format_t format;
1293 unsigned int rate, alsa_period_us;
1294 int err, i;
1295 HRESULT hr = S_OK;
1296
1297 TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This, mode, flags,
1298 wine_dbgstr_longlong(duration), wine_dbgstr_longlong(period), fmt, debugstr_guid(sessionguid));
1299
1300 if(!fmt)
1301 return E_POINTER;
1302
1303 if(mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
1304 return E_INVALIDARG;
1305
1306 if(flags & ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS |
1307 AUDCLNT_STREAMFLAGS_LOOPBACK |
1308 AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
1309 AUDCLNT_STREAMFLAGS_NOPERSIST |
1310 AUDCLNT_STREAMFLAGS_RATEADJUST |
1311 AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED |
1312 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE |
1313 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED |
1314 AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY |
1315 AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM)){
1316 FIXME("Unknown flags: %08x\n", flags);
1317 return E_INVALIDARG;
1318 }
1319
1320 if(mode == AUDCLNT_SHAREMODE_SHARED){
1321 period = DefaultPeriod;
1322 if( duration < 3 * period)
1323 duration = 3 * period;
1324 }else{
1325 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
1326 if(((WAVEFORMATEXTENSIBLE*)fmt)->dwChannelMask == 0 ||
1327 ((WAVEFORMATEXTENSIBLE*)fmt)->dwChannelMask & SPEAKER_RESERVED)
1328 return AUDCLNT_E_UNSUPPORTED_FORMAT;
1329 }
1330
1331 if(!period)
1332 period = DefaultPeriod; /* not minimum */
1333 if(period < MinimumPeriod || period > 5000000)
1334 return AUDCLNT_E_INVALID_DEVICE_PERIOD;
1335 if(duration > 20000000) /* the smaller the period, the lower this limit */
1336 return AUDCLNT_E_BUFFER_SIZE_ERROR;
1337 if(flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK){
1338 if(duration != period)
1339 return AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL;
1340 FIXME("EXCLUSIVE mode with EVENTCALLBACK\n");
1341 return AUDCLNT_E_DEVICE_IN_USE;
1342 }else{
1343 if( duration < 8 * period)
1344 duration = 8 * period; /* may grow above 2s */
1345 }
1346 }
1347
1348 EnterCriticalSection(&This->lock);
1349
1350 if(This->initted){
1351 LeaveCriticalSection(&This->lock);
1352 return AUDCLNT_E_ALREADY_INITIALIZED;
1353 }
1354
1355 dump_fmt(fmt);
1356
1357 This->need_remapping = map_channels(This, fmt, &This->alsa_channels, This->alsa_channel_map) == S_OK;
1358
1359 if((err = snd_pcm_hw_params_any(This->pcm_handle, This->hw_params)) < 0){
1360 WARN("Unable to get hw_params: %d (%s)\n", err, snd_strerror(err));
1361 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1362 goto exit;
1363 }
1364
1365 if((err = snd_pcm_hw_params_set_access(This->pcm_handle, This->hw_params,
1366 SND_PCM_ACCESS_RW_INTERLEAVED)) < 0){
1367 WARN("Unable to set access: %d (%s)\n", err, snd_strerror(err));
1368 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1369 goto exit;
1370 }
1371
1372 format = alsa_format(fmt);
1373 if (format == SND_PCM_FORMAT_UNKNOWN){
1374 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1375 goto exit;
1376 }
1377
1378 if((err = snd_pcm_hw_params_set_format(This->pcm_handle, This->hw_params,
1379 format)) < 0){
1380 WARN("Unable to set ALSA format to %u: %d (%s)\n", format, err,
1381 snd_strerror(err));
1382 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1383 goto exit;
1384 }
1385
1386 This->alsa_format = format;
1387
1388 rate = fmt->nSamplesPerSec;
1389 if((err = snd_pcm_hw_params_set_rate_near(This->pcm_handle, This->hw_params,
1390 &rate, NULL)) < 0){
1391 WARN("Unable to set rate to %u: %d (%s)\n", rate, err,
1392 snd_strerror(err));
1393 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1394 goto exit;
1395 }
1396
1397 if((err = snd_pcm_hw_params_set_channels(This->pcm_handle, This->hw_params,
1398 This->alsa_channels)) < 0){
1399 WARN("Unable to set channels to %u: %d (%s)\n", fmt->nChannels, err,
1400 snd_strerror(err));
1401 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1402 goto exit;
1403 }
1404
1405 This->mmdev_period_rt = period;
1406 alsa_period_us = This->mmdev_period_rt / 10;
1407 if((err = snd_pcm_hw_params_set_period_time_near(This->pcm_handle,
1408 This->hw_params, &alsa_period_us, NULL)) < 0)
1409 WARN("Unable to set period time near %u: %d (%s)\n", alsa_period_us,
1410 err, snd_strerror(err));
1411 /* ALSA updates the output variable alsa_period_us */
1412
1413 This->mmdev_period_frames = MulDiv(fmt->nSamplesPerSec,
1414 This->mmdev_period_rt, 10000000);
1415
1416 /* Buffer 4 ALSA periods if large enough, else 4 mmdevapi periods */
1417 This->alsa_bufsize_frames = This->mmdev_period_frames * 4;
1418 if(err < 0 || alsa_period_us < period / 10)
1419 err = snd_pcm_hw_params_set_buffer_size_near(This->pcm_handle,
1420 This->hw_params, &This->alsa_bufsize_frames);
1421 else{
1422 unsigned int periods = 4;
1423 err = snd_pcm_hw_params_set_periods_near(This->pcm_handle, This->hw_params, &periods, NULL);
1424 }
1425 if(err < 0)
1426 WARN("Unable to set buffer size: %d (%s)\n", err, snd_strerror(err));
1427
1428 if((err = snd_pcm_hw_params(This->pcm_handle, This->hw_params)) < 0){
1429 WARN("Unable to set hw params: %d (%s)\n", err, snd_strerror(err));
1430 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1431 goto exit;
1432 }
1433
1434 if((err = snd_pcm_hw_params_get_period_size(This->hw_params,
1435 &This->alsa_period_frames, NULL)) < 0){
1436 WARN("Unable to get period size: %d (%s)\n", err, snd_strerror(err));
1437 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1438 goto exit;
1439 }
1440
1441 if((err = snd_pcm_hw_params_get_buffer_size(This->hw_params,
1442 &This->alsa_bufsize_frames)) < 0){
1443 WARN("Unable to get buffer size: %d (%s)\n", err, snd_strerror(err));
1444 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1445 goto exit;
1446 }
1447
1448 sw_params = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_sw_params_sizeof());
1449 if(!sw_params){
1450 hr = E_OUTOFMEMORY;
1451 goto exit;
1452 }
1453
1454 if((err = snd_pcm_sw_params_current(This->pcm_handle, sw_params)) < 0){
1455 WARN("Unable to get sw_params: %d (%s)\n", err, snd_strerror(err));
1456 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1457 goto exit;
1458 }
1459
1460 if((err = snd_pcm_sw_params_set_start_threshold(This->pcm_handle,
1461 sw_params, 1)) < 0){
1462 WARN("Unable set start threshold to 1: %d (%s)\n", err, snd_strerror(err));
1463 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1464 goto exit;
1465 }
1466
1467 if((err = snd_pcm_sw_params_set_stop_threshold(This->pcm_handle,
1468 sw_params, This->alsa_bufsize_frames)) < 0){
1469 WARN("Unable set stop threshold to %lu: %d (%s)\n",
1470 This->alsa_bufsize_frames, err, snd_strerror(err));
1471 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1472 goto exit;
1473 }
1474
1475 if((err = snd_pcm_sw_params(This->pcm_handle, sw_params)) < 0){
1476 WARN("Unable to set sw params: %d (%s)\n", err, snd_strerror(err));
1477 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1478 goto exit;
1479 }
1480
1481 if((err = snd_pcm_prepare(This->pcm_handle)) < 0){
1482 WARN("Unable to prepare device: %d (%s)\n", err, snd_strerror(err));
1483 hr = AUDCLNT_E_ENDPOINT_CREATE_FAILED;
1484 goto exit;
1485 }
1486
1487 /* Bear in mind weird situations where
1488 * ALSA period (50ms) > mmdevapi buffer (3x10ms)
1489 * or surprising rounding as seen with 22050x8x1 with Pulse:
1490 * ALSA period 220 vs. 221 frames in mmdevapi and
1491 * buffer 883 vs. 2205 frames in mmdevapi! */
1492 This->bufsize_frames = MulDiv(duration, fmt->nSamplesPerSec, 10000000);
1493 if(mode == AUDCLNT_SHAREMODE_EXCLUSIVE)
1494 This->bufsize_frames -= This->bufsize_frames % This->mmdev_period_frames;
1495 This->hidden_frames = This->alsa_period_frames + This->mmdev_period_frames +
1496 MulDiv(fmt->nSamplesPerSec, EXTRA_SAFE_RT, 10000000);
1497 /* leave no less than about 1.33ms or 256 bytes of data after a rewind */
1498 This->safe_rewind_frames = max(256 / fmt->nBlockAlign, MulDiv(133, fmt->nSamplesPerSec, 100000));
1499
1500 /* Check if the ALSA buffer is so small that it will run out before
1501 * the next MMDevAPI period tick occurs. Allow a little wiggle room
1502 * with 120% of the period time. */
1503 if(This->alsa_bufsize_frames < 1.2 * This->mmdev_period_frames)
1504 FIXME("ALSA buffer time is too small. Expect underruns. (%lu < %u * 1.2)\n",
1505 This->alsa_bufsize_frames, This->mmdev_period_frames);
1506
1507 This->fmt = clone_format(fmt);
1508 if(!This->fmt){
1509 hr = E_OUTOFMEMORY;
1510 goto exit;
1511 }
1512
1513 This->local_buffer = HeapAlloc(GetProcessHeap(), 0,
1514 This->bufsize_frames * fmt->nBlockAlign);
1515 if(!This->local_buffer){
1516 hr = E_OUTOFMEMORY;
1517 goto exit;
1518 }
1519 silence_buffer(This, This->local_buffer, This->bufsize_frames);
1520
1521 This->silence_buf = HeapAlloc(GetProcessHeap(), 0,
1522 This->alsa_period_frames * This->fmt->nBlockAlign);
1523 if(!This->silence_buf){
1524 hr = E_OUTOFMEMORY;
1525 goto exit;
1526 }
1527 silence_buffer(This, This->silence_buf, This->alsa_period_frames);
1528
1529 This->vols = HeapAlloc(GetProcessHeap(), 0, fmt->nChannels * sizeof(float));
1530 if(!This->vols){
1531 hr = E_OUTOFMEMORY;
1532 goto exit;
1533 }
1534
1535 for(i = 0; i < fmt->nChannels; ++i)
1536 This->vols[i] = 1.f;
1537
1538 This->share = mode;
1539 This->flags = flags;
1540
1541 EnterCriticalSection(&g_sessions_lock);
1542
1543 hr = get_audio_session(sessionguid, This->parent, fmt->nChannels,
1544 &This->session);
1545 if(FAILED(hr)){
1546 LeaveCriticalSection(&g_sessions_lock);
1547 goto exit;
1548 }
1549
1550 list_add_tail(&This->session->clients, &This->entry);
1551
1552 LeaveCriticalSection(&g_sessions_lock);
1553
1554 This->initted = TRUE;
1555
1556 TRACE("ALSA period: %lu frames\n", This->alsa_period_frames);
1557 TRACE("ALSA buffer: %lu frames\n", This->alsa_bufsize_frames);
1558 TRACE("MMDevice period: %u frames\n", This->mmdev_period_frames);
1559 TRACE("MMDevice buffer: %u frames\n", This->bufsize_frames);
1560
1561 exit:
1562 HeapFree(GetProcessHeap(), 0, sw_params);
1563 if(FAILED(hr)){
1564 HeapFree(GetProcessHeap(), 0, This->local_buffer);
1565 This->local_buffer = NULL;
1566 CoTaskMemFree(This->fmt);
1567 This->fmt = NULL;
1568 HeapFree(GetProcessHeap(), 0, This->vols);
1569 This->vols = NULL;
1570 }
1571
1572 LeaveCriticalSection(&This->lock);
1573
1574 return hr;
1575 }
1576
1577 static HRESULT WINAPI AudioClient_GetBufferSize(IAudioClient3 *iface,
1578 UINT32 *out)
1579 {
1580 ACImpl *This = impl_from_IAudioClient3(iface);
1581
1582 TRACE("(%p)->(%p)\n", This, out);
1583
1584 if(!out)
1585 return E_POINTER;
1586
1587 EnterCriticalSection(&This->lock);
1588
1589 if(!This->initted){
1590 LeaveCriticalSection(&This->lock);
1591 return AUDCLNT_E_NOT_INITIALIZED;
1592 }
1593
1594 *out = This->bufsize_frames;
1595
1596 LeaveCriticalSection(&This->lock);
1597
1598 return S_OK;
1599 }
1600
1601 static HRESULT WINAPI AudioClient_GetStreamLatency(IAudioClient3 *iface,
1602 REFERENCE_TIME *latency)
1603 {
1604 ACImpl *This = impl_from_IAudioClient3(iface);
1605
1606 TRACE("(%p)->(%p)\n", This, latency);
1607
1608 if(!latency)
1609 return E_POINTER;
1610
1611 EnterCriticalSection(&This->lock);
1612
1613 if(!This->initted){
1614 LeaveCriticalSection(&This->lock);
1615 return AUDCLNT_E_NOT_INITIALIZED;
1616 }
1617
1618 /* Hide some frames in the ALSA buffer. Allows us to return GetCurrentPadding=0
1619 * yet have enough data left to play (as if it were in native's mixer). Add:
1620 * + mmdevapi_period such that at the end of it, ALSA still has data;
1621 * + EXTRA_SAFE (~4ms) to allow for late callback invocation / fluctuation;
1622 * + alsa_period such that ALSA always has at least one period to play. */
1623 if(This->dataflow == eRender)
1624 *latency = MulDiv(This->hidden_frames, 10000000, This->fmt->nSamplesPerSec);
1625 else
1626 *latency = MulDiv(This->alsa_period_frames, 10000000, This->fmt->nSamplesPerSec)
1627 + This->mmdev_period_rt;
1628
1629 LeaveCriticalSection(&This->lock);
1630
1631 return S_OK;
1632 }
1633
1634 static HRESULT WINAPI AudioClient_GetCurrentPadding(IAudioClient3 *iface,
1635 UINT32 *out)
1636 {
1637 ACImpl *This = impl_from_IAudioClient3(iface);
1638
1639 TRACE("(%p)->(%p)\n", This, out);
1640
1641 if(!out)
1642 return E_POINTER;
1643
1644 EnterCriticalSection(&This->lock);
1645
1646 if(!This->initted){
1647 LeaveCriticalSection(&This->lock);
1648 return AUDCLNT_E_NOT_INITIALIZED;
1649 }
1650
1651 /* padding is solely updated at callback time in shared mode */
1652 *out = This->held_frames;
1653
1654 LeaveCriticalSection(&This->lock);
1655
1656 TRACE("pad: %u\n", *out);
1657
1658 return S_OK;
1659 }
1660
1661 static HRESULT WINAPI AudioClient_IsFormatSupported(IAudioClient3 *iface,
1662 AUDCLNT_SHAREMODE mode, const WAVEFORMATEX *fmt,
1663 WAVEFORMATEX **out)
1664 {
1665 ACImpl *This = impl_from_IAudioClient3(iface);
1666 snd_pcm_format_mask_t *formats = NULL;
1667 snd_pcm_format_t format;
1668 HRESULT hr = S_OK;
1669 WAVEFORMATEX *closest = NULL;
1670 unsigned int max = 0, min = 0;
1671 int err;
1672 int alsa_channels, alsa_channel_map[32];
1673
1674 TRACE("(%p)->(%x, %p, %p)\n", This, mode, fmt, out);
1675
1676 if(!fmt || (mode == AUDCLNT_SHAREMODE_SHARED && !out))
1677 return E_POINTER;
1678
1679 if(mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
1680 return E_INVALIDARG;
1681
1682 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1683 fmt->cbSize < sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX))
1684 return E_INVALIDARG;
1685
1686 dump_fmt(fmt);
1687
1688 if(out){
1689 *out = NULL;
1690 if(mode != AUDCLNT_SHAREMODE_SHARED)
1691 out = NULL;
1692 }
1693
1694 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1695 (fmt->nAvgBytesPerSec == 0 ||
1696 fmt->nBlockAlign == 0 ||
1697 ((WAVEFORMATEXTENSIBLE*)fmt)->Samples.wValidBitsPerSample > fmt->wBitsPerSample))
1698 return E_INVALIDARG;
1699
1700 if(fmt->nChannels == 0)
1701 return AUDCLNT_E_UNSUPPORTED_FORMAT;
1702
1703 EnterCriticalSection(&This->lock);
1704
1705 if((err = snd_pcm_hw_params_any(This->pcm_handle, This->hw_params)) < 0){
1706 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1707 goto exit;
1708 }
1709
1710 formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
1711 snd_pcm_format_mask_sizeof());
1712 if(!formats){
1713 hr = E_OUTOFMEMORY;
1714 goto exit;
1715 }
1716
1717 snd_pcm_hw_params_get_format_mask(This->hw_params, formats);
1718 format = alsa_format(fmt);
1719 if (format == SND_PCM_FORMAT_UNKNOWN ||
1720 !snd_pcm_format_mask_test(formats, format)){
1721 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1722 goto exit;
1723 }
1724
1725 closest = clone_format(fmt);
1726 if(!closest){
1727 hr = E_OUTOFMEMORY;
1728 goto exit;
1729 }
1730
1731 if((err = snd_pcm_hw_params_get_rate_min(This->hw_params, &min, NULL)) < 0){
1732 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1733 WARN("Unable to get min rate: %d (%s)\n", err, snd_strerror(err));
1734 goto exit;
1735 }
1736
1737 if((err = snd_pcm_hw_params_get_rate_max(This->hw_params, &max, NULL)) < 0){
1738 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1739 WARN("Unable to get max rate: %d (%s)\n", err, snd_strerror(err));
1740 goto exit;
1741 }
1742
1743 if(fmt->nSamplesPerSec < min || fmt->nSamplesPerSec > max){
1744 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1745 goto exit;
1746 }
1747
1748 if((err = snd_pcm_hw_params_get_channels_min(This->hw_params, &min)) < 0){
1749 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1750 WARN("Unable to get min channels: %d (%s)\n", err, snd_strerror(err));
1751 goto exit;
1752 }
1753
1754 if((err = snd_pcm_hw_params_get_channels_max(This->hw_params, &max)) < 0){
1755 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1756 WARN("Unable to get max channels: %d (%s)\n", err, snd_strerror(err));
1757 goto exit;
1758 }
1759 if(fmt->nChannels > max){
1760 hr = S_FALSE;
1761 closest->nChannels = max;
1762 }else if(fmt->nChannels < min){
1763 hr = S_FALSE;
1764 closest->nChannels = min;
1765 }
1766
1767 map_channels(This, fmt, &alsa_channels, alsa_channel_map);
1768
1769 if(alsa_channels > max){
1770 hr = S_FALSE;
1771 closest->nChannels = max;
1772 }
1773
1774 if(closest->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
1775 ((WAVEFORMATEXTENSIBLE*)closest)->dwChannelMask = get_channel_mask(closest->nChannels);
1776
1777 if(fmt->nBlockAlign != fmt->nChannels * fmt->wBitsPerSample / 8 ||
1778 fmt->nAvgBytesPerSec != fmt->nBlockAlign * fmt->nSamplesPerSec ||
1779 (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1780 ((WAVEFORMATEXTENSIBLE*)fmt)->Samples.wValidBitsPerSample < fmt->wBitsPerSample))
1781 hr = S_FALSE;
1782
1783 if(mode == AUDCLNT_SHAREMODE_EXCLUSIVE &&
1784 fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
1785 if(((WAVEFORMATEXTENSIBLE*)fmt)->dwChannelMask == 0 ||
1786 ((WAVEFORMATEXTENSIBLE*)fmt)->dwChannelMask & SPEAKER_RESERVED)
1787 hr = S_FALSE;
1788 }
1789
1790 exit:
1791 LeaveCriticalSection(&This->lock);
1792 HeapFree(GetProcessHeap(), 0, formats);
1793
1794 if(hr == S_FALSE && !out)
1795 hr = AUDCLNT_E_UNSUPPORTED_FORMAT;
1796
1797 if(hr == S_FALSE && out) {
1798 closest->nBlockAlign =
1799 closest->nChannels * closest->wBitsPerSample / 8;
1800 closest->nAvgBytesPerSec =
1801 closest->nBlockAlign * closest->nSamplesPerSec;
1802 if(closest->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
1803 ((WAVEFORMATEXTENSIBLE*)closest)->Samples.wValidBitsPerSample = closest->wBitsPerSample;
1804 *out = closest;
1805 } else
1806 CoTaskMemFree(closest);
1807
1808 TRACE("returning: %08x\n", hr);
1809 return hr;
1810 }
1811
1812 static HRESULT WINAPI AudioClient_GetMixFormat(IAudioClient3 *iface,
1813 WAVEFORMATEX **pwfx)
1814 {
1815 ACImpl *This = impl_from_IAudioClient3(iface);
1816 WAVEFORMATEXTENSIBLE *fmt;
1817 snd_pcm_format_mask_t *formats;
1818 unsigned int max_rate, max_channels;
1819 int err;
1820 HRESULT hr = S_OK;
1821
1822 TRACE("(%p)->(%p)\n", This, pwfx);
1823
1824 if(!pwfx)
1825 return E_POINTER;
1826 *pwfx = NULL;
1827
1828 fmt = CoTaskMemAlloc(sizeof(WAVEFORMATEXTENSIBLE));
1829 if(!fmt)
1830 return E_OUTOFMEMORY;
1831
1832 formats = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, snd_pcm_format_mask_sizeof());
1833 if(!formats){
1834 CoTaskMemFree(fmt);
1835 return E_OUTOFMEMORY;
1836 }
1837
1838 EnterCriticalSection(&This->lock);
1839
1840 if((err = snd_pcm_hw_params_any(This->pcm_handle, This->hw_params)) < 0){
1841 WARN("Unable to get hw_params: %d (%s)\n", err, snd_strerror(err));
1842 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1843 goto exit;
1844 }
1845
1846 snd_pcm_hw_params_get_format_mask(This->hw_params, formats);
1847
1848 fmt->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
1849 if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_FLOAT_LE)){
1850 fmt->Format.wBitsPerSample = 32;
1851 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
1852 }else if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_S16_LE)){
1853 fmt->Format.wBitsPerSample = 16;
1854 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1855 }else if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_U8)){
1856 fmt->Format.wBitsPerSample = 8;
1857 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1858 }else if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_S32_LE)){
1859 fmt->Format.wBitsPerSample = 32;
1860 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1861 }else if(snd_pcm_format_mask_test(formats, SND_PCM_FORMAT_S24_3LE)){
1862 fmt->Format.wBitsPerSample = 24;
1863 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1864 }else{
1865 ERR("Didn't recognize any available ALSA formats\n");
1866 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1867 goto exit;
1868 }
1869
1870 if((err = snd_pcm_hw_params_get_channels_max(This->hw_params,
1871 &max_channels)) < 0){
1872 WARN("Unable to get max channels: %d (%s)\n", err, snd_strerror(err));
1873 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1874 goto exit;
1875 }
1876
1877 if(max_channels > 6)
1878 fmt->Format.nChannels = 2;
1879 else
1880 fmt->Format.nChannels = max_channels;
1881
1882 if(fmt->Format.nChannels > 1 && (fmt->Format.nChannels & 0x1)){
1883 /* For most hardware on Windows, users must choose a configuration with an even
1884 * number of channels (stereo, quad, 5.1, 7.1). Users can then disable
1885 * channels, but those channels are still reported to applications from
1886 * GetMixFormat! Some applications behave badly if given an odd number of
1887 * channels (e.g. 2.1). */
1888
1889 if(fmt->Format.nChannels < max_channels)
1890 fmt->Format.nChannels += 1;
1891 else
1892 /* We could "fake" more channels and downmix the emulated channels,
1893 * but at that point you really ought to tweak your ALSA setup or
1894 * just use PulseAudio. */
1895 WARN("Some Windows applications behave badly with an odd number of channels (%u)!\n", fmt->Format.nChannels);
1896 }
1897
1898 fmt->dwChannelMask = get_channel_mask(fmt->Format.nChannels);
1899
1900 if((err = snd_pcm_hw_params_get_rate_max(This->hw_params, &max_rate,
1901 NULL)) < 0){
1902 WARN("Unable to get max rate: %d (%s)\n", err, snd_strerror(err));
1903 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1904 goto exit;
1905 }
1906
1907 if(max_rate >= 48000)
1908 fmt->Format.nSamplesPerSec = 48000;
1909 else if(max_rate >= 44100)
1910 fmt->Format.nSamplesPerSec = 44100;
1911 else if(max_rate >= 22050)
1912 fmt->Format.nSamplesPerSec = 22050;
1913 else if(max_rate >= 11025)
1914 fmt->Format.nSamplesPerSec = 11025;
1915 else if(max_rate >= 8000)
1916 fmt->Format.nSamplesPerSec = 8000;
1917 else{
1918 ERR("Unknown max rate: %u\n", max_rate);
1919 hr = AUDCLNT_E_DEVICE_INVALIDATED;
1920 goto exit;
1921 }
1922
1923 fmt->Format.nBlockAlign = (fmt->Format.wBitsPerSample *
1924 fmt->Format.nChannels) / 8;
1925 fmt->Format.nAvgBytesPerSec = fmt->Format.nSamplesPerSec *
1926 fmt->Format.nBlockAlign;
1927
1928 fmt->Samples.wValidBitsPerSample = fmt->Format.wBitsPerSample;
1929 fmt->Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
1930
1931 dump_fmt((WAVEFORMATEX*)fmt);
1932 *pwfx = (WAVEFORMATEX*)fmt;
1933
1934 exit:
1935 LeaveCriticalSection(&This->lock);
1936 if(FAILED(hr))
1937 CoTaskMemFree(fmt);
1938 HeapFree(GetProcessHeap(), 0, formats);
1939
1940 return hr;
1941 }
1942
1943 static HRESULT WINAPI AudioClient_GetDevicePeriod(IAudioClient3 *iface,
1944 REFERENCE_TIME *defperiod, REFERENCE_TIME *minperiod)
1945 {
1946 ACImpl *This = impl_from_IAudioClient3(iface);
1947
1948 TRACE("(%p)->(%p, %p)\n", This, defperiod, minperiod);
1949
1950 if(!defperiod && !minperiod)
1951 return E_POINTER;
1952
1953 if(defperiod)
1954 *defperiod = DefaultPeriod;
1955 if(minperiod)
1956 *minperiod = DefaultPeriod;
1957
1958 return S_OK;
1959 }
1960
1961 static BYTE *remap_channels(ACImpl *This, BYTE *buf, snd_pcm_uframes_t frames)
1962 {
1963 snd_pcm_uframes_t i;
1964 UINT c;
1965 UINT bytes_per_sample = This->fmt->wBitsPerSample / 8;
1966
1967 if(!This->need_remapping)
1968 return buf;
1969
1970 if(!This->remapping_buf){
1971 This->remapping_buf = HeapAlloc(GetProcessHeap(), 0,
1972 bytes_per_sample * This->alsa_channels * frames);
1973 This->remapping_buf_frames = frames;
1974 }else if(This->remapping_buf_frames < frames){
1975 This->remapping_buf = HeapReAlloc(GetProcessHeap(), 0, This->remapping_buf,
1976 bytes_per_sample * This->alsa_channels * frames);
1977 This->remapping_buf_frames = frames;
1978 }
1979
1980 snd_pcm_format_set_silence(This->alsa_format, This->remapping_buf,
1981 frames * This->alsa_channels);
1982
1983 switch(This->fmt->wBitsPerSample){
1984 case 8: {
1985 UINT8 *tgt_buf, *src_buf;
1986 tgt_buf = This->remapping_buf;
1987 src_buf = buf;
1988 for(i = 0; i < frames; ++i){
1989 for(c = 0; c < This->fmt->nChannels; ++c)
1990 tgt_buf[This->alsa_channel_map[c]] = src_buf[c];
1991 tgt_buf += This->alsa_channels;
1992 src_buf += This->fmt->nChannels;
1993 }
1994 break;
1995 }
1996 case 16: {
1997 UINT16 *tgt_buf, *src_buf;
1998 tgt_buf = (UINT16*)This->remapping_buf;
1999 src_buf = (UINT16*)buf;
2000 for(i = 0; i < frames; ++i){
2001 for(c = 0; c < This->fmt->nChannels; ++c)
2002 tgt_buf[This->alsa_channel_map[c]] = src_buf[c];
2003 tgt_buf += This->alsa_channels;
2004 src_buf += This->fmt->nChannels;
2005 }
2006 }
2007 break;
2008 case 32: {
2009 UINT32 *tgt_buf, *src_buf;
2010 tgt_buf = (UINT32*)This->remapping_buf;
2011 src_buf = (UINT32*)buf;
2012 for(i = 0; i < frames; ++i){
2013 for(c = 0; c < This->fmt->nChannels; ++c)
2014 tgt_buf[This->alsa_channel_map[c]] = src_buf[c];
2015 tgt_buf += This->alsa_channels;
2016 src_buf += This->fmt->nChannels;
2017 }
2018 }
2019 break;
2020 default: {
2021 BYTE *tgt_buf, *src_buf;
2022 tgt_buf = This->remapping_buf;
2023 src_buf = buf;
2024 for(i = 0; i < frames; ++i){
2025 for(c = 0; c < This->fmt->nChannels; ++c)
2026 memcpy(&tgt_buf[This->alsa_channel_map[c] * bytes_per_sample],
2027 &src_buf[c * bytes_per_sample], bytes_per_sample);
2028 tgt_buf += This->alsa_channels * bytes_per_sample;
2029 src_buf += This->fmt->nChannels * bytes_per_sample;
2030 }
2031 }
2032 break;
2033 }
2034
2035 return This->remapping_buf;
2036 }
2037
2038 static void adjust_buffer_volume(const ACImpl *This, BYTE *buf, snd_pcm_uframes_t frames, BOOL mute)
2039 {
2040 float vol[ARRAY_SIZE(This->alsa_channel_map)];
2041 BOOL adjust = FALSE;
2042 UINT32 i, channels;
2043 BYTE *end;
2044
2045 if (This->vol_adjusted_frames >= frames)
2046 return;
2047 channels = This->fmt->nChannels;
2048
2049 if (mute)
2050 {
2051 int err = snd_pcm_format_set_silence(This->alsa_format, buf, frames * channels);
2052 if (err < 0)
2053 WARN("Setting buffer to silence failed: %d (%s)\n", err, snd_strerror(err));
2054 return;
2055 }
2056
2057 /* Adjust the buffer based on the volume for each channel */
2058 for (i = 0; i < channels; i++)
2059 vol[i] = This->vols[i] * This->session->master_vol;
2060 for (i = 0; i < min(channels, This->session->channel_count); i++)
2061 {
2062 vol[i] *= This->session->channel_vols[i];
2063 adjust |= vol[i] != 1.0f;
2064 }
2065 while (i < channels) adjust |= vol[i++] != 1.0f;
2066 if (!adjust) return;
2067
2068 /* Skip the frames we've already adjusted before */
2069 end = buf + frames * This->fmt->nBlockAlign;
2070 buf += This->vol_adjusted_frames * This->fmt->nBlockAlign;
2071
2072 switch (This->alsa_format)
2073 {
2074 #ifndef WORDS_BIGENDIAN
2075 #define PROCESS_BUFFER(type) do \
2076 { \
2077 type *p = (type*)buf; \
2078 do \
2079 { \
2080 for (i = 0; i < channels; i++) \
2081 p[i] = p[i] * vol[i]; \
2082 p += i; \
2083 } while ((BYTE*)p != end); \
2084 } while (0)
2085 case SND_PCM_FORMAT_S16_LE:
2086 PROCESS_BUFFER(INT16);
2087 break;
2088 case SND_PCM_FORMAT_S32_LE:
2089 PROCESS_BUFFER(INT32);
2090 break;
2091 case SND_PCM_FORMAT_FLOAT_LE:
2092 PROCESS_BUFFER(float);
2093 break;
2094 case SND_PCM_FORMAT_FLOAT64_LE:
2095 PROCESS_BUFFER(double);
2096 break;
2097 #undef PROCESS_BUFFER
2098 case SND_PCM_FORMAT_S20_3LE:
2099 case SND_PCM_FORMAT_S24_3LE:
2100 {
2101 /* Do it 12 bytes at a time until it is no longer possible */
2102 UINT32 *q = (UINT32*)buf, mask = ~0xff;
2103 BYTE *p;
2104
2105 /* After we adjust the volume, we need to mask out low bits */
2106 if (This->alsa_format == SND_PCM_FORMAT_S20_3LE)
2107 mask = ~0x0fff;
2108
2109 i = 0;
2110 while (end - (BYTE*)q >= 12)
2111 {
2112 UINT32 v[4], k;
2113 v[0] = q[0] << 8;
2114 v[1] = q[1] << 16 | (q[0] >> 16 & ~0xff);
2115 v[2] = q[2] << 24 | (q[1] >> 8 & ~0xff);
2116 v[3] = q[2] & ~0xff;
2117 for (k = 0; k < 4; k++)
2118 {
2119 v[k] = (INT32)((INT32)v[k] * vol[i]);
2120 v[k] &= mask;
2121 if (++i == channels) i = 0;
2122 }
2123 *q++ = v[0] >> 8 | v[1] << 16;
2124 *q++ = v[1] >> 16 | v[2] << 8;
2125 *q++ = v[2] >> 24 | v[3];
2126 }
2127 p = (BYTE*)q;
2128 while (p != end)
2129 {
2130 UINT32 v = (INT32)((INT32)(p[0] << 8 | p[1] << 16 | p[2] << 24) * vol[i]);
2131 v &= mask;
2132 *p++ = v >> 8 & 0xff;
2133 *p++ = v >> 16 & 0xff;
2134 *p++ = v >> 24;
2135 if (++i == channels) i = 0;
2136 }
2137 break;
2138 }
2139 #endif
2140 case SND_PCM_FORMAT_U8:
2141 {
2142 UINT8 *p = (UINT8*)buf;
2143 do
2144 {
2145 for (i = 0; i < channels; i++)
2146 p[i] = (int)((p[i] - 128) * vol[i]) + 128;
2147 p += i;
2148 } while ((BYTE*)p != end);
2149 break;
2150 }
2151 default:
2152 TRACE("Unhandled format %i, not adjusting volume.\n", This->alsa_format);
2153 break;
2154 }
2155 }
2156
2157 static snd_pcm_sframes_t alsa_write_best_effort(ACImpl *This, BYTE *buf,
2158 snd_pcm_uframes_t frames, BOOL mute)
2159 {
2160 snd_pcm_sframes_t written;
2161
2162 adjust_buffer_volume(This, buf, frames, mute);
2163
2164 /* Mark the frames we've already adjusted */
2165 if (This->vol_adjusted_frames < frames)
2166 This->vol_adjusted_frames = frames;
2167
2168 buf = remap_channels(This, buf, frames);
2169
2170 written = snd_pcm_writei(This->pcm_handle, buf, frames);
2171 if(written < 0){
2172 int ret;
2173
2174 if(written == -EAGAIN)
2175 /* buffer full */
2176 return 0;
2177
2178 WARN("writei failed, recovering: %ld (%s)\n", written,
2179 snd_strerror(written));
2180
2181 ret = snd_pcm_recover(This->pcm_handle, written, 0);
2182 if(ret < 0){
2183 WARN("Could not recover: %d (%s)\n", ret, snd_strerror(ret));
2184 return ret;
2185 }
2186
2187 written = snd_pcm_writei(This->pcm_handle, buf, frames);
2188 }
2189
2190 if (written > 0)
2191 This->vol_adjusted_frames -= written;
2192 return written;
2193 }
2194
2195 static snd_pcm_sframes_t alsa_write_buffer_wrap(ACImpl *This, BYTE *buf,
2196 snd_pcm_uframes_t buflen, snd_pcm_uframes_t offs,
2197 snd_pcm_uframes_t to_write)
2198 {
2199 snd_pcm_sframes_t ret = 0;
2200
2201 while(to_write){
2202 snd_pcm_uframes_t chunk;
2203 snd_pcm_sframes_t tmp;
2204
2205 if(offs + to_write > buflen)
2206 chunk = buflen - offs;
2207 else
2208 chunk = to_write;
2209
2210 tmp = alsa_write_best_effort(This, buf + offs * This->fmt->nBlockAlign, chunk, This->session->mute);
2211 if(tmp < 0)
2212 return ret;
2213 if(!tmp)
2214 break;
2215
2216 ret += tmp;
2217 to_write -= tmp;
2218 offs += tmp;
2219 offs %= buflen;
2220 }
2221
2222 return ret;
2223 }
2224
2225 static UINT buf_ptr_diff(UINT left, UINT right, UINT bufsize)
2226 {
2227 if(left <= right)
2228 return right - left;
2229 return bufsize - (left - right);
2230 }
2231
2232 static UINT data_not_in_alsa(ACImpl *This)
2233 {
2234 UINT32 diff;
2235
2236 diff = buf_ptr_diff(This->lcl_offs_frames, This->wri_offs_frames, This->bufsize_frames);
2237 if(diff)
2238 return diff;
2239
2240 return This->held_frames - This->data_in_alsa_frames;
2241 }
2242 /* Here's the buffer setup:
2243 *
2244 * vvvvvvvv sent to HW already
2245 * vvvvvvvv in ALSA buffer but rewindable
2246 * [dddddddddddddddd] ALSA buffer
2247 * [dddddddddddddddd--------] mmdevapi buffer
2248 * ^^^^^^^^ data_in_alsa_frames
2249 * ^^^^^^^^^^^^^^^^ held_frames
2250 * ^ lcl_offs_frames
2251 * ^ wri_offs_frames
2252 *
2253 * GetCurrentPadding is held_frames
2254 *
2255 * During period callback, we decrement held_frames, fill ALSA buffer, and move
2256 * lcl_offs forward
2257 *
2258 * During Stop, we rewind the ALSA buffer
2259 */
2260 static void alsa_write_data(ACImpl *This)
2261 {
2262 snd_pcm_sframes_t written;
2263 snd_pcm_uframes_t avail, max_copy_frames, data_frames_played;
2264 int err;
2265
2266 /* this call seems to be required to get an accurate snd_pcm_state() */
2267 avail = snd_pcm_avail_update(This->pcm_handle);
2268
2269 if(snd_pcm_state(This->pcm_handle) == SND_PCM_STATE_XRUN){
2270 TRACE("XRun state, recovering\n");
2271
2272 avail = This->alsa_bufsize_frames;
2273
2274 if((err = snd_pcm_recover(This->pcm_handle, -EPIPE, 1)) < 0)
2275 WARN("snd_pcm_recover failed: %d (%s)\n", err, snd_strerror(err));
2276
2277 if((err = snd_pcm_reset(This->pcm_handle)) < 0)
2278 WARN("snd_pcm_reset failed: %d (%s)\n", err, snd_strerror(err));
2279
2280 if((err = snd_pcm_prepare(This->pcm_handle)) < 0)
2281 WARN("snd_pcm_prepare failed: %d (%s)\n", err, snd_strerror(err));
2282 }
2283
2284 TRACE("avail: %ld\n", avail);
2285
2286 /* Add a lead-in when starting with too few frames to ensure
2287 * continuous rendering. Additional benefit: Force ALSA to start. */
2288 if(This->data_in_alsa_frames == 0 && This->held_frames < This->alsa_period_frames)
2289 {
2290 alsa_write_best_effort(This, This->silence_buf, This->alsa_period_frames - This->held_frames, FALSE);
2291 This->vol_adjusted_frames = 0;
2292 }
2293
2294 if(This->started)
2295 max_copy_frames = data_not_in_alsa(This);
2296 else
2297 max_copy_frames = 0;
2298
2299 data_frames_played = min(This->data_in_alsa_frames, avail);
2300 This->data_in_alsa_frames -= data_frames_played;
2301
2302 if(This->held_frames > data_frames_played){
2303 if(This->started)
2304 This->held_frames -= data_frames_played;
2305 }else
2306 This->held_frames = 0;
2307
2308 while(avail && max_copy_frames){
2309 snd_pcm_uframes_t to_write;
2310
2311 to_write = min(avail, max_copy_frames);
2312
2313 written = alsa_write_buffer_wrap(This, This->local_buffer,
2314 This->bufsize_frames, This->lcl_offs_frames, to_write);
2315 if(written <= 0)
2316 break;
2317
2318 avail -= written;
2319 This->lcl_offs_frames += written;
2320 This->lcl_offs_frames %= This->bufsize_frames;
2321 This->data_in_alsa_frames += written;
2322 max_copy_frames -= written;
2323 }
2324
2325 if(This->event)
2326 SetEvent(This->event);
2327 }
2328
2329 static void alsa_read_data(ACImpl *This)
2330 {
2331 snd_pcm_sframes_t nread;
2332 UINT32 pos = This->wri_offs_frames, limit = This->held_frames;
2333
2334 if(!This->started)
2335 goto exit;
2336
2337 /* FIXME: Detect overrun and signal DATA_DISCONTINUITY
2338 * How to count overrun frames and report them as position increase? */
2339 limit = This->bufsize_frames - max(limit, pos);
2340
2341 nread = snd_pcm_readi(This->pcm_handle,
2342 This->local_buffer + pos * This->fmt->nBlockAlign, limit);
2343 TRACE("read %ld from %u limit %u\n", nread, pos, limit);
2344 if(nread < 0){
2345 int ret;
2346
2347 if(nread == -EAGAIN) /* no data yet */
2348 return;
2349
2350 WARN("read failed, recovering: %ld (%s)\n", nread, snd_strerror(nread));
2351
2352 ret = snd_pcm_recover(This->pcm_handle, nread, 0);
2353 if(ret < 0){
2354 WARN("Recover failed: %d (%s)\n", ret, snd_strerror(ret));
2355 return;
2356 }
2357
2358 nread = snd_pcm_readi(This->pcm_handle,
2359 This->local_buffer + pos * This->fmt->nBlockAlign, limit);
2360 if(nread < 0){
2361 WARN("read failed: %ld (%s)\n", nread, snd_strerror(nread));
2362 return;
2363 }
2364 }
2365
2366 if(This->session->mute){
2367 int err;
2368 if((err = snd_pcm_format_set_silence(This->alsa_format,
2369 This->local_buffer + pos * This->fmt->nBlockAlign,
2370 nread)) < 0)
2371 WARN("Setting buffer to silence failed: %d (%s)\n", err,
2372 snd_strerror(err));
2373 }
2374
2375 This->wri_offs_frames += nread;
2376 This->wri_offs_frames %= This->bufsize_frames;
2377 This->held_frames += nread;
2378
2379 exit:
2380 if(This->event)
2381 SetEvent(This->event);
2382 }
2383
2384 static void CALLBACK alsa_push_buffer_data(void *user, BOOLEAN timer)
2385 {
2386 ACImpl *This = user;
2387
2388 EnterCriticalSection(&This->lock);
2389
2390 QueryPerformanceCounter(&This->last_period_time);
2391
2392 if(This->dataflow == eRender)
2393 alsa_write_data(This);
2394 else if(This->dataflow == eCapture)
2395 alsa_read_data(This);
2396
2397 LeaveCriticalSection(&This->lock);
2398 }
2399
2400 static snd_pcm_uframes_t interp_elapsed_frames(ACImpl *This)
2401 {
2402 LARGE_INTEGER time_freq, current_time, time_diff;
2403 QueryPerformanceFrequency(&time_freq);
2404 QueryPerformanceCounter(&current_time);
2405 time_diff.QuadPart = current_time.QuadPart - This->last_period_time.QuadPart;
2406 return MulDiv(time_diff.QuadPart, This->fmt->nSamplesPerSec, time_freq.QuadPart);
2407 }
2408
2409 static int alsa_rewind_best_effort(ACImpl *This)
2410 {
2411 snd_pcm_uframes_t len, leave;
2412
2413 /* we can't use snd_pcm_rewindable, some PCM devices crash. so follow
2414 * PulseAudio's example and rewind as much data as we believe is in the
2415 * buffer, minus 1.33ms for safety. */
2416
2417 /* amount of data to leave in ALSA buffer */
2418 leave = interp_elapsed_frames(This) + This->safe_rewind_frames;
2419
2420 if(This->held_frames < leave)
2421 This->held_frames = 0;
2422 else
2423 This->held_frames -= leave;
2424
2425 if(This->data_in_alsa_frames < leave)
2426 len = 0;
2427 else
2428 len = This->data_in_alsa_frames - leave;
2429
2430 TRACE("rewinding %lu frames, now held %u\n", len, This->held_frames);
2431
2432 if(len)
2433 /* snd_pcm_rewind return value is often broken, assume it succeeded */
2434 snd_pcm_rewind(This->pcm_handle, len);
2435
2436 This->data_in_alsa_frames = 0;
2437
2438 return len;
2439 }
2440
2441 static HRESULT WINAPI AudioClient_Start(IAudioClient3 *iface)
2442 {
2443 ACImpl *This = impl_from_IAudioClient3(iface);
2444
2445 TRACE("(%p)\n", This);
2446
2447 EnterCriticalSection(&This->lock);
2448
2449 if(!This->initted){
2450 LeaveCriticalSection(&This->lock);
2451 return AUDCLNT_E_NOT_INITIALIZED;
2452 }
2453
2454 if((This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK) && !This->event){
2455 LeaveCriticalSection(&This->lock);
2456 return AUDCLNT_E_EVENTHANDLE_NOT_SET;
2457 }
2458
2459 if(This->started){
2460 LeaveCriticalSection(&This->lock);
2461 return AUDCLNT_E_NOT_STOPPED;
2462 }
2463
2464 if(This->dataflow == eCapture){
2465 /* dump any data that might be leftover in the ALSA capture buffer */
2466 snd_pcm_readi(This->pcm_handle, This->local_buffer,
2467 This->bufsize_frames);
2468 }else{
2469 snd_pcm_sframes_t avail, written;
2470 snd_pcm_uframes_t offs;
2471
2472 avail = snd_pcm_avail_update(This->pcm_handle);
2473 avail = min(avail, This->held_frames);
2474
2475 if(This->wri_offs_frames < This->held_frames)
2476 offs = This->bufsize_frames - This->held_frames + This->wri_offs_frames;
2477 else
2478 offs = This->wri_offs_frames - This->held_frames;
2479
2480 /* fill it with data */
2481 written = alsa_write_buffer_wrap(This, This->local_buffer,
2482 This->bufsize_frames, offs, avail);
2483
2484 if(written > 0){
2485 This->lcl_offs_frames = (offs + written) % This->bufsize_frames;
2486 This->data_in_alsa_frames = written;
2487 }else{
2488 This->lcl_offs_frames = offs;
2489 This->data_in_alsa_frames = 0;
2490 }
2491 }
2492
2493 if(!This->timer){
2494 if(!CreateTimerQueueTimer(&This->timer, g_timer_q, alsa_push_buffer_data,
2495 This, 0, This->mmdev_period_rt / 10000, WT_EXECUTEINTIMERTHREAD)){
2496 LeaveCriticalSection(&This->lock);
2497 WARN("Unable to create timer: %u\n", GetLastError());
2498 return E_OUTOFMEMORY;
2499 }
2500 }
2501
2502 This->started = TRUE;
2503
2504 LeaveCriticalSection(&This->lock);
2505
2506 return S_OK;
2507 }
2508
2509 static HRESULT WINAPI AudioClient_Stop(IAudioClient3 *iface)
2510 {
2511 ACImpl *This = impl_from_IAudioClient3(iface);
2512
2513 TRACE("(%p)\n", This);
2514
2515 EnterCriticalSection(&This->lock);
2516
2517 if(!This->initted){
2518 LeaveCriticalSection(&This->lock);
2519 return AUDCLNT_E_NOT_INITIALIZED;
2520 }
2521
2522 if(!This->started){
2523 LeaveCriticalSection(&This->lock);
2524 return S_FALSE;
2525 }
2526
2527 if(This->dataflow == eRender)
2528 alsa_rewind_best_effort(This);
2529
2530 This->started = FALSE;
2531
2532 LeaveCriticalSection(&This->lock);
2533
2534 return S_OK;
2535 }
2536
2537 static HRESULT WINAPI AudioClient_Reset(IAudioClient3 *iface)
2538 {
2539 ACImpl *This = impl_from_IAudioClient3(iface);
2540
2541 TRACE("(%p)\n", This);
2542
2543 EnterCriticalSection(&This->lock);
2544
2545 if(!This->initted){
2546 LeaveCriticalSection(&This->lock);
2547 return AUDCLNT_E_NOT_INITIALIZED;
2548 }
2549
2550 if(This->started){
2551 LeaveCriticalSection(&This->lock);
2552 return AUDCLNT_E_NOT_STOPPED;
2553 }
2554
2555 if(This->getbuf_last){
2556 LeaveCriticalSection(&This->lock);
2557 return AUDCLNT_E_BUFFER_OPERATION_PENDING;
2558 }
2559
2560 if(snd_pcm_drop(This->pcm_handle) < 0)
2561 WARN("snd_pcm_drop failed\n");
2562
2563 if(snd_pcm_reset(This->pcm_handle) < 0)
2564 WARN("snd_pcm_reset failed\n");
2565
2566 if(snd_pcm_prepare(This->pcm_handle) < 0)
2567 WARN("snd_pcm_prepare failed\n");
2568
2569 if(This->dataflow == eRender){
2570 This->written_frames = 0;
2571 This->last_pos_frames = 0;
2572 }else{
2573 This->written_frames += This->held_frames;
2574 }
2575 This->held_frames = 0;
2576 This->lcl_offs_frames = 0;
2577 This->wri_offs_frames = 0;
2578
2579 LeaveCriticalSection(&This->lock);
2580
2581 return S_OK;
2582 }
2583
2584 static HRESULT WINAPI AudioClient_SetEventHandle(IAudioClient3 *iface,
2585 HANDLE event)
2586 {
2587 ACImpl *This = impl_from_IAudioClient3(iface);
2588
2589 TRACE("(%p)->(%p)\n", This, event);
2590
2591 if(!event)
2592 return E_INVALIDARG;
2593
2594 EnterCriticalSection(&This->lock);
2595
2596 if(!This->initted){
2597 LeaveCriticalSection(&This->lock);
2598 return AUDCLNT_E_NOT_INITIALIZED;
2599 }
2600
2601 if(!(This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK)){
2602 LeaveCriticalSection(&This->lock);
2603 return AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED;
2604 }
2605
2606 if (This->event){
2607 LeaveCriticalSection(&This->lock);
2608 FIXME("called twice\n");
2609 return HRESULT_FROM_WIN32(ERROR_INVALID_NAME);
2610 }
2611
2612 This->event = event;
2613
2614 LeaveCriticalSection(&This->lock);
2615
2616 return S_OK;
2617 }
2618
2619 static HRESULT WINAPI AudioClient_GetService(IAudioClient3 *iface, REFIID riid,
2620 void **ppv)
2621 {
2622 ACImpl *This = impl_from_IAudioClient3(iface);
2623
2624 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
2625
2626 if(!ppv)
2627 return E_POINTER;
2628 *ppv = NULL;
2629
2630 EnterCriticalSection(&This->lock);
2631
2632 if(!This->initted){
2633 LeaveCriticalSection(&This->lock);
2634 return AUDCLNT_E_NOT_INITIALIZED;
2635 }
2636
2637 if(IsEqualIID(riid, &IID_IAudioRenderClient)){
2638 if(This->dataflow != eRender){
2639 LeaveCriticalSection(&This->lock);
2640 return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
2641 }
2642 IAudioRenderClient_AddRef(&This->IAudioRenderClient_iface);
2643 *ppv = &This->IAudioRenderClient_iface;
2644 }else if(IsEqualIID(riid, &IID_IAudioCaptureClient)){
2645 if(This->dataflow != eCapture){
2646 LeaveCriticalSection(&This->lock);
2647 return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
2648 }
2649 IAudioCaptureClient_AddRef(&This->IAudioCaptureClient_iface);
2650 *ppv = &This->IAudioCaptureClient_iface;
2651 }else if(IsEqualIID(riid, &IID_IAudioClock)){
2652 IAudioClock_AddRef(&This->IAudioClock_iface);
2653 *ppv = &This->IAudioClock_iface;
2654 }else if(IsEqualIID(riid, &IID_IAudioStreamVolume)){
2655 IAudioStreamVolume_AddRef(&This->IAudioStreamVolume_iface);
2656 *ppv = &This->IAudioStreamVolume_iface;
2657 }else if(IsEqualIID(riid, &IID_IAudioSessionControl)){
2658 if(!This->session_wrapper){
2659 This->session_wrapper = AudioSessionWrapper_Create(This);
2660 if(!This->session_wrapper){
2661 LeaveCriticalSection(&This->lock);
2662 return E_OUTOFMEMORY;
2663 }
2664 }else
2665 IAudioSessionControl2_AddRef(&This->session_wrapper->IAudioSessionControl2_iface);
2666
2667 *ppv = &This->session_wrapper->IAudioSessionControl2_iface;
2668 }else if(IsEqualIID(riid, &IID_IChannelAudioVolume)){
2669 if(!This->session_wrapper){
2670 This->session_wrapper = AudioSessionWrapper_Create(This);
2671 if(!This->session_wrapper){
2672 LeaveCriticalSection(&This->lock);
2673 return E_OUTOFMEMORY;
2674 }
2675 }else
2676 IChannelAudioVolume_AddRef(&This->session_wrapper->IChannelAudioVolume_iface);
2677
2678 *ppv = &This->session_wrapper->IChannelAudioVolume_iface;
2679 }else if(IsEqualIID(riid, &IID_ISimpleAudioVolume)){
2680 if(!This->session_wrapper){
2681 This->session_wrapper = AudioSessionWrapper_Create(This);
2682 if(!This->session_wrapper){
2683 LeaveCriticalSection(&This->lock);
2684 return E_OUTOFMEMORY;
2685 }
2686 }else
2687 ISimpleAudioVolume_AddRef(&This->session_wrapper->ISimpleAudioVolume_iface);
2688
2689 *ppv = &This->session_wrapper->ISimpleAudioVolume_iface;
2690 }
2691
2692 if(*ppv){
2693 LeaveCriticalSection(&This->lock);
2694 return S_OK;
2695 }
2696
2697 LeaveCriticalSection(&This->lock);
2698
2699 FIXME("stub %s\n", debugstr_guid(riid));
2700 return E_NOINTERFACE;
2701 }
2702
2703 static HRESULT WINAPI AudioClient_IsOffloadCapable(IAudioClient3 *iface,
2704 AUDIO_STREAM_CATEGORY category, BOOL *offload_capable)
2705 {
2706 ACImpl *This = impl_from_IAudioClient3(iface);
2707
2708 TRACE("(%p)->(0x%x, %p)\n", This, category, offload_capable);
2709
2710 if(!offload_capable)
2711 return E_INVALIDARG;
2712
2713 *offload_capable = FALSE;
2714
2715 return S_OK;
2716 }
2717
2718 static HRESULT WINAPI AudioClient_SetClientProperties(IAudioClient3 *iface,
2719 const AudioClientProperties *prop)
2720 {
2721 ACImpl *This = impl_from_IAudioClient3(iface);
2722 const Win8AudioClientProperties *legacy_prop = (const Win8AudioClientProperties *)prop;
2723
2724 TRACE("(%p)->(%p)\n", This, prop);
2725
2726 if(!legacy_prop)
2727 return E_POINTER;
2728
2729 if(legacy_prop->cbSize == sizeof(AudioClientProperties)){
2730 TRACE("{ bIsOffload: %u, eCategory: 0x%x, Options: 0x%x }\n",
2731 legacy_prop->bIsOffload,
2732 legacy_prop->eCategory,
2733 prop->Options);
2734 }else if(legacy_prop->cbSize == sizeof(Win8AudioClientProperties)){
2735 TRACE("{ bIsOffload: %u, eCategory: 0x%x }\n",
2736 legacy_prop->bIsOffload,
2737 legacy_prop->eCategory);
2738 }else{
2739 WARN("Unsupported Size = %d\n", legacy_prop->cbSize);
2740 return E_INVALIDARG;
2741 }
2742
2743
2744 if(legacy_prop->bIsOffload)
2745 return AUDCLNT_E_ENDPOINT_OFFLOAD_NOT_CAPABLE;
2746
2747 return S_OK;
2748 }
2749
2750 static HRESULT WINAPI AudioClient_GetBufferSizeLimits(IAudioClient3 *iface,
2751 const WAVEFORMATEX *format, BOOL event_driven, REFERENCE_TIME *min_duration,
2752 REFERENCE_TIME *max_duration)
2753 {
2754 ACImpl *This = impl_from_IAudioClient3(iface);
2755
2756 FIXME("(%p)->(%p, %u, %p, %p)\n", This, format, event_driven, min_duration, max_duration);
2757
2758 return E_NOTIMPL;
2759 }
2760
2761 static HRESULT WINAPI AudioClient_GetSharedModeEnginePeriod(IAudioClient3 *iface,
2762 const WAVEFORMATEX *format, UINT32 *default_period_frames, UINT32 *unit_period_frames,
2763 UINT32 *min_period_frames, UINT32 *max_period_frames)
2764 {
2765 ACImpl *This = impl_from_IAudioClient3(iface);
2766
2767 FIXME("(%p)->(%p, %p, %p, %p, %p)\n", This, format, default_period_frames, unit_period_frames,
2768 min_period_frames, max_period_frames);
2769
2770 return E_NOTIMPL;
2771 }
2772
2773 static HRESULT WINAPI AudioClient_GetCurrentSharedModeEnginePeriod(IAudioClient3 *iface,
2774 WAVEFORMATEX **cur_format, UINT32 *cur_period_frames)
2775 {
2776 ACImpl *This = impl_from_IAudioClient3(iface);
2777
2778 FIXME("(%p)->(%p, %p)\n", This, cur_format, cur_period_frames);
2779
2780 return E_NOTIMPL;
2781 }
2782
2783 static HRESULT WINAPI AudioClient_InitializeSharedAudioStream(IAudioClient3 *iface,
2784 DWORD flags, UINT32 period_frames, const WAVEFORMATEX *format,
2785 const GUID *session_guid)
2786 {
2787 ACImpl *This = impl_from_IAudioClient3(iface);
2788
2789 FIXME("(%p)->(0x%x, %u, %p, %s)\n", This, flags, period_frames, format, debugstr_guid(session_guid));
2790
2791 return E_NOTIMPL;
2792 }
2793
2794 static const IAudioClient3Vtbl AudioClient3_Vtbl =
2795 {
2796 AudioClient_QueryInterface,
2797 AudioClient_AddRef,
2798 AudioClient_Release,
2799 AudioClient_Initialize,
2800 AudioClient_GetBufferSize,
2801 AudioClient_GetStreamLatency,
2802 AudioClient_GetCurrentPadding,
2803 AudioClient_IsFormatSupported,
2804 AudioClient_GetMixFormat,
2805 AudioClient_GetDevicePeriod,
2806 AudioClient_Start,
2807 AudioClient_Stop,
2808 AudioClient_Reset,
2809 AudioClient_SetEventHandle,
2810 AudioClient_GetService,
2811 AudioClient_IsOffloadCapable,
2812 AudioClient_SetClientProperties,
2813 AudioClient_GetBufferSizeLimits,
2814 AudioClient_GetSharedModeEnginePeriod,
2815 AudioClient_GetCurrentSharedModeEnginePeriod,
2816 AudioClient_InitializeSharedAudioStream,
2817 };
2818
2819 static HRESULT WINAPI AudioRenderClient_QueryInterface(
2820 IAudioRenderClient *iface, REFIID riid, void **ppv)
2821 {
2822 ACImpl *This = impl_from_IAudioRenderClient(iface);
2823 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2824
2825 if(!ppv)
2826 return E_POINTER;
2827 *ppv = NULL;
2828
2829 if(IsEqualIID(riid, &IID_IUnknown) ||
2830 IsEqualIID(riid, &IID_IAudioRenderClient))
2831 *ppv = iface;
2832 else if(IsEqualIID(riid, &IID_IMarshal))
2833 return IUnknown_QueryInterface(This->pUnkFTMarshal, riid, ppv);
2834
2835 if(*ppv){
2836 IUnknown_AddRef((IUnknown*)*ppv);
2837 return S_OK;
2838 }
2839
2840 WARN("Unknown interface %s\n", debugstr_guid(riid));
2841 return E_NOINTERFACE;
2842 }
2843
2844 static ULONG WINAPI AudioRenderClient_AddRef(IAudioRenderClient *iface)
2845 {
2846 ACImpl *This = impl_from_IAudioRenderClient(iface);
2847 return AudioClient_AddRef(&This->IAudioClient3_iface);
2848 }
2849
2850 static ULONG WINAPI AudioRenderClient_Release(IAudioRenderClient *iface)
2851 {
2852 ACImpl *This = impl_from_IAudioRenderClient(iface);
2853 return AudioClient_Release(&This->IAudioClient3_iface);
2854 }
2855
2856 static HRESULT WINAPI AudioRenderClient_GetBuffer(IAudioRenderClient *iface,
2857 UINT32 frames, BYTE **data)
2858 {
2859 ACImpl *This = impl_from_IAudioRenderClient(iface);
2860 UINT32 write_pos;
2861
2862 TRACE("(%p)->(%u, %p)\n", This, frames, data);
2863
2864 if(!data)
2865 return E_POINTER;
2866 *data = NULL;
2867
2868 EnterCriticalSection(&This->lock);
2869
2870 if(This->getbuf_last){
2871 LeaveCriticalSection(&This->lock);
2872 return AUDCLNT_E_OUT_OF_ORDER;
2873 }
2874
2875 if(!frames){
2876 LeaveCriticalSection(&This->lock);
2877 return S_OK;
2878 }
2879
2880 /* held_frames == GetCurrentPadding_nolock(); */
2881 if(This->held_frames + frames > This->bufsize_frames){
2882 LeaveCriticalSection(&This->lock);
2883 return AUDCLNT_E_BUFFER_TOO_LARGE;
2884 }
2885
2886 write_pos = This->wri_offs_frames;
2887 if(write_pos + frames > This->bufsize_frames){
2888 if(This->tmp_buffer_frames < frames){
2889 HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
2890 This->tmp_buffer = HeapAlloc(GetProcessHeap(), 0,
2891 frames * This->fmt->nBlockAlign);
2892 if(!This->tmp_buffer){
2893 LeaveCriticalSection(&This->lock);
2894 return E_OUTOFMEMORY;
2895 }
2896 This->tmp_buffer_frames = frames;
2897 }
2898 *data = This->tmp_buffer;
2899 This->getbuf_last = -frames;
2900 }else{
2901 *data = This->local_buffer + write_pos * This->fmt->nBlockAlign;
2902 This->getbuf_last = frames;
2903 }
2904
2905 silence_buffer(This, *data, frames);
2906
2907 LeaveCriticalSection(&This->lock);
2908
2909 return S_OK;
2910 }
2911
2912 static void alsa_wrap_buffer(ACImpl *This, BYTE *buffer, UINT32 written_frames)
2913 {
2914 snd_pcm_uframes_t write_offs_frames = This->wri_offs_frames;
2915 UINT32 write_offs_bytes = write_offs_frames * This->fmt->nBlockAlign;
2916 snd_pcm_uframes_t chunk_frames = This->bufsize_frames - write_offs_frames;
2917 UINT32 chunk_bytes = chunk_frames * This->fmt->nBlockAlign;
2918 UINT32 written_bytes = written_frames * This->fmt->nBlockAlign;
2919
2920 if(written_bytes <= chunk_bytes){
2921 memcpy(This->local_buffer + write_offs_bytes, buffer, written_bytes);
2922 }else{
2923 memcpy(This->local_buffer + write_offs_bytes, buffer, chunk_bytes);
2924 memcpy(This->local_buffer, buffer + chunk_bytes,
2925 written_bytes - chunk_bytes);
2926 }
2927 }
2928
2929 static HRESULT WINAPI AudioRenderClient_ReleaseBuffer(
2930 IAudioRenderClient *iface, UINT32 written_frames, DWORD flags)
2931 {
2932 ACImpl *This = impl_from_IAudioRenderClient(iface);
2933 BYTE *buffer;
2934
2935 TRACE("(%p)->(%u, %x)\n", This, written_frames, flags);
2936
2937 EnterCriticalSection(&This->lock);
2938
2939 if(!written_frames){
2940 This->getbuf_last = 0;
2941 LeaveCriticalSection(&This->lock);
2942 return S_OK;
2943 }
2944
2945 if(!This->getbuf_last){
2946 LeaveCriticalSection(&This->lock);
2947 return AUDCLNT_E_OUT_OF_ORDER;
2948 }
2949
2950 if(written_frames > (This->getbuf_last >= 0 ? This->getbuf_last : -This->getbuf_last)){
2951 LeaveCriticalSection(&This->lock);
2952 return AUDCLNT_E_INVALID_SIZE;
2953 }
2954
2955 if(This->getbuf_last >= 0)
2956 buffer = This->local_buffer + This->wri_offs_frames * This->fmt->nBlockAlign;
2957 else
2958 buffer = This->tmp_buffer;
2959
2960 if(flags & AUDCLNT_BUFFERFLAGS_SILENT)
2961 silence_buffer(This, buffer, written_frames);
2962
2963 if(This->getbuf_last < 0)
2964 alsa_wrap_buffer(This, buffer, written_frames);
2965
2966 This->wri_offs_frames += written_frames;
2967 This->wri_offs_frames %= This->bufsize_frames;
2968 This->held_frames += written_frames;
2969 This->written_frames += written_frames;
2970 This->getbuf_last = 0;
2971
2972 LeaveCriticalSection(&This->lock);
2973
2974 return S_OK;
2975 }
2976
2977 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl = {
2978 AudioRenderClient_QueryInterface,
2979 AudioRenderClient_AddRef,
2980 AudioRenderClient_Release,
2981 AudioRenderClient_GetBuffer,
2982 AudioRenderClient_ReleaseBuffer
2983 };
2984
2985 static HRESULT WINAPI AudioCaptureClient_QueryInterface(
2986 IAudioCaptureClient *iface, REFIID riid, void **ppv)
2987 {
2988 ACImpl *This = impl_from_IAudioCaptureClient(iface);
2989 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2990
2991 if(!ppv)
2992 return E_POINTER;
2993 *ppv = NULL;
2994
2995 if(IsEqualIID(riid, &IID_IUnknown) ||
2996 IsEqualIID(riid, &IID_IAudioCaptureClient))
2997 *ppv = iface;
2998 else if(IsEqualIID(riid, &IID_IMarshal))
2999 return IUnknown_QueryInterface(This->pUnkFTMarshal, riid, ppv);
3000
3001 if(*ppv){
3002 IUnknown_AddRef((IUnknown*)*ppv);
3003 return S_OK;
3004 }
3005
3006 WARN("Unknown interface %s\n", debugstr_guid(riid));
3007 return E_NOINTERFACE;
3008 }
3009
3010 static ULONG WINAPI AudioCaptureClient_AddRef(IAudioCaptureClient *iface)
3011 {
3012 ACImpl *This = impl_from_IAudioCaptureClient(iface);
3013 return IAudioClient3_AddRef(&This->IAudioClient3_iface);
3014 }
3015
3016 static ULONG WINAPI AudioCaptureClient_Release(IAudioCaptureClient *iface)
3017 {
3018 ACImpl *This = impl_from_IAudioCaptureClient(iface);
3019 return IAudioClient3_Release(&This->IAudioClient3_iface);
3020 }
3021
3022 static HRESULT WINAPI AudioCaptureClient_GetBuffer(IAudioCaptureClient *iface,
3023 BYTE **data, UINT32 *frames, DWORD *flags, UINT64 *devpos,
3024 UINT64 *qpcpos)
3025 {
3026 ACImpl *This = impl_from_IAudioCaptureClient(iface);
3027
3028 TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This, data, frames, flags,
3029 devpos, qpcpos);
3030
3031 if(!data)
3032 return E_POINTER;
3033
3034 *data = NULL;
3035
3036 if(!frames || !flags)
3037 return E_POINTER;
3038
3039 EnterCriticalSection(&This->lock);
3040
3041 if(This->getbuf_last){
3042 LeaveCriticalSection(&This->lock);
3043 return AUDCLNT_E_OUT_OF_ORDER;
3044 }
3045
3046 /* hr = GetNextPacketSize(iface, frames); */
3047 if(This->held_frames < This->mmdev_period_frames){
3048 *frames = 0;
3049 LeaveCriticalSection(&This->lock);
3050 return AUDCLNT_S_BUFFER_EMPTY;
3051 }
3052 *frames = This->mmdev_period_frames;
3053
3054 if(This->lcl_offs_frames + *frames > This->bufsize_frames){
3055 UINT32 chunk_bytes, offs_bytes, frames_bytes;
3056 if(This->tmp_buffer_frames < *frames){
3057 HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
3058 This->tmp_buffer = HeapAlloc(GetProcessHeap(), 0,
3059 *frames * This->fmt->nBlockAlign);
3060 if(!This->tmp_buffer){
3061 LeaveCriticalSection(&This->lock);
3062 return E_OUTOFMEMORY;
3063 }
3064 This->tmp_buffer_frames = *frames;
3065 }
3066
3067 *data = This->tmp_buffer;
3068 chunk_bytes = (This->bufsize_frames - This->lcl_offs_frames) *
3069 This->fmt->nBlockAlign;
3070 offs_bytes = This->lcl_offs_frames * This->fmt->nBlockAlign;
3071 frames_bytes = *frames * This->fmt->nBlockAlign;
3072 memcpy(This->tmp_buffer, This->local_buffer + offs_bytes, chunk_bytes);
3073 memcpy(This->tmp_buffer + chunk_bytes, This->local_buffer,
3074 frames_bytes - chunk_bytes);
3075 }else
3076 *data = This->local_buffer +
3077 This->lcl_offs_frames * This->fmt->nBlockAlign;
3078
3079 This->getbuf_last = *frames;
3080 *flags = 0;
3081
3082 if(devpos)
3083 *devpos = This->written_frames;
3084 if(qpcpos){ /* fixme: qpc of recording time */
3085 LARGE_INTEGER stamp, freq;
3086 QueryPerformanceCounter(&stamp);
3087 QueryPerformanceFrequency(&freq);
3088 *qpcpos = (stamp.QuadPart * (INT64)10000000) / freq.QuadPart;
3089 }
3090
3091 LeaveCriticalSection(&This->lock);
3092
3093 return *frames ? S_OK : AUDCLNT_S_BUFFER_EMPTY;
3094 }
3095
3096 static HRESULT WINAPI AudioCaptureClient_ReleaseBuffer(
3097 IAudioCaptureClient *iface, UINT32 done)
3098 {
3099 ACImpl *This = impl_from_IAudioCaptureClient(iface);
3100
3101 TRACE("(%p)->(%u)\n", This, done);
3102
3103 EnterCriticalSection(&This->lock);
3104
3105 if(!done){
3106 This->getbuf_last = 0;
3107 LeaveCriticalSection(&This->lock);
3108 return S_OK;
3109 }
3110
3111 if(!This->getbuf_last){
3112 LeaveCriticalSection(&This->lock);
3113 return AUDCLNT_E_OUT_OF_ORDER;
3114 }
3115
3116 if(This->getbuf_last != done){
3117 LeaveCriticalSection(&This->lock);
3118 return AUDCLNT_E_INVALID_SIZE;
3119 }
3120
3121 This->written_frames += done;
3122 This->held_frames -= done;
3123 This->lcl_offs_frames += done;
3124 This->lcl_offs_frames %= This->bufsize_frames;
3125 This->getbuf_last = 0;
3126
3127 LeaveCriticalSection(&This->lock);
3128
3129 return S_OK;
3130 }
3131
3132 static HRESULT WINAPI AudioCaptureClient_GetNextPacketSize(
3133 IAudioCaptureClient *iface, UINT32 *frames)
3134 {
3135 ACImpl *This = impl_from_IAudioCaptureClient(iface);
3136
3137 TRACE("(%p)->(%p)\n", This, frames);
3138
3139 if(!frames)
3140 return E_POINTER;
3141
3142 EnterCriticalSection(&This->lock);
3143
3144 *frames = This->held_frames < This->mmdev_period_frames ? 0 : This->mmdev_period_frames;
3145
3146 LeaveCriticalSection(&This->lock);
3147
3148 return S_OK;
3149 }
3150
3151 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl =
3152 {
3153 AudioCaptureClient_QueryInterface,
3154 AudioCaptureClient_AddRef,
3155 AudioCaptureClient_Release,
3156 AudioCaptureClient_GetBuffer,
3157 AudioCaptureClient_ReleaseBuffer,
3158 AudioCaptureClient_GetNextPacketSize
3159 };
3160
3161 static HRESULT WINAPI AudioClock_QueryInterface(IAudioClock *iface,
3162 REFIID riid, void **ppv)
3163 {
3164 ACImpl *This = impl_from_IAudioClock(iface);
3165
3166 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3167
3168 if(!ppv)
3169 return E_POINTER;
3170 *ppv = NULL;
3171
3172 if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAudioClock))
3173 *ppv = iface;
3174 else if(IsEqualIID(riid, &IID_IAudioClock2))
3175 *ppv = &This->IAudioClock2_iface;
3176 if(*ppv){
3177 IUnknown_AddRef((IUnknown*)*ppv);
3178 return S_OK;
3179 }
3180
3181 WARN("Unknown interface %s\n", debugstr_guid(riid));
3182 return E_NOINTERFACE;
3183 }
3184
3185 static ULONG WINAPI AudioClock_AddRef(IAudioClock *iface)
3186 {
3187 ACImpl *This = impl_from_IAudioClock(iface);
3188 return IAudioClient3_AddRef(&This->IAudioClient3_iface);
3189 }
3190
3191 static ULONG WINAPI AudioClock_Release(IAudioClock *iface)
3192 {
3193 ACImpl *This = impl_from_IAudioClock(iface);
3194 return IAudioClient3_Release(&This->IAudioClient3_iface);
3195 }
3196
3197 static HRESULT WINAPI AudioClock_GetFrequency(IAudioClock *iface, UINT64 *freq)
3198 {
3199 ACImpl *This = impl_from_IAudioClock(iface);
3200
3201 TRACE("(%p)->(%p)\n", This, freq);
3202
3203 if(This->share == AUDCLNT_SHAREMODE_SHARED)
3204 *freq = (UINT64)This->fmt->nSamplesPerSec * This->fmt->nBlockAlign;
3205 else
3206 *freq = This->fmt->nSamplesPerSec;
3207
3208 return S_OK;
3209 }
3210
3211 static HRESULT WINAPI AudioClock_GetPosition(IAudioClock *iface, UINT64 *pos,
3212 UINT64 *qpctime)
3213 {
3214 ACImpl *This = impl_from_IAudioClock(iface);
3215 UINT64 position;
3216 snd_pcm_state_t alsa_state;
3217
3218 TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
3219
3220 if(!pos)
3221 return E_POINTER;
3222
3223 EnterCriticalSection(&This->lock);
3224
3225 /* avail_update required to get accurate snd_pcm_state() */
3226 snd_pcm_avail_update(This->pcm_handle);
3227 alsa_state = snd_pcm_state(This->pcm_handle);
3228
3229 if(This->dataflow == eRender){
3230 position = This->written_frames - This->held_frames;
3231
3232 if(This->started && alsa_state == SND_PCM_STATE_RUNNING && This->held_frames)
3233 /* we should be using snd_pcm_delay here, but it is broken
3234 * especially during ALSA device underrun. instead, let's just
3235 * interpolate between periods with the system timer. */
3236 position += interp_elapsed_frames(This);
3237
3238 position = min(position, This->written_frames - This->held_frames + This->mmdev_period_frames);
3239
3240 position = min(position, This->written_frames);
3241 }else
3242 position = This->written_frames + This->held_frames;
3243
3244 /* ensure monotic growth */
3245 if(position < This->last_pos_frames)
3246 position = This->last_pos_frames;
3247 else
3248 This->last_pos_frames = position;
3249
3250 TRACE("frames written: %u, held: %u, state: 0x%x, position: %u\n",
3251 (UINT32)(This->written_frames%1000000000), This->held_frames,
3252 alsa_state, (UINT32)(position%1000000000));
3253
3254 LeaveCriticalSection(&This->lock);
3255
3256 if(This->share == AUDCLNT_SHAREMODE_SHARED)
3257 *pos = position * This->fmt->nBlockAlign;
3258 else
3259 *pos = position;
3260
3261 if(qpctime){
3262 LARGE_INTEGER stamp, freq;
3263 QueryPerformanceCounter(&stamp);
3264 QueryPerformanceFrequency(&freq);
3265 *qpctime = (stamp.QuadPart * (INT64)10000000) / freq.QuadPart;
3266 }
3267
3268 return S_OK;
3269 }
3270
3271 static HRESULT WINAPI AudioClock_GetCharacteristics(IAudioClock *iface,
3272 DWORD *chars)
3273 {
3274 ACImpl *This = impl_from_IAudioClock(iface);
3275
3276 TRACE("(%p)->(%p)\n", This, chars);
3277
3278 if(!chars)
3279 return E_POINTER;
3280
3281 *chars = AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ;
3282
3283 return S_OK;
3284 }
3285
3286 static const IAudioClockVtbl AudioClock_Vtbl =
3287 {
3288 AudioClock_QueryInterface,
3289 AudioClock_AddRef,
3290 AudioClock_Release,
3291 AudioClock_GetFrequency,
3292 AudioClock_GetPosition,
3293 AudioClock_GetCharacteristics
3294 };
3295
3296 static HRESULT WINAPI AudioClock2_QueryInterface(IAudioClock2 *iface,
3297 REFIID riid, void **ppv)
3298 {
3299 ACImpl *This = impl_from_IAudioClock2(iface);
3300 return IAudioClock_QueryInterface(&This->IAudioClock_iface, riid, ppv);
3301 }
3302
3303 static ULONG WINAPI AudioClock2_AddRef(IAudioClock2 *iface)
3304 {
3305 ACImpl *This = impl_from_IAudioClock2(iface);
3306 return IAudioClient3_AddRef(&This->IAudioClient3_iface);
3307 }
3308
3309 static ULONG WINAPI AudioClock2_Release(IAudioClock2 *iface)
3310 {
3311 ACImpl *This = impl_from_IAudioClock2(iface);
3312 return IAudioClient3_Release(&This->IAudioClient3_iface);
3313 }
3314
3315 static HRESULT WINAPI AudioClock2_GetDevicePosition(IAudioClock2 *iface,
3316 UINT64 *pos, UINT64 *qpctime)
3317 {
3318 ACImpl *This = impl_from_IAudioClock2(iface);
3319
3320 FIXME("(%p)->(%p, %p)\n", This, pos, qpctime);
3321
3322 return E_NOTIMPL;
3323 }
3324
3325 static const IAudioClock2Vtbl AudioClock2_Vtbl =
3326 {
3327 AudioClock2_QueryInterface,
3328 AudioClock2_AddRef,
3329 AudioClock2_Release,
3330 AudioClock2_GetDevicePosition
3331 };
3332
3333 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client)
3334 {
3335 AudioSessionWrapper *ret;
3336
3337 ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
3338 sizeof(AudioSessionWrapper));
3339 if(!ret)
3340 return NULL;
3341
3342 ret->IAudioSessionControl2_iface.lpVtbl = &AudioSessionControl2_Vtbl;
3343 ret->ISimpleAudioVolume_iface.lpVtbl = &SimpleAudioVolume_Vtbl;
3344 ret->IChannelAudioVolume_iface.lpVtbl = &ChannelAudioVolume_Vtbl;
3345
3346 ret->ref = 1;
3347
3348 ret->client = client;
3349 if(client){
3350 ret->session = client->session;
3351 AudioClient_AddRef(&client->IAudioClient3_iface);
3352 }
3353
3354 return ret;
3355 }
3356
3357 static HRESULT WINAPI AudioSessionControl_QueryInterface(
3358 IAudioSessionControl2 *iface, REFIID riid, void **ppv)
3359 {
3360 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3361
3362 if(!ppv)
3363 return E_POINTER;
3364 *ppv = NULL;
3365
3366 if(IsEqualIID(riid, &IID_IUnknown) ||
3367 IsEqualIID(riid, &IID_IAudioSessionControl) ||
3368 IsEqualIID(riid, &IID_IAudioSessionControl2))
3369 *ppv = iface;
3370 if(*ppv){
3371 IUnknown_AddRef((IUnknown*)*ppv);
3372 return S_OK;
3373 }
3374
3375 WARN("Unknown interface %s\n", debugstr_guid(riid));
3376 return E_NOINTERFACE;
3377 }
3378
3379 static ULONG WINAPI AudioSessionControl_AddRef(IAudioSessionControl2 *iface)
3380 {
3381 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3382 ULONG ref;
3383 ref = InterlockedIncrement(&This->ref);
3384 TRACE("(%p) Refcount now %u\n", This, ref);
3385 return ref;
3386 }
3387
3388 static ULONG WINAPI AudioSessionControl_Release(IAudioSessionControl2 *iface)
3389 {
3390 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3391 ULONG ref;
3392 ref = InterlockedDecrement(&This->ref);
3393 TRACE("(%p) Refcount now %u\n", This, ref);
3394 if(!ref){
3395 if(This->client){
3396 EnterCriticalSection(&This->client->lock);
3397 This->client->session_wrapper = NULL;
3398 LeaveCriticalSection(&This->client->lock);
3399 AudioClient_Release(&This->client->IAudioClient3_iface);
3400 }
3401 HeapFree(GetProcessHeap(), 0, This);
3402 }
3403 return ref;
3404 }
3405
3406 static HRESULT WINAPI AudioSessionControl_GetState(IAudioSessionControl2 *iface,
3407 AudioSessionState *state)
3408 {
3409 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3410 ACImpl *client;
3411
3412 TRACE("(%p)->(%p)\n", This, state);
3413
3414 if(!state)
3415 return NULL_PTR_ERR;
3416
3417 EnterCriticalSection(&g_sessions_lock);
3418
3419 if(list_empty(&This->session->clients)){
3420 *state = AudioSessionStateExpired;
3421 LeaveCriticalSection(&g_sessions_lock);
3422 return S_OK;
3423 }
3424
3425 LIST_FOR_EACH_ENTRY(client, &This->session->clients, ACImpl, entry){
3426 EnterCriticalSection(&client->lock);
3427 if(client->started){
3428 *state = AudioSessionStateActive;
3429 LeaveCriticalSection(&client->lock);
3430 LeaveCriticalSection(&g_sessions_lock);
3431 return S_OK;
3432 }
3433 LeaveCriticalSection(&client->lock);
3434 }
3435
3436 LeaveCriticalSection(&g_sessions_lock);
3437
3438 *state = AudioSessionStateInactive;
3439
3440 return S_OK;
3441 }
3442
3443 static HRESULT WINAPI AudioSessionControl_GetDisplayName(
3444 IAudioSessionControl2 *iface, WCHAR **name)
3445 {
3446 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3447
3448 FIXME("(%p)->(%p) - stub\n", This, name);
3449
3450 return E_NOTIMPL;
3451 }
3452
3453 static HRESULT WINAPI AudioSessionControl_SetDisplayName(
3454 IAudioSessionControl2 *iface, const WCHAR *name, const GUID *session)
3455 {
3456 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3457
3458 FIXME("(%p)->(%p, %s) - stub\n", This, name, debugstr_guid(session));
3459
3460 return E_NOTIMPL;
3461 }
3462
3463 static HRESULT WINAPI AudioSessionControl_GetIconPath(
3464 IAudioSessionControl2 *iface, WCHAR **path)
3465 {
3466 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3467
3468 FIXME("(%p)->(%p) - stub\n", This, path);
3469
3470 return E_NOTIMPL;
3471 }
3472
3473 static HRESULT WINAPI AudioSessionControl_SetIconPath(
3474 IAudioSessionControl2 *iface, const WCHAR *path, const GUID *session)
3475 {
3476 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3477
3478 FIXME("(%p)->(%p, %s) - stub\n", This, path, debugstr_guid(session));
3479
3480 return E_NOTIMPL;
3481 }
3482
3483 static HRESULT WINAPI AudioSessionControl_GetGroupingParam(
3484 IAudioSessionControl2 *iface, GUID *group)
3485 {
3486 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3487
3488 FIXME("(%p)->(%p) - stub\n", This, group);
3489
3490 return E_NOTIMPL;
3491 }
3492
3493 static HRESULT WINAPI AudioSessionControl_SetGroupingParam(
3494 IAudioSessionControl2 *iface, const GUID *group, const GUID *session)
3495 {
3496 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3497
3498 FIXME("(%p)->(%s, %s) - stub\n", This, debugstr_guid(group),
3499 debugstr_guid(session));
3500
3501 return E_NOTIMPL;
3502 }
3503
3504 static HRESULT WINAPI AudioSessionControl_RegisterAudioSessionNotification(
3505 IAudioSessionControl2 *iface, IAudioSessionEvents *events)
3506 {
3507 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3508
3509 FIXME("(%p)->(%p) - stub\n", This, events);
3510
3511 return S_OK;
3512 }
3513
3514 static HRESULT WINAPI AudioSessionControl_UnregisterAudioSessionNotification(
3515 IAudioSessionControl2 *iface, IAudioSessionEvents *events)
3516 {
3517 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3518
3519 FIXME("(%p)->(%p) - stub\n", This, events);
3520
3521 return S_OK;
3522 }
3523
3524 static HRESULT WINAPI AudioSessionControl_GetSessionIdentifier(
3525 IAudioSessionControl2 *iface, WCHAR **id)
3526 {
3527 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3528
3529 FIXME("(%p)->(%p) - stub\n", This, id);
3530
3531 return E_NOTIMPL;
3532 }
3533
3534 static HRESULT WINAPI AudioSessionControl_GetSessionInstanceIdentifier(
3535 IAudioSessionControl2 *iface, WCHAR **id)
3536 {
3537 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3538
3539 FIXME("(%p)->(%p) - stub\n", This, id);
3540
3541 return E_NOTIMPL;
3542 }
3543
3544 static HRESULT WINAPI AudioSessionControl_GetProcessId(
3545 IAudioSessionControl2 *iface, DWORD *pid)
3546 {
3547 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3548
3549 TRACE("(%p)->(%p)\n", This, pid);
3550
3551 if(!pid)
3552 return E_POINTER;
3553
3554 *pid = GetCurrentProcessId();
3555
3556 return S_OK;
3557 }
3558
3559 static HRESULT WINAPI AudioSessionControl_IsSystemSoundsSession(
3560 IAudioSessionControl2 *iface)
3561 {
3562 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3563
3564 TRACE("(%p)\n", This);
3565
3566 return S_FALSE;
3567 }
3568
3569 static HRESULT WINAPI AudioSessionControl_SetDuckingPreference(
3570 IAudioSessionControl2 *iface, BOOL optout)
3571 {
3572 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
3573
3574 TRACE("(%p)->(%d)\n", This, optout);
3575
3576 return S_OK;
3577 }
3578
3579 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl =
3580 {
3581 AudioSessionControl_QueryInterface,
3582 AudioSessionControl_AddRef,
3583 AudioSessionControl_Release,
3584 AudioSessionControl_GetState,
3585 AudioSessionControl_GetDisplayName,
3586 AudioSessionControl_SetDisplayName,
3587 AudioSessionControl_GetIconPath,
3588 AudioSessionControl_SetIconPath,
3589 AudioSessionControl_GetGroupingParam,
3590 AudioSessionControl_SetGroupingParam,
3591 AudioSessionControl_RegisterAudioSessionNotification,
3592 AudioSessionControl_UnregisterAudioSessionNotification,
3593 AudioSessionControl_GetSessionIdentifier,
3594 AudioSessionControl_GetSessionInstanceIdentifier,
3595 AudioSessionControl_GetProcessId,
3596 AudioSessionControl_IsSystemSoundsSession,
3597 AudioSessionControl_SetDuckingPreference
3598 };
3599
3600 static HRESULT WINAPI SimpleAudioVolume_QueryInterface(
3601 ISimpleAudioVolume *iface, REFIID riid, void **ppv)
3602 {
3603 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3604
3605 if(!ppv)
3606 return E_POINTER;
3607 *ppv = NULL;
3608
3609 if(IsEqualIID(riid, &IID_IUnknown) ||
3610 IsEqualIID(riid, &IID_ISimpleAudioVolume))
3611 *ppv = iface;
3612 if(*ppv){
3613 IUnknown_AddRef((IUnknown*)*ppv);
3614 return S_OK;
3615 }
3616
3617 WARN("Unknown interface %s\n", debugstr_guid(riid));
3618 return E_NOINTERFACE;
3619 }
3620
3621 static ULONG WINAPI SimpleAudioVolume_AddRef(ISimpleAudioVolume *iface)
3622 {
3623 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3624 return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
3625 }
3626
3627 static ULONG WINAPI SimpleAudioVolume_Release(ISimpleAudioVolume *iface)
3628 {
3629 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3630 return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
3631 }
3632
3633 static HRESULT WINAPI SimpleAudioVolume_SetMasterVolume(
3634 ISimpleAudioVolume *iface, float level, const GUID *context)
3635 {
3636 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3637 AudioSession *session = This->session;
3638
3639 TRACE("(%p)->(%f, %s)\n", session, level, wine_dbgstr_guid(context));
3640
3641 if(level < 0.f || level > 1.f)
3642 return E_INVALIDARG;
3643
3644 if(context)
3645 FIXME("Notifications not supported yet\n");
3646
3647 TRACE("ALSA does not support volume control\n");
3648
3649 EnterCriticalSection(&session->lock);
3650
3651 session->master_vol = level;
3652
3653 LeaveCriticalSection(&session->lock);
3654
3655 return S_OK;
3656 }
3657
3658 static HRESULT WINAPI SimpleAudioVolume_GetMasterVolume(
3659 ISimpleAudioVolume *iface, float *level)
3660 {
3661 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3662 AudioSession *session = This->session;
3663
3664 TRACE("(%p)->(%p)\n", session, level);
3665
3666 if(!level)
3667 return NULL_PTR_ERR;
3668
3669 *level = session->master_vol;
3670
3671 return S_OK;
3672 }
3673
3674 static HRESULT WINAPI SimpleAudioVolume_SetMute(ISimpleAudioVolume *iface,
3675 BOOL mute, const GUID *context)
3676 {
3677 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3678 AudioSession *session = This->session;
3679
3680 TRACE("(%p)->(%u, %s)\n", session, mute, debugstr_guid(context));
3681
3682 if(context)
3683 FIXME("Notifications not supported yet\n");
3684
3685 session->mute = mute;
3686
3687 return S_OK;
3688 }
3689
3690 static HRESULT WINAPI SimpleAudioVolume_GetMute(ISimpleAudioVolume *iface,
3691 BOOL *mute)
3692 {
3693 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
3694 AudioSession *session = This->session;
3695
3696 TRACE("(%p)->(%p)\n", session, mute);
3697
3698 if(!mute)
3699 return NULL_PTR_ERR;
3700
3701 *mute = session->mute;
3702
3703 return S_OK;
3704 }
3705
3706 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl =
3707 {
3708 SimpleAudioVolume_QueryInterface,
3709 SimpleAudioVolume_AddRef,
3710 SimpleAudioVolume_Release,
3711 SimpleAudioVolume_SetMasterVolume,
3712 SimpleAudioVolume_GetMasterVolume,
3713 SimpleAudioVolume_SetMute,
3714 SimpleAudioVolume_GetMute
3715 };
3716
3717 static HRESULT WINAPI AudioStreamVolume_QueryInterface(
3718 IAudioStreamVolume *iface, REFIID riid, void **ppv)
3719 {
3720 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3721
3722 if(!ppv)
3723 return E_POINTER;
3724 *ppv = NULL;
3725
3726 if(IsEqualIID(riid, &IID_IUnknown) ||
3727 IsEqualIID(riid, &IID_IAudioStreamVolume))
3728 *ppv = iface;
3729 if(*ppv){
3730 IUnknown_AddRef((IUnknown*)*ppv);
3731 return S_OK;
3732 }
3733
3734 WARN("Unknown interface %s\n", debugstr_guid(riid));
3735 return E_NOINTERFACE;
3736 }
3737
3738 static ULONG WINAPI AudioStreamVolume_AddRef(IAudioStreamVolume *iface)
3739 {
3740 ACImpl *This = impl_from_IAudioStreamVolume(iface);
3741 return IAudioClient3_AddRef(&This->IAudioClient3_iface);
3742 }
3743
3744 static ULONG WINAPI AudioStreamVolume_Release(IAudioStreamVolume *iface)
3745 {
3746 ACImpl *This = impl_from_IAudioStreamVolume(iface);
3747 return IAudioClient3_Release(&This->IAudioClient3_iface);
3748 }
3749
3750 static HRESULT WINAPI AudioStreamVolume_GetChannelCount(
3751 IAudioStreamVolume *iface, UINT32 *out)
3752 {
3753 ACImpl *This = impl_from_IAudioStreamVolume(iface);
3754
3755 TRACE("(%p)->(%p)\n", This, out);
3756
3757 if(!out)
3758 return E_POINTER;
3759
3760 *out = This->fmt->nChannels;
3761
3762 return S_OK;
3763 }
3764
3765 static HRESULT WINAPI AudioStreamVolume_SetChannelVolume(
3766 IAudioStreamVolume *iface, UINT32 index, float level)
3767 {
3768 ACImpl *This = impl_from_IAudioStreamVolume(iface);
3769
3770 TRACE("(%p)->(%d, %f)\n", This, index, level);
3771
3772 if(level < 0.f || level > 1.f)
3773 return E_INVALIDARG;
3774
3775 if(index >= This->fmt->nChannels)
3776 return E_INVALIDARG;
3777
3778 TRACE("ALSA does not support volume control\n");
3779
3780 EnterCriticalSection(&This->lock);
3781
3782 This->vols[index] = level;
3783
3784 LeaveCriticalSection(&This->lock);
3785
3786 return S_OK;
3787 }
3788
3789 static HRESULT WINAPI AudioStreamVolume_GetChannelVolume(
3790 IAudioStreamVolume *iface, UINT32 index, float *level)
3791 {
3792 ACImpl *This = impl_from_IAudioStreamVolume(iface);
3793
3794 TRACE("(%p)->(%d, %p)\n", This, index, level);
3795
3796 if(!level)
3797 return E_POINTER;
3798
3799 if(index >= This->fmt->nChannels)
3800 return E_INVALIDARG;
3801
3802 *level = This->vols[index];
3803
3804 return S_OK;
3805 }
3806
3807 static HRESULT WINAPI AudioStreamVolume_SetAllVolumes(
3808 IAudioStreamVolume *iface, UINT32 count, const float *levels)
3809 {
3810 ACImpl *This = impl_from_IAudioStreamVolume(iface);
3811 unsigned int i;
3812
3813 TRACE("(%p)->(%d, %p)\n", This, count, levels);
3814
3815 if(!levels)
3816 return E_POINTER;
3817
3818 if(count != This->fmt->nChannels)
3819 return E_INVALIDARG;
3820
3821 TRACE("ALSA does not support volume control\n");
3822
3823 EnterCriticalSection(&This->lock);
3824
3825 for(i = 0; i < count; ++i)
3826 This->vols[i] = levels[i];
3827
3828 LeaveCriticalSection(&This->lock);
3829
3830 return S_OK;
3831 }
3832
3833 static HRESULT WINAPI AudioStreamVolume_GetAllVolumes(
3834 IAudioStreamVolume *iface, UINT32 count, float *levels)
3835 {
3836 ACImpl *This = impl_from_IAudioStreamVolume(iface);
3837 unsigned int i;
3838
3839 TRACE("(%p)->(%d, %p)\n", This, count, levels);
3840
3841 if(!levels)
3842 return E_POINTER;
3843
3844 if(count != This->fmt->nChannels)
3845 return E_INVALIDARG;
3846
3847 EnterCriticalSection(&This->lock);
3848
3849 for(i = 0; i < count; ++i)
3850 levels[i] = This->vols[i];
3851
3852 LeaveCriticalSection(&This->lock);
3853
3854 return S_OK;
3855 }
3856
3857 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl =
3858 {
3859 AudioStreamVolume_QueryInterface,
3860 AudioStreamVolume_AddRef,
3861 AudioStreamVolume_Release,
3862 AudioStreamVolume_GetChannelCount,
3863 AudioStreamVolume_SetChannelVolume,
3864 AudioStreamVolume_GetChannelVolume,
3865 AudioStreamVolume_SetAllVolumes,
3866 AudioStreamVolume_GetAllVolumes
3867 };
3868
3869 static HRESULT WINAPI ChannelAudioVolume_QueryInterface(
3870 IChannelAudioVolume *iface, REFIID riid, void **ppv)
3871 {
3872 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
3873
3874 if(!ppv)
3875 return E_POINTER;
3876 *ppv = NULL;
3877
3878 if(IsEqualIID(riid, &IID_IUnknown) ||
3879 IsEqualIID(riid, &IID_IChannelAudioVolume))
3880 *ppv = iface;
3881 if(*ppv){
3882 IUnknown_AddRef((IUnknown*)*ppv);
3883 return S_OK;
3884 }
3885
3886 WARN("Unknown interface %s\n", debugstr_guid(riid));
3887 return E_NOINTERFACE;
3888 }
3889
3890 static ULONG WINAPI ChannelAudioVolume_AddRef(IChannelAudioVolume *iface)
3891 {
3892 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3893 return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
3894 }
3895
3896 static ULONG WINAPI ChannelAudioVolume_Release(IChannelAudioVolume *iface)
3897 {
3898 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3899 return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
3900 }
3901
3902 static HRESULT WINAPI ChannelAudioVolume_GetChannelCount(
3903 IChannelAudioVolume *iface, UINT32 *out)
3904 {
3905 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3906 AudioSession *session = This->session;
3907
3908 TRACE("(%p)->(%p)\n", session, out);
3909
3910 if(!out)
3911 return NULL_PTR_ERR;
3912
3913 *out = session->channel_count;
3914
3915 return S_OK;
3916 }
3917
3918 static HRESULT WINAPI ChannelAudioVolume_SetChannelVolume(
3919 IChannelAudioVolume *iface, UINT32 index, float level,
3920 const GUID *context)
3921 {
3922 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3923 AudioSession *session = This->session;
3924
3925 TRACE("(%p)->(%d, %f, %s)\n", session, index, level,
3926 wine_dbgstr_guid(context));
3927
3928 if(level < 0.f || level > 1.f)
3929 return E_INVALIDARG;
3930
3931 if(index >= session->channel_count)
3932 return E_INVALIDARG;
3933
3934 if(context)
3935 FIXME("Notifications not supported yet\n");
3936
3937 TRACE("ALSA does not support volume control\n");
3938
3939 EnterCriticalSection(&session->lock);
3940
3941 session->channel_vols[index] = level;
3942
3943 LeaveCriticalSection(&session->lock);
3944
3945 return S_OK;
3946 }
3947
3948 static HRESULT WINAPI ChannelAudioVolume_GetChannelVolume(
3949 IChannelAudioVolume *iface, UINT32 index, float *level)
3950 {
3951 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3952 AudioSession *session = This->session;
3953
3954 TRACE("(%p)->(%d, %p)\n", session, index, level);
3955
3956 if(!level)
3957 return NULL_PTR_ERR;
3958
3959 if(index >= session->channel_count)
3960 return E_INVALIDARG;
3961
3962 *level = session->channel_vols[index];
3963
3964 return S_OK;
3965 }
3966
3967 static HRESULT WINAPI ChannelAudioVolume_SetAllVolumes(
3968 IChannelAudioVolume *iface, UINT32 count, const float *levels,
3969 const GUID *context)
3970 {
3971 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
3972 AudioSession *session = This->session;
3973 unsigned int i;
3974
3975 TRACE("(%p)->(%d, %p, %s)\n", session, count, levels,
3976 wine_dbgstr_guid(context));
3977
3978 if(!levels)
3979 return NULL_PTR_ERR;
3980
3981 if(count != session->channel_count)
3982 return E_INVALIDARG;
3983
3984 if(context)
3985 FIXME("Notifications not supported yet\n");
3986
3987 TRACE("ALSA does not support volume control\n");
3988
3989 EnterCriticalSection(&session->lock);
3990
3991 for(i = 0; i < count; ++i)
3992 session->channel_vols[i] = levels[i];
3993
3994 LeaveCriticalSection(&session->lock);
3995
3996 return S_OK;
3997 }
3998
3999 static HRESULT WINAPI ChannelAudioVolume_GetAllVolumes(
4000 IChannelAudioVolume *iface, UINT32 count, float *levels)
4001 {
4002 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
4003 AudioSession *session = This->session;
4004 unsigned int i;
4005
4006 TRACE("(%p)->(%d, %p)\n", session, count, levels);
4007
4008 if(!levels)
4009 return NULL_PTR_ERR;
4010
4011 if(count != session->channel_count)
4012 return E_INVALIDARG;
4013
4014 for(i = 0; i < count; ++i)
4015 levels[i] = session->channel_vols[i];
4016
4017 return S_OK;
4018 }
4019
4020 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl =
4021 {
4022 ChannelAudioVolume_QueryInterface,
4023 ChannelAudioVolume_AddRef,
4024 ChannelAudioVolume_Release,
4025 ChannelAudioVolume_GetChannelCount,
4026 ChannelAudioVolume_SetChannelVolume,
4027 ChannelAudioVolume_GetChannelVolume,
4028 ChannelAudioVolume_SetAllVolumes,
4029 ChannelAudioVolume_GetAllVolumes
4030 };
4031
4032 static HRESULT WINAPI AudioSessionManager_QueryInterface(IAudioSessionManager2 *iface,
4033 REFIID riid, void **ppv)
4034 {
4035 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
4036
4037 if(!ppv)
4038 return E_POINTER;
4039 *ppv = NULL;
4040
4041 if(IsEqualIID(riid, &IID_IUnknown) ||
4042 IsEqualIID(riid, &IID_IAudioSessionManager) ||
4043 IsEqualIID(riid, &IID_IAudioSessionManager2))
4044 *ppv = iface;
4045 if(*ppv){
4046 IUnknown_AddRef((IUnknown*)*ppv);
4047 return S_OK;
4048 }
4049
4050 WARN("Unknown interface %s\n", debugstr_guid(riid));
4051 return E_NOINTERFACE;
4052 }
4053
4054 static ULONG WINAPI AudioSessionManager_AddRef(IAudioSessionManager2 *iface)
4055 {
4056 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
4057 ULONG ref;
4058 ref = InterlockedIncrement(&This->ref);
4059 TRACE("(%p) Refcount now %u\n", This, ref);
4060 return ref;
4061 }
4062
4063 static ULONG WINAPI AudioSessionManager_Release(IAudioSessionManager2 *iface)
4064 {
4065 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
4066 ULONG ref;
4067 ref = InterlockedDecrement(&This->ref);
4068 TRACE("(%p) Refcount now %u\n", This, ref);
4069 if(!ref)
4070 HeapFree(GetProcessHeap(), 0, This);
4071 return ref;
4072 }
4073
4074 static HRESULT WINAPI AudioSessionManager_GetAudioSessionControl(
4075 IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
4076 IAudioSessionControl **out)
4077 {
4078 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
4079 AudioSession *session;
4080 AudioSessionWrapper *wrapper;
4081 HRESULT hr;
4082
4083 TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
4084 flags, out);
4085
4086 hr = get_audio_session(session_guid, This->device, 0, &session);
4087 if(FAILED(hr))
4088 return hr;
4089
4090 wrapper = AudioSessionWrapper_Create(NULL);
4091 if(!wrapper)
4092 return E_OUTOFMEMORY;
4093
4094 wrapper->session = session;
4095
4096 *out = (IAudioSessionControl*)&wrapper->IAudioSessionControl2_iface;
4097
4098 return S_OK;
4099 }
4100
4101 static HRESULT WINAPI AudioSessionManager_GetSimpleAudioVolume(
4102 IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
4103 ISimpleAudioVolume **out)
4104 {
4105 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
4106 AudioSession *session;
4107 AudioSessionWrapper *wrapper;
4108 HRESULT hr;
4109
4110 TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
4111 flags, out);
4112
4113 hr = get_audio_session(session_guid, This->device, 0, &session);
4114 if(FAILED(hr))
4115 return hr;
4116
4117 wrapper = AudioSessionWrapper_Create(NULL);
4118 if(!wrapper)
4119 return E_OUTOFMEMORY;
4120
4121 wrapper->session = session;
4122
4123 *out = &wrapper->ISimpleAudioVolume_iface;
4124
4125 return S_OK;
4126 }
4127
4128 static HRESULT WINAPI AudioSessionManager_GetSessionEnumerator(
4129 IAudioSessionManager2 *iface, IAudioSessionEnumerator **out)
4130 {
4131 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
4132 FIXME("(%p)->(%p) - stub\n", This, out);
4133 return E_NOTIMPL;
4134 }
4135
4136 static HRESULT WINAPI AudioSessionManager_RegisterSessionNotification(
4137 IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
4138 {
4139 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
4140 FIXME("(%p)->(%p) - stub\n", This, notification);
4141 return E_NOTIMPL;
4142 }
4143
4144 static HRESULT WINAPI AudioSessionManager_UnregisterSessionNotification(
4145 IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
4146 {
4147 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
4148 FIXME("(%p)->(%p) - stub\n", This, notification);
4149 return E_NOTIMPL;
4150 }
4151
4152 static HRESULT WINAPI AudioSessionManager_RegisterDuckNotification(
4153 IAudioSessionManager2 *iface, const WCHAR *session_id,
4154 IAudioVolumeDuckNotification *notification)
4155 {
4156 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
4157 FIXME("(%p)->(%p) - stub\n", This, notification);
4158 return E_NOTIMPL;
4159 }
4160
4161 static HRESULT WINAPI AudioSessionManager_UnregisterDuckNotification(
4162 IAudioSessionManager2 *iface,
4163 IAudioVolumeDuckNotification *notification)
4164 {
4165 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
4166 FIXME("(%p)->(%p) - stub\n", This, notification);
4167 return E_NOTIMPL;
4168 }
4169
4170 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl =
4171 {
4172 AudioSessionManager_QueryInterface,
4173 AudioSessionManager_AddRef,
4174 AudioSessionManager_Release,
4175 AudioSessionManager_GetAudioSessionControl,
4176 AudioSessionManager_GetSimpleAudioVolume,
4177 AudioSessionManager_GetSessionEnumerator,
4178 AudioSessionManager_RegisterSessionNotification,
4179 AudioSessionManager_UnregisterSessionNotification,
4180 AudioSessionManager_RegisterDuckNotification,
4181 AudioSessionManager_UnregisterDuckNotification
4182 };
4183
4184 HRESULT WINAPI AUDDRV_GetAudioSessionManager(IMMDevice *device,
4185 IAudioSessionManager2 **out)
4186 {
4187 SessionMgr *This;
4188
4189 This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SessionMgr));
4190 if(!This)
4191 return E_OUTOFMEMORY;
4192
4193 This->IAudioSessionManager2_iface.lpVtbl = &AudioSessionManager2_Vtbl;
4194 This->device = device;
4195 This->ref = 1;
4196
4197 *out = &This->IAudioSessionManager2_iface;
4198
4199 return S_OK;
4200 }
4201
4202 static unsigned int alsa_probe_num_speakers(char *name) {
4203 snd_pcm_t *handle;
4204 snd_pcm_hw_params_t *params;
4205 int err;
4206 unsigned int max_channels = 0;
4207
4208 if ((err = snd_pcm_open(&handle, name, SND_PCM_STREAM_PLAYBACK, SND_PCM_NONBLOCK)) < 0) {
4209 WARN("The device \"%s\" failed to open: %d (%s).\n",
4210 name, err, snd_strerror(err));
4211 return 0;
4212 }
4213
4214 params = HeapAlloc(GetProcessHeap(), 0, snd_pcm_hw_params_sizeof());
4215 if (!params) {
4216 WARN("Out of memory.\n");
4217 snd_pcm_close(handle);
4218 return 0;
4219 }
4220
4221 if ((err = snd_pcm_hw_params_any(handle, params)) < 0) {
4222 WARN("snd_pcm_hw_params_any failed for \"%s\": %d (%s).\n",
4223 name, err, snd_strerror(err));
4224 goto exit;
4225 }
4226
4227 if ((err = snd_pcm_hw_params_get_channels_max(params,
4228 &max_channels)) < 0){
4229 WARN("Unable to get max channels: %d (%s)\n", err, snd_strerror(err));
4230 goto exit;
4231 }
4232
4233 exit:
4234 HeapFree(GetProcessHeap(), 0, params);
4235 snd_pcm_close(handle);
4236
4237 return max_channels;
4238 }
4239
4240 enum AudioDeviceConnectionType {
4241 AudioDeviceConnectionType_Unknown = 0,
4242 AudioDeviceConnectionType_PCI,
4243 AudioDeviceConnectionType_USB
4244 };
4245
4246 HRESULT WINAPI AUDDRV_GetPropValue(GUID *guid, const PROPERTYKEY *prop, PROPVARIANT *out)
4247 {
4248 char name[256];
4249 EDataFlow flow;
4250
4251 static const PROPERTYKEY devicepath_key = { /* undocumented? - {b3f8fa53-0004-438e-9003-51a46e139bfc},2 */
4252 {0xb3f8fa53, 0x0004, 0x438e, {0x90, 0x03, 0x51, 0xa4, 0x6e, 0x13, 0x9b, 0xfc}}, 2
4253 };
4254
4255 TRACE("%s, (%s,%u), %p\n", wine_dbgstr_guid(guid), wine_dbgstr_guid(&prop->fmtid), prop->pid, out);
4256
4257 if(!get_alsa_name_by_guid(guid, name, sizeof(name), &flow))
4258 {
4259 WARN("Unknown interface %s\n", debugstr_guid(guid));
4260 return E_NOINTERFACE;
4261 }
4262
4263 if(IsEqualPropertyKey(*prop, devicepath_key))
4264 {
4265 char uevent[MAX_PATH];
4266 FILE *fuevent;
4267 int card, device;
4268
4269 /* only implemented for identifiable devices, i.e. not "default" */
4270 if(!sscanf(name, "plughw:%u,%u", &card, &device))
4271 return E_NOTIMPL;
4272
4273 sprintf(uevent, "/sys/class/sound/card%u/device/uevent", card);
4274 fuevent = fopen(uevent, "r");
4275
4276 if(fuevent){
4277 enum AudioDeviceConnectionType connection = AudioDeviceConnectionType_Unknown;
4278 USHORT vendor_id = 0, product_id = 0;
4279 char line[256];
4280
4281 while (fgets(line, sizeof(line), fuevent)) {
4282 char *val;
4283 size_t val_len;
4284
4285 if((val = strchr(line, '='))) {
4286 val[0] = 0;
4287 val++;
4288
4289 val_len = strlen(val);
4290 if(val_len > 0 && val[val_len - 1] == '\n') { val[val_len - 1] = 0; }
4291
4292 if(!strcmp(line, "PCI_ID")){
4293 connection = AudioDeviceConnectionType_PCI;
4294 if(sscanf(val, "%hX:%hX", &vendor_id, &product_id)<2){
4295 WARN("Unexpected input when reading PCI_ID in uevent file.\n");
4296 connection = AudioDeviceConnectionType_Unknown;
4297 break;
4298 }
4299 }else if(!strcmp(line, "DEVTYPE") && !strcmp(val,"usb_interface"))
4300 connection = AudioDeviceConnectionType_USB;
4301 else if(!strcmp(line, "PRODUCT"))
4302 if(sscanf(val, "%hx/%hx/", &vendor_id, &product_id)<2){
4303 WARN("Unexpected input when reading PRODUCT in uevent file.\n");
4304 connection = AudioDeviceConnectionType_Unknown;
4305 break;
4306 }
4307 }
4308 }
4309
4310 fclose(fuevent);
4311
4312 if(connection == AudioDeviceConnectionType_USB || connection == AudioDeviceConnectionType_PCI){
4313 static const WCHAR usbformatW[] = { '{','1','}','.','U','S','B','\\','V','I','D','_',
4314 '%','0','4','X','&','P','I','D','_','%','0','4','X','\\',
4315 '%','u','&','%','0','8','X',0 }; /* "{1}.USB\VID_%04X&PID_%04X\%u&%08X" */
4316 static const WCHAR pciformatW[] = { '{','1','}','.','H','D','A','U','D','I','O','\\','F','U','N','C','_','0','1','&',
4317 'V','E','N','_','%','0','4','X','&','D','E','V','_',
4318 '%','0','4','X','\\','%','u','&','%','0','8','X',0 }; /* "{1}.HDAUDIO\FUNC_01&VEN_%04X&DEV_%04X\%u&%08X" */
4319 UINT serial_number;
4320
4321 /* As hardly any audio devices have serial numbers, Windows instead
4322 appears to use a persistent random number. We emulate this here
4323 by instead using the last 8 hex digits of the GUID. */
4324 serial_number = (guid->Data4[4] << 24) | (guid->Data4[5] << 16) | (guid->Data4[6] << 8) | guid->Data4[7];
4325
4326 out->vt = VT_LPWSTR;
4327 out->pwszVal = CoTaskMemAlloc(128 * sizeof(WCHAR));
4328
4329 if(!out->pwszVal)
4330 return E_OUTOFMEMORY;
4331
4332 if(connection == AudioDeviceConnectionType_USB)
4333 sprintfW( out->pwszVal, usbformatW, vendor_id, product_id, device, serial_number);
4334 else if(connection == AudioDeviceConnectionType_PCI)
4335 sprintfW( out->pwszVal, pciformatW, vendor_id, product_id, device, serial_number);
4336
4337 return S_OK;
4338 }
4339 }else{
4340 WARN("Could not open %s for reading\n", uevent);
4341 return E_NOTIMPL;
4342 }
4343 } else if (flow != eCapture && IsEqualPropertyKey(*prop, PKEY_AudioEndpoint_PhysicalSpeakers)) {
4344 unsigned int num_speakers, card, device;
4345 char hwname[255];
4346
4347 if (sscanf(name, "plughw:%u,%u", &card, &device))
4348 sprintf(hwname, "hw:%u,%u", card, device); /* must be hw rather than plughw to work */
4349 else
4350 strcpy(hwname, name);
4351
4352 num_speakers = alsa_probe_num_speakers(hwname);
4353 if (num_speakers == 0)
4354 return E_FAIL;
4355
4356 out->vt = VT_UI4;
4357
4358 if (num_speakers > 6)
4359 out->ulVal = KSAUDIO_SPEAKER_STEREO;
4360 else if (num_speakers == 6)
4361 out->ulVal = KSAUDIO_SPEAKER_5POINT1;
4362 else if (num_speakers >= 4)
4363 out->ulVal = KSAUDIO_SPEAKER_QUAD;
4364 else if (num_speakers >= 2)
4365 out->ulVal = KSAUDIO_SPEAKER_STEREO;
4366 else if (num_speakers == 1)
4367 out->ulVal = KSAUDIO_SPEAKER_MONO;
4368
4369 return S_OK;
4370 }
4371
4372 TRACE("Unimplemented property %s,%u\n", wine_dbgstr_guid(&prop->fmtid), prop->pid);
4373
4374 return E_NOTIMPL;
4375 }
Windows API implementation