2 * Copyright 2011 Andrew Eikum for CodeWeavers
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 #define NONAMELESSUNION
29 #include "wine/debug.h"
30 #include "wine/unicode.h"
31 #include "wine/list.h"
34 #include "mmdeviceapi.h"
40 #include "endpointvolume.h"
41 #include "audioclient.h"
42 #include "audiopolicy.h"
49 #include <sys/types.h>
51 #include <sys/ioctl.h>
55 #include <libkern/OSAtomic.h>
56 #include <CoreAudio/CoreAudio.h>
57 #include <AudioToolbox/AudioQueue.h>
58 #include <AudioToolbox/AudioFormat.h>
60 WINE_DEFAULT_DEBUG_CHANNEL(coreaudio
);
62 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
64 static const REFERENCE_TIME DefaultPeriod
= 200000;
65 static const REFERENCE_TIME MinimumPeriod
= 100000;
67 typedef struct _QueuedBufInfo
{
68 Float64 start_sampletime
;
74 typedef struct _AQBuffer
{
75 AudioQueueBufferRef buf
;
81 typedef struct ACImpl ACImpl
;
83 typedef struct _AudioSession
{
94 CRITICAL_SECTION lock
;
99 typedef struct _AudioSessionWrapper
{
100 IAudioSessionControl2 IAudioSessionControl2_iface
;
101 IChannelAudioVolume IChannelAudioVolume_iface
;
102 ISimpleAudioVolume ISimpleAudioVolume_iface
;
107 AudioSession
*session
;
108 } AudioSessionWrapper
;
111 IAudioClient IAudioClient_iface
;
112 IAudioRenderClient IAudioRenderClient_iface
;
113 IAudioCaptureClient IAudioCaptureClient_iface
;
114 IAudioClock IAudioClock_iface
;
115 IAudioClock2 IAudioClock2_iface
;
116 IAudioStreamVolume IAudioStreamVolume_iface
;
121 IUnknown
*pUnkFTMarshal
;
127 AUDCLNT_SHAREMODE share
;
131 AudioDeviceID adevid
;
132 AudioQueueRef aqueue
;
133 AudioObjectPropertyScope scope
;
135 UINT32 period_ms
, bufsize_frames
, inbuf_frames
, read_offs_bytes
, period_frames
;
136 UINT64 last_time
, written_frames
;
137 AudioQueueBufferRef public_buffer
;
140 BYTE
*tmp_buffer
, *capture_buf
;
142 Float64 highest_sampletime
, next_sampletime
;
144 AudioSession
*session
;
145 AudioSessionWrapper
*session_wrapper
;
149 struct list avail_buffers
;
150 struct list queued_buffers
; /* either in avail, queued or public_buffer */
151 struct list queued_bufinfos
;
162 static const IAudioClientVtbl AudioClient_Vtbl
;
163 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl
;
164 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl
;
165 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl
;
166 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl
;
167 static const IAudioClockVtbl AudioClock_Vtbl
;
168 static const IAudioClock2Vtbl AudioClock2_Vtbl
;
169 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl
;
170 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl
;
171 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl
;
173 typedef struct _SessionMgr
{
174 IAudioSessionManager2 IAudioSessionManager2_iface
;
181 static const WCHAR drv_keyW
[] = {'S','o','f','t','w','a','r','e','\\',
182 'W','i','n','e','\\','D','r','i','v','e','r','s','\\',
183 'w','i','n','e','c','o','r','e','a','u','d','i','o','.','d','r','v',0};
184 static const WCHAR drv_key_devicesW
[] = {'S','o','f','t','w','a','r','e','\\',
185 'W','i','n','e','\\','D','r','i','v','e','r','s','\\',
186 'w','i','n','e','c','o','r','e','a','u','d','i','o','.','d','r','v','\\','d','e','v','i','c','e','s',0};
187 static const WCHAR guidW
[] = {'g','u','i','d',0};
189 static HANDLE g_timer_q
;
191 static CRITICAL_SECTION g_sessions_lock
;
192 static CRITICAL_SECTION_DEBUG g_sessions_lock_debug
=
194 0, 0, &g_sessions_lock
,
195 { &g_sessions_lock_debug
.ProcessLocksList
, &g_sessions_lock_debug
.ProcessLocksList
},
196 0, 0, { (DWORD_PTR
)(__FILE__
": g_sessions_lock") }
198 static CRITICAL_SECTION g_sessions_lock
= { &g_sessions_lock_debug
, -1, 0, 0, 0, 0 };
199 static struct list g_sessions
= LIST_INIT(g_sessions
);
201 static AudioSessionWrapper
*AudioSessionWrapper_Create(ACImpl
*client
);
202 static HRESULT
ca_setvol(ACImpl
*This
, UINT32 index
);
204 static inline ACImpl
*impl_from_IAudioClient(IAudioClient
*iface
)
206 return CONTAINING_RECORD(iface
, ACImpl
, IAudioClient_iface
);
209 static inline ACImpl
*impl_from_IAudioRenderClient(IAudioRenderClient
*iface
)
211 return CONTAINING_RECORD(iface
, ACImpl
, IAudioRenderClient_iface
);
214 static inline ACImpl
*impl_from_IAudioCaptureClient(IAudioCaptureClient
*iface
)
216 return CONTAINING_RECORD(iface
, ACImpl
, IAudioCaptureClient_iface
);
219 static inline AudioSessionWrapper
*impl_from_IAudioSessionControl2(IAudioSessionControl2
*iface
)
221 return CONTAINING_RECORD(iface
, AudioSessionWrapper
, IAudioSessionControl2_iface
);
224 static inline AudioSessionWrapper
*impl_from_ISimpleAudioVolume(ISimpleAudioVolume
*iface
)
226 return CONTAINING_RECORD(iface
, AudioSessionWrapper
, ISimpleAudioVolume_iface
);
229 static inline AudioSessionWrapper
*impl_from_IChannelAudioVolume(IChannelAudioVolume
*iface
)
231 return CONTAINING_RECORD(iface
, AudioSessionWrapper
, IChannelAudioVolume_iface
);
234 static inline ACImpl
*impl_from_IAudioClock(IAudioClock
*iface
)
236 return CONTAINING_RECORD(iface
, ACImpl
, IAudioClock_iface
);
239 static inline ACImpl
*impl_from_IAudioClock2(IAudioClock2
*iface
)
241 return CONTAINING_RECORD(iface
, ACImpl
, IAudioClock2_iface
);
244 static inline ACImpl
*impl_from_IAudioStreamVolume(IAudioStreamVolume
*iface
)
246 return CONTAINING_RECORD(iface
, ACImpl
, IAudioStreamVolume_iface
);
249 static inline SessionMgr
*impl_from_IAudioSessionManager2(IAudioSessionManager2
*iface
)
251 return CONTAINING_RECORD(iface
, SessionMgr
, IAudioSessionManager2_iface
);
254 BOOL WINAPI
DllMain(HINSTANCE dll
, DWORD reason
, void *reserved
)
258 case DLL_PROCESS_ATTACH
:
259 g_timer_q
= CreateTimerQueue();
264 case DLL_PROCESS_DETACH
:
266 DeleteCriticalSection(&g_sessions_lock
);
272 /* From <dlls/mmdevapi/mmdevapi.h> */
273 enum DriverPriority
{
274 Priority_Unavailable
= 0,
280 int WINAPI
AUDDRV_GetPriority(void)
282 return Priority_Neutral
;
285 static HRESULT
osstatus_to_hresult(OSStatus sc
)
288 case kAudioFormatUnsupportedDataFormatError
:
289 case kAudioFormatUnknownFormatError
:
290 case kAudioDeviceUnsupportedFormatError
:
291 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
292 case kAudioHardwareBadDeviceError
:
293 return AUDCLNT_E_DEVICE_INVALIDATED
;
298 static void set_device_guid(EDataFlow flow
, HKEY drv_key
, const WCHAR
*key_name
,
306 lr
= RegCreateKeyExW(HKEY_CURRENT_USER
, drv_key_devicesW
, 0, NULL
, 0, KEY_WRITE
,
307 NULL
, &drv_key
, NULL
);
308 if(lr
!= ERROR_SUCCESS
){
309 ERR("RegCreateKeyEx(drv_key) failed: %u\n", lr
);
315 lr
= RegCreateKeyExW(drv_key
, key_name
, 0, NULL
, 0, KEY_WRITE
,
317 if(lr
!= ERROR_SUCCESS
){
318 ERR("RegCreateKeyEx(%s) failed: %u\n", wine_dbgstr_w(key_name
), lr
);
322 lr
= RegSetValueExW(key
, guidW
, 0, REG_BINARY
, (BYTE
*)guid
,
324 if(lr
!= ERROR_SUCCESS
)
325 ERR("RegSetValueEx(%s\\guid) failed: %u\n", wine_dbgstr_w(key_name
), lr
);
330 RegCloseKey(drv_key
);
333 static void get_device_guid(EDataFlow flow
, AudioDeviceID device
, GUID
*guid
)
335 HKEY key
= NULL
, dev_key
;
336 DWORD type
, size
= sizeof(*guid
);
339 static const WCHAR key_fmt
[] = {'%','u',0};
347 sprintfW(key_name
+ 2, key_fmt
, device
);
349 if(RegOpenKeyExW(HKEY_CURRENT_USER
, drv_key_devicesW
, 0, KEY_WRITE
|KEY_READ
, &key
) == ERROR_SUCCESS
){
350 if(RegOpenKeyExW(key
, key_name
, 0, KEY_READ
, &dev_key
) == ERROR_SUCCESS
){
351 if(RegQueryValueExW(dev_key
, guidW
, 0, &type
,
352 (BYTE
*)guid
, &size
) == ERROR_SUCCESS
){
353 if(type
== REG_BINARY
){
354 RegCloseKey(dev_key
);
358 ERR("Invalid type for device %s GUID: %u; ignoring and overwriting\n",
359 wine_dbgstr_w(key_name
), type
);
361 RegCloseKey(dev_key
);
367 set_device_guid(flow
, key
, key_name
, guid
);
373 HRESULT WINAPI
AUDDRV_GetEndpointIDs(EDataFlow flow
, WCHAR
***ids
,
374 GUID
**guids
, UINT
*num
, UINT
*def_index
)
376 UInt32 devsize
, size
;
377 AudioDeviceID
*devices
;
378 AudioDeviceID default_id
;
379 AudioObjectPropertyAddress addr
;
383 TRACE("%d %p %p %p\n", flow
, ids
, num
, def_index
);
385 addr
.mScope
= kAudioObjectPropertyScopeGlobal
;
386 addr
.mElement
= kAudioObjectPropertyElementMaster
;
388 addr
.mSelector
= kAudioHardwarePropertyDefaultOutputDevice
;
389 else if(flow
== eCapture
)
390 addr
.mSelector
= kAudioHardwarePropertyDefaultInputDevice
;
394 size
= sizeof(default_id
);
395 sc
= AudioObjectGetPropertyData(kAudioObjectSystemObject
, &addr
, 0,
396 NULL
, &size
, &default_id
);
398 WARN("Getting _DefaultInputDevice property failed: %lx\n", sc
);
402 addr
.mSelector
= kAudioHardwarePropertyDevices
;
403 sc
= AudioObjectGetPropertyDataSize(kAudioObjectSystemObject
, &addr
, 0,
406 WARN("Getting _Devices property size failed: %lx\n", sc
);
407 return osstatus_to_hresult(sc
);
410 devices
= HeapAlloc(GetProcessHeap(), 0, devsize
);
412 return E_OUTOFMEMORY
;
414 sc
= AudioObjectGetPropertyData(kAudioObjectSystemObject
, &addr
, 0, NULL
,
417 WARN("Getting _Devices property failed: %lx\n", sc
);
418 HeapFree(GetProcessHeap(), 0, devices
);
419 return osstatus_to_hresult(sc
);
422 ndevices
= devsize
/ sizeof(AudioDeviceID
);
424 *ids
= HeapAlloc(GetProcessHeap(), 0, ndevices
* sizeof(WCHAR
*));
426 HeapFree(GetProcessHeap(), 0, devices
);
427 return E_OUTOFMEMORY
;
430 *guids
= HeapAlloc(GetProcessHeap(), 0, ndevices
* sizeof(GUID
));
432 HeapFree(GetProcessHeap(), 0, *ids
);
433 HeapFree(GetProcessHeap(), 0, devices
);
434 return E_OUTOFMEMORY
;
438 *def_index
= (UINT
)-1;
439 for(i
= 0; i
< ndevices
; ++i
){
440 AudioBufferList
*buffers
;
445 addr
.mSelector
= kAudioDevicePropertyStreamConfiguration
;
447 addr
.mScope
= kAudioDevicePropertyScopeOutput
;
449 addr
.mScope
= kAudioDevicePropertyScopeInput
;
451 sc
= AudioObjectGetPropertyDataSize(devices
[i
], &addr
, 0, NULL
, &size
);
453 WARN("Unable to get _StreamConfiguration property size for "
454 "device %lu: %lx\n", devices
[i
], sc
);
458 buffers
= HeapAlloc(GetProcessHeap(), 0, size
);
460 HeapFree(GetProcessHeap(), 0, devices
);
461 for(j
= 0; j
< *num
; ++j
)
462 HeapFree(GetProcessHeap(), 0, (*ids
)[j
]);
463 HeapFree(GetProcessHeap(), 0, *guids
);
464 HeapFree(GetProcessHeap(), 0, *ids
);
465 return E_OUTOFMEMORY
;
468 sc
= AudioObjectGetPropertyData(devices
[i
], &addr
, 0, NULL
,
471 WARN("Unable to get _StreamConfiguration property for "
472 "device %lu: %lx\n", devices
[i
], sc
);
473 HeapFree(GetProcessHeap(), 0, buffers
);
477 /* check that there's at least one channel in this device before
478 * we claim it as usable */
479 for(j
= 0; j
< buffers
->mNumberBuffers
; ++j
)
480 if(buffers
->mBuffers
[j
].mNumberChannels
> 0)
482 if(j
>= buffers
->mNumberBuffers
){
483 HeapFree(GetProcessHeap(), 0, buffers
);
487 HeapFree(GetProcessHeap(), 0, buffers
);
490 addr
.mSelector
= kAudioObjectPropertyName
;
491 sc
= AudioObjectGetPropertyData(devices
[i
], &addr
, 0, NULL
,
494 WARN("Unable to get _Name property for device %lu: %lx\n",
499 len
= CFStringGetLength(name
) + 1;
500 (*ids
)[*num
] = HeapAlloc(GetProcessHeap(), 0, len
* sizeof(WCHAR
));
503 HeapFree(GetProcessHeap(), 0, devices
);
504 for(j
= 0; j
< *num
; ++j
)
505 HeapFree(GetProcessHeap(), 0, (*ids
)[j
]);
506 HeapFree(GetProcessHeap(), 0, *ids
);
507 HeapFree(GetProcessHeap(), 0, *guids
);
508 return E_OUTOFMEMORY
;
510 CFStringGetCharacters(name
, CFRangeMake(0, len
- 1), (UniChar
*)(*ids
)[*num
]);
511 ((*ids
)[*num
])[len
- 1] = 0;
514 get_device_guid(flow
, devices
[i
], &(*guids
)[*num
]);
516 if(*def_index
== (UINT
)-1 && devices
[i
] == default_id
)
519 TRACE("device %u: id %s key %u%s\n", *num
, debugstr_w((*ids
)[*num
]),
520 (unsigned int)devices
[i
], (*def_index
== *num
) ? " (default)" : "");
525 if(*def_index
== (UINT
)-1)
528 HeapFree(GetProcessHeap(), 0, devices
);
533 static BOOL
get_deviceid_by_guid(GUID
*guid
, AudioDeviceID
*id
, EDataFlow
*flow
)
540 if(RegOpenKeyExW(HKEY_CURRENT_USER
, drv_key_devicesW
, 0, KEY_READ
, &devices_key
) != ERROR_SUCCESS
){
541 ERR("No devices in registry?\n");
550 key_name_size
= sizeof(key_name
);
551 if(RegEnumKeyExW(devices_key
, i
, key_name
, &key_name_size
, NULL
,
552 NULL
, NULL
, NULL
) != ERROR_SUCCESS
)
555 if(RegOpenKeyExW(devices_key
, key_name
, 0, KEY_READ
, &key
) != ERROR_SUCCESS
){
556 WARN("Couldn't open key: %s\n", wine_dbgstr_w(key_name
));
560 size
= sizeof(reg_guid
);
561 if(RegQueryValueExW(key
, guidW
, 0, &type
,
562 (BYTE
*)®_guid
, &size
) == ERROR_SUCCESS
){
563 if(IsEqualGUID(®_guid
, guid
)){
565 RegCloseKey(devices_key
);
567 TRACE("Found matching device key: %s\n", wine_dbgstr_w(key_name
));
569 if(key_name
[0] == '0')
571 else if(key_name
[0] == '1')
574 ERR("Unknown device type: %c\n", key_name
[0]);
578 *id
= strtoulW(key_name
+ 2, NULL
, 10);
589 RegCloseKey(devices_key
);
591 WARN("No matching device in registry for GUID %s\n", debugstr_guid(guid
));
596 HRESULT WINAPI
AUDDRV_GetAudioEndpoint(GUID
*guid
, IMMDevice
*dev
, IAudioClient
**out
)
599 AudioDeviceID adevid
;
603 TRACE("%s %p %p\n", debugstr_guid(guid
), dev
, out
);
605 if(!get_deviceid_by_guid(guid
, &adevid
, &dataflow
))
606 return AUDCLNT_E_DEVICE_INVALIDATED
;
608 This
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(ACImpl
));
610 return E_OUTOFMEMORY
;
612 This
->IAudioClient_iface
.lpVtbl
= &AudioClient_Vtbl
;
613 This
->IAudioRenderClient_iface
.lpVtbl
= &AudioRenderClient_Vtbl
;
614 This
->IAudioCaptureClient_iface
.lpVtbl
= &AudioCaptureClient_Vtbl
;
615 This
->IAudioClock_iface
.lpVtbl
= &AudioClock_Vtbl
;
616 This
->IAudioClock2_iface
.lpVtbl
= &AudioClock2_Vtbl
;
617 This
->IAudioStreamVolume_iface
.lpVtbl
= &AudioStreamVolume_Vtbl
;
619 This
->dataflow
= dataflow
;
621 if(dataflow
== eRender
)
622 This
->scope
= kAudioDevicePropertyScopeOutput
;
623 else if(dataflow
== eCapture
)
624 This
->scope
= kAudioDevicePropertyScopeInput
;
626 HeapFree(GetProcessHeap(), 0, This
);
632 hr
= CoCreateFreeThreadedMarshaler((IUnknown
*)&This
->IAudioClient_iface
,
633 (IUnknown
**)&This
->pUnkFTMarshal
);
635 HeapFree(GetProcessHeap(), 0, This
);
640 IMMDevice_AddRef(This
->parent
);
642 list_init(&This
->avail_buffers
);
643 list_init(&This
->queued_buffers
);
644 list_init(&This
->queued_bufinfos
);
646 This
->adevid
= adevid
;
648 *out
= &This
->IAudioClient_iface
;
649 IAudioClient_AddRef(&This
->IAudioClient_iface
);
654 /* current position from start of stream */
655 #define BUFPOS_ABSOLUTE 1
656 /* current position from start of this buffer */
657 #define BUFPOS_RELATIVE 2
659 static UINT64
get_current_aqbuffer_position(ACImpl
*This
, int mode
)
662 QueuedBufInfo
*bufinfo
;
665 head
= list_head(&This
->queued_bufinfos
);
667 TRACE("No buffers queued\n");
668 if(mode
== BUFPOS_ABSOLUTE
)
669 return This
->written_frames
;
672 bufinfo
= LIST_ENTRY(head
, QueuedBufInfo
, entry
);
674 if(This
->playing
== StatePlaying
){
675 AudioTimeStamp tstamp
;
678 /* AudioQueueGetCurrentTime() is brain damaged. The returned
679 * mSampleTime member jumps backwards seemingly at random, so
680 * we record the highest sampletime and use that during these
683 * It also behaves poorly when the queue is paused, jumping
684 * forwards during the pause and backwards again after resuming.
685 * So we record the sampletime when the queue is paused and use
687 sc
= AudioQueueGetCurrentTime(This
->aqueue
, NULL
, &tstamp
, NULL
);
689 if(sc
!= kAudioQueueErr_InvalidRunState
)
690 WARN("Unable to get current time: %lx\n", sc
);
691 if(mode
== BUFPOS_ABSOLUTE
)
692 return This
->highest_sampletime
;
696 if(!(tstamp
.mFlags
& kAudioTimeStampSampleTimeValid
)){
697 FIXME("SampleTime not valid: %lx\n", tstamp
.mFlags
);
701 if(tstamp
.mSampleTime
> This
->highest_sampletime
)
702 This
->highest_sampletime
= tstamp
.mSampleTime
;
705 while(This
->highest_sampletime
> bufinfo
->start_sampletime
+ bufinfo
->len_frames
){
706 This
->inbuf_frames
-= bufinfo
->len_frames
;
707 list_remove(&bufinfo
->entry
);
708 HeapFree(GetProcessHeap(), 0, bufinfo
);
710 head
= list_head(&This
->queued_bufinfos
);
712 TRACE("No buffers queued\n");
713 if(mode
== BUFPOS_ABSOLUTE
)
714 return This
->written_frames
;
717 bufinfo
= LIST_ENTRY(head
, QueuedBufInfo
, entry
);
720 if(This
->highest_sampletime
< bufinfo
->start_sampletime
)
723 ret
= This
->highest_sampletime
- bufinfo
->start_sampletime
;
725 if(mode
== BUFPOS_ABSOLUTE
){
726 ret
= This
->written_frames
- (bufinfo
->len_frames
- ret
);
727 while((head
= list_next(&This
->queued_bufinfos
, &bufinfo
->entry
))){
728 bufinfo
= LIST_ENTRY(head
, QueuedBufInfo
, entry
);
729 ret
-= bufinfo
->len_frames
;
733 TRACE("%llu frames (%s)\n", ret
,
734 mode
== BUFPOS_ABSOLUTE
? "absolute" : "relative");
739 static void avail_update(ACImpl
*This
)
741 AQBuffer
*buf
, *next
;
744 if(This
->dataflow
== eCapture
){
745 DWORD bufsize_bytes
= This
->bufsize_frames
* This
->fmt
->nBlockAlign
;
746 DWORD inbuf_bytes
= This
->inbuf_frames
* This
->fmt
->nBlockAlign
;
748 LIST_FOR_EACH_ENTRY_SAFE(buf
, next
, &This
->queued_buffers
, AQBuffer
, entry
){
749 DWORD buffer_bytes
= buf
->buf
->mAudioDataByteSize
, to_copy_bytes
;
754 to_copy_bytes
= bufsize_bytes
- (This
->read_offs_bytes
+ inbuf_bytes
) % bufsize_bytes
;
756 if(buffer_bytes
<= to_copy_bytes
){
757 memcpy(This
->capture_buf
+ (This
->read_offs_bytes
+ inbuf_bytes
) % bufsize_bytes
,
758 buf
->buf
->mAudioData
, buffer_bytes
);
760 memcpy(This
->capture_buf
+ (This
->read_offs_bytes
+ inbuf_bytes
) % bufsize_bytes
,
761 buf
->buf
->mAudioData
, to_copy_bytes
);
762 memcpy(This
->capture_buf
, ((char *)buf
->buf
->mAudioData
) + to_copy_bytes
,
763 buffer_bytes
- to_copy_bytes
);
766 if(inbuf_bytes
+ buffer_bytes
> bufsize_bytes
){
767 This
->read_offs_bytes
+= inbuf_bytes
+ buffer_bytes
;
768 This
->read_offs_bytes
%= bufsize_bytes
;
769 inbuf_bytes
= bufsize_bytes
;
771 inbuf_bytes
+= buffer_bytes
;
774 list_remove(&buf
->entry
);
775 list_add_tail(&This
->queued_buffers
, &buf
->entry
);
776 sc
= AudioQueueEnqueueBuffer(This
->aqueue
, buf
->buf
, 0, NULL
);
778 WARN("EnqueueBuffer gave: %lx\n", sc
);
781 This
->inbuf_frames
= inbuf_bytes
/ This
->fmt
->nBlockAlign
;
783 LIST_FOR_EACH_ENTRY_SAFE(buf
, next
, &This
->queued_buffers
, AQBuffer
, entry
){
786 list_remove(&buf
->entry
);
787 list_add_tail(&This
->avail_buffers
, &buf
->entry
);
792 static HRESULT WINAPI
AudioClient_QueryInterface(IAudioClient
*iface
,
793 REFIID riid
, void **ppv
)
795 ACImpl
*This
= impl_from_IAudioClient(iface
);
796 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
801 if(IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IAudioClient
))
803 else if(IsEqualIID(riid
, &IID_IMarshal
))
804 return IUnknown_QueryInterface(This
->pUnkFTMarshal
, riid
, ppv
);
807 IUnknown_AddRef((IUnknown
*)*ppv
);
810 WARN("Unknown interface %s\n", debugstr_guid(riid
));
811 return E_NOINTERFACE
;
814 static ULONG WINAPI
AudioClient_AddRef(IAudioClient
*iface
)
816 ACImpl
*This
= impl_from_IAudioClient(iface
);
818 ref
= InterlockedIncrement(&This
->ref
);
819 TRACE("(%p) Refcount now %u\n", This
, ref
);
823 static ULONG WINAPI
AudioClient_Release(IAudioClient
*iface
)
825 ACImpl
*This
= impl_from_IAudioClient(iface
);
827 ref
= InterlockedDecrement(&This
->ref
);
828 TRACE("(%p) Refcount now %u\n", This
, ref
);
831 AQBuffer
*buf
, *next
;
832 QueuedBufInfo
*bufinfo
, *bufinfo2
;
834 if(This
->public_buffer
){
835 buf
= This
->public_buffer
->mUserData
;
836 list_add_tail(&This
->avail_buffers
, &buf
->entry
);
839 IAudioClient_Stop(iface
);
840 AudioQueueStop(This
->aqueue
, 1);
842 /* Stopped synchronously, all buffers returned. */
843 list_move_tail(&This
->avail_buffers
, &This
->queued_buffers
);
844 LIST_FOR_EACH_ENTRY_SAFE(buf
, next
, &This
->avail_buffers
, AQBuffer
, entry
){
845 AudioQueueFreeBuffer(This
->aqueue
, buf
->buf
);
846 HeapFree(GetProcessHeap(), 0, buf
);
849 LIST_FOR_EACH_ENTRY_SAFE(bufinfo
, bufinfo2
, &This
->queued_bufinfos
,
850 QueuedBufInfo
, entry
)
851 HeapFree(GetProcessHeap(), 0, bufinfo
);
853 AudioQueueDispose(This
->aqueue
, 1);
856 EnterCriticalSection(&g_sessions_lock
);
857 list_remove(&This
->entry
);
858 LeaveCriticalSection(&g_sessions_lock
);
860 HeapFree(GetProcessHeap(), 0, This
->vols
);
861 HeapFree(GetProcessHeap(), 0, This
->tmp_buffer
);
862 HeapFree(GetProcessHeap(), 0, This
->capture_buf
);
863 CoTaskMemFree(This
->fmt
);
864 IMMDevice_Release(This
->parent
);
865 IUnknown_Release(This
->pUnkFTMarshal
);
866 HeapFree(GetProcessHeap(), 0, This
);
871 static void dump_fmt(const WAVEFORMATEX
*fmt
)
873 TRACE("wFormatTag: 0x%x (", fmt
->wFormatTag
);
874 switch(fmt
->wFormatTag
){
875 case WAVE_FORMAT_PCM
:
876 TRACE("WAVE_FORMAT_PCM");
878 case WAVE_FORMAT_IEEE_FLOAT
:
879 TRACE("WAVE_FORMAT_IEEE_FLOAT");
881 case WAVE_FORMAT_EXTENSIBLE
:
882 TRACE("WAVE_FORMAT_EXTENSIBLE");
890 TRACE("nChannels: %u\n", fmt
->nChannels
);
891 TRACE("nSamplesPerSec: %u\n", fmt
->nSamplesPerSec
);
892 TRACE("nAvgBytesPerSec: %u\n", fmt
->nAvgBytesPerSec
);
893 TRACE("nBlockAlign: %u\n", fmt
->nBlockAlign
);
894 TRACE("wBitsPerSample: %u\n", fmt
->wBitsPerSample
);
895 TRACE("cbSize: %u\n", fmt
->cbSize
);
897 if(fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
){
898 WAVEFORMATEXTENSIBLE
*fmtex
= (void*)fmt
;
899 TRACE("dwChannelMask: %08x\n", fmtex
->dwChannelMask
);
900 TRACE("Samples: %04x\n", fmtex
->Samples
.wReserved
);
901 TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex
->SubFormat
));
905 static DWORD
get_channel_mask(unsigned int channels
)
911 return KSAUDIO_SPEAKER_MONO
;
913 return KSAUDIO_SPEAKER_STEREO
;
915 return KSAUDIO_SPEAKER_STEREO
| SPEAKER_LOW_FREQUENCY
;
917 return KSAUDIO_SPEAKER_QUAD
; /* not _SURROUND */
919 return KSAUDIO_SPEAKER_QUAD
| SPEAKER_LOW_FREQUENCY
;
921 return KSAUDIO_SPEAKER_5POINT1
; /* not 5POINT1_SURROUND */
923 return KSAUDIO_SPEAKER_5POINT1
| SPEAKER_BACK_CENTER
;
925 return KSAUDIO_SPEAKER_7POINT1_SURROUND
; /* Vista deprecates 7POINT1 */
927 FIXME("Unknown speaker configuration: %u\n", channels
);
931 static WAVEFORMATEX
*clone_format(const WAVEFORMATEX
*fmt
)
936 if(fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
)
937 size
= sizeof(WAVEFORMATEXTENSIBLE
);
939 size
= sizeof(WAVEFORMATEX
);
941 ret
= CoTaskMemAlloc(size
);
945 memcpy(ret
, fmt
, size
);
947 ret
->cbSize
= size
- sizeof(WAVEFORMATEX
);
952 static HRESULT
ca_get_audiodesc(AudioStreamBasicDescription
*desc
,
953 const WAVEFORMATEX
*fmt
)
955 const WAVEFORMATEXTENSIBLE
*fmtex
= (const WAVEFORMATEXTENSIBLE
*)fmt
;
957 desc
->mFormatFlags
= 0;
959 if(fmt
->wFormatTag
== WAVE_FORMAT_PCM
||
960 (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
961 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
))){
962 desc
->mFormatID
= kAudioFormatLinearPCM
;
963 if(fmt
->wBitsPerSample
> 8)
964 desc
->mFormatFlags
= kAudioFormatFlagIsSignedInteger
;
965 }else if(fmt
->wFormatTag
== WAVE_FORMAT_IEEE_FLOAT
||
966 (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
967 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
))){
968 desc
->mFormatID
= kAudioFormatLinearPCM
;
969 desc
->mFormatFlags
= kAudioFormatFlagIsFloat
;
970 }else if(fmt
->wFormatTag
== WAVE_FORMAT_MULAW
||
971 (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
972 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_MULAW
))){
973 desc
->mFormatID
= kAudioFormatULaw
;
974 }else if(fmt
->wFormatTag
== WAVE_FORMAT_ALAW
||
975 (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
976 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_ALAW
))){
977 desc
->mFormatID
= kAudioFormatALaw
;
979 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
981 desc
->mSampleRate
= fmt
->nSamplesPerSec
;
982 desc
->mBytesPerPacket
= fmt
->nBlockAlign
;
983 desc
->mFramesPerPacket
= 1;
984 desc
->mBytesPerFrame
= fmt
->nBlockAlign
;
985 desc
->mChannelsPerFrame
= fmt
->nChannels
;
986 desc
->mBitsPerChannel
= fmt
->wBitsPerSample
;
992 /* We can't use debug printing or {Enter,Leave}CriticalSection from
993 * OSX callback threads. We may use OSSpinLock.
994 * OSSpinLock is not a recursive lock, so don't call
995 * synchronized functions while holding the lock. */
996 static void ca_out_buffer_cb(void *user
, AudioQueueRef aqueue
,
997 AudioQueueBufferRef buffer
)
999 AQBuffer
*buf
= buffer
->mUserData
;
1004 static void ca_in_buffer_cb(void *user
, AudioQueueRef aqueue
,
1005 AudioQueueBufferRef buffer
, const AudioTimeStamp
*start
,
1006 UInt32 ndesc
, const AudioStreamPacketDescription
*descs
)
1008 AQBuffer
*buf
= buffer
->mUserData
;
1011 /* let's update inbuf_frames synchronously without OSAddAtomic */
1014 static HRESULT
ca_setup_aqueue(AudioDeviceID did
, EDataFlow flow
,
1015 const WAVEFORMATEX
*fmt
, void *user
, AudioQueueRef
*aqueue
)
1017 AudioStreamBasicDescription desc
;
1018 AudioObjectPropertyAddress addr
;
1024 addr
.mScope
= kAudioObjectPropertyScopeGlobal
;
1026 addr
.mSelector
= kAudioDevicePropertyDeviceUID
;
1029 sc
= AudioObjectGetPropertyData(did
, &addr
, 0, NULL
, &size
, &uid
);
1031 WARN("Unable to get _DeviceUID property: %lx\n", sc
);
1032 return osstatus_to_hresult(sc
);
1035 hr
= ca_get_audiodesc(&desc
, fmt
);
1042 sc
= AudioQueueNewOutput(&desc
, ca_out_buffer_cb
, user
, NULL
, NULL
, 0,
1044 else if(flow
== eCapture
)
1045 sc
= AudioQueueNewInput(&desc
, ca_in_buffer_cb
, user
, NULL
, NULL
, 0,
1049 return E_UNEXPECTED
;
1052 WARN("Unable to create AudioQueue: %lx\n", sc
);
1054 return osstatus_to_hresult(sc
);
1057 sc
= AudioQueueSetProperty(*aqueue
, kAudioQueueProperty_CurrentDevice
,
1060 WARN("Unable to change AQueue device: %lx\n", sc
);
1062 return osstatus_to_hresult(sc
);
1070 static void session_init_vols(AudioSession
*session
, UINT channels
)
1072 if(session
->channel_count
< channels
){
1075 if(session
->channel_vols
)
1076 session
->channel_vols
= HeapReAlloc(GetProcessHeap(), 0,
1077 session
->channel_vols
, sizeof(float) * channels
);
1079 session
->channel_vols
= HeapAlloc(GetProcessHeap(), 0,
1080 sizeof(float) * channels
);
1081 if(!session
->channel_vols
)
1084 for(i
= session
->channel_count
; i
< channels
; ++i
)
1085 session
->channel_vols
[i
] = 1.f
;
1087 session
->channel_count
= channels
;
1091 static AudioSession
*create_session(const GUID
*guid
, IMMDevice
*device
,
1096 ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(AudioSession
));
1100 memcpy(&ret
->guid
, guid
, sizeof(GUID
));
1102 ret
->device
= device
;
1104 list_init(&ret
->clients
);
1106 list_add_head(&g_sessions
, &ret
->entry
);
1108 InitializeCriticalSection(&ret
->lock
);
1109 ret
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": AudioSession.lock");
1111 session_init_vols(ret
, num_channels
);
1113 ret
->master_vol
= 1.f
;
1118 /* if channels == 0, then this will return or create a session with
1119 * matching dataflow and GUID. otherwise, channels must also match */
1120 static HRESULT
get_audio_session(const GUID
*sessionguid
,
1121 IMMDevice
*device
, UINT channels
, AudioSession
**out
)
1123 AudioSession
*session
;
1125 if(!sessionguid
|| IsEqualGUID(sessionguid
, &GUID_NULL
)){
1126 *out
= create_session(&GUID_NULL
, device
, channels
);
1128 return E_OUTOFMEMORY
;
1134 LIST_FOR_EACH_ENTRY(session
, &g_sessions
, AudioSession
, entry
){
1135 if(session
->device
== device
&&
1136 IsEqualGUID(sessionguid
, &session
->guid
)){
1137 session_init_vols(session
, channels
);
1144 *out
= create_session(sessionguid
, device
, channels
);
1146 return E_OUTOFMEMORY
;
1152 static HRESULT WINAPI
AudioClient_Initialize(IAudioClient
*iface
,
1153 AUDCLNT_SHAREMODE mode
, DWORD flags
, REFERENCE_TIME duration
,
1154 REFERENCE_TIME period
, const WAVEFORMATEX
*fmt
,
1155 const GUID
*sessionguid
)
1157 ACImpl
*This
= impl_from_IAudioClient(iface
);
1162 TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This
, mode
, flags
,
1163 wine_dbgstr_longlong(duration
), wine_dbgstr_longlong(period
), fmt
, debugstr_guid(sessionguid
));
1170 if(mode
!= AUDCLNT_SHAREMODE_SHARED
&& mode
!= AUDCLNT_SHAREMODE_EXCLUSIVE
)
1171 return AUDCLNT_E_NOT_INITIALIZED
;
1173 if(flags
& ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS
|
1174 AUDCLNT_STREAMFLAGS_LOOPBACK
|
1175 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
|
1176 AUDCLNT_STREAMFLAGS_NOPERSIST
|
1177 AUDCLNT_STREAMFLAGS_RATEADJUST
|
1178 AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED
|
1179 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE
|
1180 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED
)){
1181 TRACE("Unknown flags: %08x\n", flags
);
1182 return E_INVALIDARG
;
1185 if(mode
== AUDCLNT_SHAREMODE_SHARED
){
1186 period
= DefaultPeriod
;
1187 if( duration
< 3 * period
)
1188 duration
= 3 * period
;
1190 if(fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
){
1191 if(((WAVEFORMATEXTENSIBLE
*)fmt
)->dwChannelMask
== 0 ||
1192 ((WAVEFORMATEXTENSIBLE
*)fmt
)->dwChannelMask
& SPEAKER_RESERVED
)
1193 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1197 period
= DefaultPeriod
; /* not minimum */
1198 if(period
< MinimumPeriod
|| period
> 5000000)
1199 return AUDCLNT_E_INVALID_DEVICE_PERIOD
;
1200 if(duration
> 20000000) /* the smaller the period, the lower this limit */
1201 return AUDCLNT_E_BUFFER_SIZE_ERROR
;
1202 if(flags
& AUDCLNT_STREAMFLAGS_EVENTCALLBACK
){
1203 if(duration
!= period
)
1204 return AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL
;
1205 FIXME("EXCLUSIVE mode with EVENTCALLBACK\n");
1206 return AUDCLNT_E_DEVICE_IN_USE
;
1208 if( duration
< 8 * period
)
1209 duration
= 8 * period
; /* may grow above 2s */
1213 OSSpinLockLock(&This
->lock
);
1216 OSSpinLockUnlock(&This
->lock
);
1217 return AUDCLNT_E_ALREADY_INITIALIZED
;
1220 hr
= ca_setup_aqueue(This
->adevid
, This
->dataflow
, fmt
, This
, &This
->aqueue
);
1222 OSSpinLockUnlock(&This
->lock
);
1226 This
->fmt
= clone_format(fmt
);
1228 AudioQueueDispose(This
->aqueue
, 1);
1229 This
->aqueue
= NULL
;
1230 OSSpinLockUnlock(&This
->lock
);
1231 return E_OUTOFMEMORY
;
1234 This
->period_ms
= period
/ 10000;
1235 This
->period_frames
= MulDiv(period
, This
->fmt
->nSamplesPerSec
, 10000000);
1237 This
->bufsize_frames
= MulDiv(duration
, fmt
->nSamplesPerSec
, 10000000);
1239 if(This
->dataflow
== eCapture
){
1240 int i
, nbuffs
= (This
->bufsize_frames
/ This
->period_frames
) + 1;
1242 This
->capture_buf
= HeapAlloc(GetProcessHeap(), 0, This
->bufsize_frames
* This
->fmt
->nBlockAlign
);
1244 for(i
= 0; i
< nbuffs
; ++i
){
1247 buf
= HeapAlloc(GetProcessHeap(), 0, sizeof(AQBuffer
));
1249 HeapFree(GetProcessHeap(), 0, This
->capture_buf
);
1250 AudioQueueDispose(This
->aqueue
, 1);
1251 This
->aqueue
= NULL
;
1252 CoTaskMemFree(This
->fmt
);
1254 OSSpinLockUnlock(&This
->lock
);
1255 return E_OUTOFMEMORY
;
1258 sc
= AudioQueueAllocateBuffer(This
->aqueue
, This
->period_frames
* This
->fmt
->nBlockAlign
, &buf
->buf
);
1260 HeapFree(GetProcessHeap(), 0, This
->capture_buf
);
1261 AudioQueueDispose(This
->aqueue
, 1);
1262 This
->aqueue
= NULL
;
1263 CoTaskMemFree(This
->fmt
);
1265 OSSpinLockUnlock(&This
->lock
);
1266 WARN("Couldn't allocate buffer: %lx\n", sc
);
1267 return osstatus_to_hresult(sc
);
1270 buf
->buf
->mUserData
= buf
;
1272 sc
= AudioQueueEnqueueBuffer(This
->aqueue
, buf
->buf
, 0, NULL
);
1274 ERR("Couldn't enqueue buffer: %lx\n", sc
);
1277 list_add_tail(&This
->queued_buffers
, &buf
->entry
);
1281 This
->vols
= HeapAlloc(GetProcessHeap(), 0, fmt
->nChannels
* sizeof(float));
1283 HeapFree(GetProcessHeap(), 0, This
->capture_buf
);
1284 AudioQueueDispose(This
->aqueue
, 1);
1285 This
->aqueue
= NULL
;
1286 CoTaskMemFree(This
->fmt
);
1288 OSSpinLockUnlock(&This
->lock
);
1289 return E_OUTOFMEMORY
;
1292 for(i
= 0; i
< fmt
->nChannels
; ++i
)
1293 This
->vols
[i
] = 1.f
;
1296 This
->flags
= flags
;
1298 EnterCriticalSection(&g_sessions_lock
);
1300 hr
= get_audio_session(sessionguid
, This
->parent
, fmt
->nChannels
,
1303 LeaveCriticalSection(&g_sessions_lock
);
1304 AudioQueueDispose(This
->aqueue
, 1);
1305 This
->aqueue
= NULL
;
1306 CoTaskMemFree(This
->fmt
);
1308 HeapFree(GetProcessHeap(), 0, This
->capture_buf
);
1309 HeapFree(GetProcessHeap(), 0, This
->vols
);
1311 OSSpinLockUnlock(&This
->lock
);
1312 return E_INVALIDARG
;
1315 list_add_tail(&This
->session
->clients
, &This
->entry
);
1317 LeaveCriticalSection(&g_sessions_lock
);
1319 ca_setvol(This
, -1);
1321 OSSpinLockUnlock(&This
->lock
);
1326 static HRESULT WINAPI
AudioClient_GetBufferSize(IAudioClient
*iface
,
1329 ACImpl
*This
= impl_from_IAudioClient(iface
);
1331 TRACE("(%p)->(%p)\n", This
, frames
);
1336 OSSpinLockLock(&This
->lock
);
1339 OSSpinLockUnlock(&This
->lock
);
1340 return AUDCLNT_E_NOT_INITIALIZED
;
1343 *frames
= This
->bufsize_frames
;
1345 OSSpinLockUnlock(&This
->lock
);
1350 static HRESULT
ca_get_max_stream_latency(ACImpl
*This
, UInt32
*max
)
1352 AudioObjectPropertyAddress addr
;
1358 addr
.mScope
= This
->scope
;
1360 addr
.mSelector
= kAudioDevicePropertyStreams
;
1362 sc
= AudioObjectGetPropertyDataSize(This
->adevid
, &addr
, 0, NULL
,
1365 WARN("Unable to get size for _Streams property: %lx\n", sc
);
1366 return osstatus_to_hresult(sc
);
1369 ids
= HeapAlloc(GetProcessHeap(), 0, size
);
1371 return E_OUTOFMEMORY
;
1373 sc
= AudioObjectGetPropertyData(This
->adevid
, &addr
, 0, NULL
, &size
, ids
);
1375 WARN("Unable to get _Streams property: %lx\n", sc
);
1376 HeapFree(GetProcessHeap(), 0, ids
);
1377 return osstatus_to_hresult(sc
);
1380 nstreams
= size
/ sizeof(AudioStreamID
);
1383 addr
.mSelector
= kAudioStreamPropertyLatency
;
1384 for(i
= 0; i
< nstreams
; ++i
){
1387 size
= sizeof(latency
);
1388 sc
= AudioObjectGetPropertyData(ids
[i
], &addr
, 0, NULL
,
1391 WARN("Unable to get _Latency property: %lx\n", sc
);
1399 HeapFree(GetProcessHeap(), 0, ids
);
1404 static HRESULT WINAPI
AudioClient_GetStreamLatency(IAudioClient
*iface
,
1405 REFERENCE_TIME
*out
)
1407 ACImpl
*This
= impl_from_IAudioClient(iface
);
1408 UInt32 latency
, stream_latency
, size
;
1409 AudioObjectPropertyAddress addr
;
1413 TRACE("(%p)->(%p)\n", This
, out
);
1418 OSSpinLockLock(&This
->lock
);
1421 OSSpinLockUnlock(&This
->lock
);
1422 return AUDCLNT_E_NOT_INITIALIZED
;
1425 addr
.mScope
= This
->scope
;
1426 addr
.mSelector
= kAudioDevicePropertyLatency
;
1429 size
= sizeof(latency
);
1430 sc
= AudioObjectGetPropertyData(This
->adevid
, &addr
, 0, NULL
,
1433 WARN("Couldn't get _Latency property: %lx\n", sc
);
1434 OSSpinLockUnlock(&This
->lock
);
1435 return osstatus_to_hresult(sc
);
1438 hr
= ca_get_max_stream_latency(This
, &stream_latency
);
1440 OSSpinLockUnlock(&This
->lock
);
1444 latency
+= stream_latency
;
1445 /* pretend we process audio in Period chunks, so max latency includes
1446 * the period time */
1447 *out
= MulDiv(latency
, 10000000, This
->fmt
->nSamplesPerSec
)
1448 + This
->period_ms
* 10000;
1450 OSSpinLockUnlock(&This
->lock
);
1455 static HRESULT
AudioClient_GetCurrentPadding_nolock(ACImpl
*This
,
1459 return AUDCLNT_E_NOT_INITIALIZED
;
1463 if(This
->dataflow
== eRender
){
1465 bufpos
= get_current_aqbuffer_position(This
, BUFPOS_RELATIVE
);
1466 *numpad
= This
->inbuf_frames
- bufpos
;
1468 *numpad
= This
->inbuf_frames
;
1469 if(*numpad
< This
->period_frames
)
1476 static HRESULT WINAPI
AudioClient_GetCurrentPadding(IAudioClient
*iface
,
1479 ACImpl
*This
= impl_from_IAudioClient(iface
);
1482 TRACE("(%p)->(%p)\n", This
, numpad
);
1487 OSSpinLockLock(&This
->lock
);
1489 hr
= AudioClient_GetCurrentPadding_nolock(This
, numpad
);
1491 OSSpinLockUnlock(&This
->lock
);
1496 static HRESULT WINAPI
AudioClient_IsFormatSupported(IAudioClient
*iface
,
1497 AUDCLNT_SHAREMODE mode
, const WAVEFORMATEX
*pwfx
,
1498 WAVEFORMATEX
**outpwfx
)
1500 ACImpl
*This
= impl_from_IAudioClient(iface
);
1501 WAVEFORMATEXTENSIBLE
*fmtex
= (WAVEFORMATEXTENSIBLE
*)pwfx
;
1502 AudioQueueRef aqueue
;
1505 TRACE("(%p)->(%x, %p, %p)\n", This
, mode
, pwfx
, outpwfx
);
1507 if(!pwfx
|| (mode
== AUDCLNT_SHAREMODE_SHARED
&& !outpwfx
))
1510 if(mode
!= AUDCLNT_SHAREMODE_SHARED
&& mode
!= AUDCLNT_SHAREMODE_EXCLUSIVE
)
1511 return E_INVALIDARG
;
1513 if(pwfx
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
1514 pwfx
->cbSize
< sizeof(WAVEFORMATEXTENSIBLE
) - sizeof(WAVEFORMATEX
))
1515 return E_INVALIDARG
;
1521 if(mode
!= AUDCLNT_SHAREMODE_SHARED
)
1525 if(pwfx
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
){
1526 if(pwfx
->nAvgBytesPerSec
== 0 ||
1527 pwfx
->nBlockAlign
== 0 ||
1528 fmtex
->Samples
.wValidBitsPerSample
> pwfx
->wBitsPerSample
)
1529 return E_INVALIDARG
;
1530 if(fmtex
->Samples
.wValidBitsPerSample
< pwfx
->wBitsPerSample
)
1532 if(mode
== AUDCLNT_SHAREMODE_EXCLUSIVE
){
1533 if(fmtex
->dwChannelMask
== 0 ||
1534 fmtex
->dwChannelMask
& SPEAKER_RESERVED
)
1539 if(pwfx
->nBlockAlign
!= pwfx
->nChannels
* pwfx
->wBitsPerSample
/ 8 ||
1540 pwfx
->nAvgBytesPerSec
!= pwfx
->nBlockAlign
* pwfx
->nSamplesPerSec
)
1543 if(pwfx
->nChannels
== 0)
1544 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1546 OSSpinLockLock(&This
->lock
);
1548 hr
= ca_setup_aqueue(This
->adevid
, This
->dataflow
, pwfx
, NULL
, &aqueue
);
1550 AudioQueueDispose(aqueue
, 1);
1551 OSSpinLockUnlock(&This
->lock
);
1552 TRACE("returning %08x\n", S_OK
);
1555 OSSpinLockUnlock(&This
->lock
);
1556 if(hr
!= AUDCLNT_E_UNSUPPORTED_FORMAT
){
1557 TRACE("returning %08x\n", hr
);
1563 hr
= IAudioClient_GetMixFormat(&This
->IAudioClient_iface
, outpwfx
);
1569 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1572 static HRESULT WINAPI
AudioClient_GetMixFormat(IAudioClient
*iface
,
1573 WAVEFORMATEX
**pwfx
)
1575 ACImpl
*This
= impl_from_IAudioClient(iface
);
1576 WAVEFORMATEXTENSIBLE
*fmt
;
1580 AudioBufferList
*buffers
;
1581 AudioObjectPropertyAddress addr
;
1584 TRACE("(%p)->(%p)\n", This
, pwfx
);
1590 fmt
= CoTaskMemAlloc(sizeof(WAVEFORMATEXTENSIBLE
));
1592 return E_OUTOFMEMORY
;
1594 fmt
->Format
.wFormatTag
= WAVE_FORMAT_EXTENSIBLE
;
1596 addr
.mScope
= This
->scope
;
1598 addr
.mSelector
= kAudioDevicePropertyStreamConfiguration
;
1600 sc
= AudioObjectGetPropertyDataSize(This
->adevid
, &addr
, 0, NULL
, &size
);
1603 WARN("Unable to get size for _StreamConfiguration property: %lx\n", sc
);
1604 return osstatus_to_hresult(sc
);
1607 buffers
= HeapAlloc(GetProcessHeap(), 0, size
);
1610 return E_OUTOFMEMORY
;
1613 sc
= AudioObjectGetPropertyData(This
->adevid
, &addr
, 0, NULL
,
1617 HeapFree(GetProcessHeap(), 0, buffers
);
1618 WARN("Unable to get _StreamConfiguration property: %lx\n", sc
);
1619 return osstatus_to_hresult(sc
);
1622 fmt
->Format
.nChannels
= 0;
1623 for(i
= 0; i
< buffers
->mNumberBuffers
; ++i
)
1624 fmt
->Format
.nChannels
+= buffers
->mBuffers
[i
].mNumberChannels
;
1626 HeapFree(GetProcessHeap(), 0, buffers
);
1628 fmt
->dwChannelMask
= get_channel_mask(fmt
->Format
.nChannels
);
1630 addr
.mSelector
= kAudioDevicePropertyNominalSampleRate
;
1631 size
= sizeof(Float64
);
1632 sc
= AudioObjectGetPropertyData(This
->adevid
, &addr
, 0, NULL
, &size
, &rate
);
1635 WARN("Unable to get _NominalSampleRate property: %lx\n", sc
);
1636 return osstatus_to_hresult(sc
);
1638 fmt
->Format
.nSamplesPerSec
= rate
;
1640 fmt
->Format
.wBitsPerSample
= 32;
1641 fmt
->SubFormat
= KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
;
1643 fmt
->Format
.nBlockAlign
= (fmt
->Format
.wBitsPerSample
*
1644 fmt
->Format
.nChannels
) / 8;
1645 fmt
->Format
.nAvgBytesPerSec
= fmt
->Format
.nSamplesPerSec
*
1646 fmt
->Format
.nBlockAlign
;
1648 fmt
->Samples
.wValidBitsPerSample
= fmt
->Format
.wBitsPerSample
;
1649 fmt
->Format
.cbSize
= sizeof(WAVEFORMATEXTENSIBLE
) - sizeof(WAVEFORMATEX
);
1651 *pwfx
= (WAVEFORMATEX
*)fmt
;
1657 static HRESULT WINAPI
AudioClient_GetDevicePeriod(IAudioClient
*iface
,
1658 REFERENCE_TIME
*defperiod
, REFERENCE_TIME
*minperiod
)
1660 ACImpl
*This
= impl_from_IAudioClient(iface
);
1662 TRACE("(%p)->(%p, %p)\n", This
, defperiod
, minperiod
);
1664 if(!defperiod
&& !minperiod
)
1668 *defperiod
= DefaultPeriod
;
1670 *minperiod
= MinimumPeriod
;
1675 void CALLBACK
ca_period_cb(void *user
, BOOLEAN timer
)
1677 ACImpl
*This
= user
;
1680 SetEvent(This
->event
);
1683 static HRESULT WINAPI
AudioClient_Start(IAudioClient
*iface
)
1685 ACImpl
*This
= impl_from_IAudioClient(iface
);
1688 TRACE("(%p)\n", This
);
1690 OSSpinLockLock(&This
->lock
);
1693 OSSpinLockUnlock(&This
->lock
);
1694 return AUDCLNT_E_NOT_INITIALIZED
;
1697 if(This
->playing
!= StateStopped
){
1698 OSSpinLockUnlock(&This
->lock
);
1699 return AUDCLNT_E_NOT_STOPPED
;
1702 if((This
->flags
& AUDCLNT_STREAMFLAGS_EVENTCALLBACK
) && !This
->event
){
1703 OSSpinLockUnlock(&This
->lock
);
1704 return AUDCLNT_E_EVENTHANDLE_NOT_SET
;
1708 if(!CreateTimerQueueTimer(&This
->timer
, g_timer_q
, ca_period_cb
,
1709 This
, 0, This
->period_ms
, WT_EXECUTEINTIMERTHREAD
)){
1711 OSSpinLockUnlock(&This
->lock
);
1712 WARN("Unable to create timer: %u\n", GetLastError());
1713 return E_OUTOFMEMORY
;
1716 /* enqueue buffers */
1719 This
->playing
= StateInTransition
;
1721 sc
= AudioQueueStart(This
->aqueue
, NULL
);
1723 OSSpinLockUnlock(&This
->lock
);
1724 WARN("Unable to start audio queue: %lx\n", sc
);
1725 return osstatus_to_hresult(sc
);
1728 This
->playing
= StatePlaying
;
1730 OSSpinLockUnlock(&This
->lock
);
1735 static HRESULT WINAPI
AudioClient_Stop(IAudioClient
*iface
)
1737 ACImpl
*This
= impl_from_IAudioClient(iface
);
1738 AudioTimeStamp tstamp
;
1740 HANDLE event
= NULL
;
1743 TRACE("(%p)\n", This
);
1745 OSSpinLockLock(&This
->lock
);
1748 OSSpinLockUnlock(&This
->lock
);
1749 return AUDCLNT_E_NOT_INITIALIZED
;
1752 if(This
->playing
== StateStopped
){
1753 OSSpinLockUnlock(&This
->lock
);
1757 if(This
->playing
== StateInTransition
){
1758 OSSpinLockUnlock(&This
->lock
);
1763 event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
1764 wait
= !DeleteTimerQueueTimer(g_timer_q
, This
->timer
, event
);
1767 WARN("DeleteTimerQueueTimer error %u\n", GetLastError());
1768 wait
= wait
&& GetLastError() == ERROR_IO_PENDING
;
1771 This
->playing
= StateInTransition
;
1773 sc
= AudioQueueGetCurrentTime(This
->aqueue
, NULL
, &tstamp
, NULL
);
1775 if(tstamp
.mFlags
& kAudioTimeStampSampleTimeValid
){
1776 if(tstamp
.mSampleTime
> This
->highest_sampletime
)
1777 This
->highest_sampletime
= tstamp
.mSampleTime
;
1779 WARN("Returned tstamp mSampleTime not valid: %lx\n", tstamp
.mFlags
);
1781 WARN("GetCurrentTime failed: %lx\n", sc
);
1783 /* Mac OS bug? Our capture callback is no more called past AQStop */
1784 sc
= AudioQueuePause(This
->aqueue
);
1786 OSSpinLockUnlock(&This
->lock
);
1787 WARN("Unable to pause audio queue: %lx\n", sc
);
1788 return osstatus_to_hresult(sc
);
1791 This
->playing
= StateStopped
;
1793 OSSpinLockUnlock(&This
->lock
);
1796 WaitForSingleObject(event
, INFINITE
);
1802 static HRESULT WINAPI
AudioClient_Reset(IAudioClient
*iface
)
1804 ACImpl
*This
= impl_from_IAudioClient(iface
);
1806 QueuedBufInfo
*bufinfo
, *bufinfo2
;
1808 TRACE("(%p)\n", This
);
1810 OSSpinLockLock(&This
->lock
);
1813 OSSpinLockUnlock(&This
->lock
);
1814 return AUDCLNT_E_NOT_INITIALIZED
;
1817 if(This
->playing
!= StateStopped
){
1818 OSSpinLockUnlock(&This
->lock
);
1819 return AUDCLNT_E_NOT_STOPPED
;
1822 if(This
->getbuf_last
){
1823 OSSpinLockUnlock(&This
->lock
);
1824 return AUDCLNT_E_BUFFER_OPERATION_PENDING
;
1827 avail_update(This
); /* going to skip over inbuf_frames */
1829 LIST_FOR_EACH_ENTRY_SAFE(bufinfo
, bufinfo2
, &This
->queued_bufinfos
,
1830 QueuedBufInfo
, entry
){
1831 list_remove(&bufinfo
->entry
);
1832 HeapFree(GetProcessHeap(), 0, bufinfo
);
1835 sc
= AudioQueueReset(This
->aqueue
);
1837 OSSpinLockUnlock(&This
->lock
);
1838 WARN("Unable to reset audio queue: %lx\n", sc
);
1839 return osstatus_to_hresult(sc
);
1842 if(This
->dataflow
== eRender
){
1843 This
->written_frames
= 0;
1845 This
->written_frames
+= This
->inbuf_frames
;
1847 This
->inbuf_frames
= 0;
1849 OSSpinLockUnlock(&This
->lock
);
1854 static HRESULT WINAPI
AudioClient_SetEventHandle(IAudioClient
*iface
,
1857 ACImpl
*This
= impl_from_IAudioClient(iface
);
1859 TRACE("(%p)->(%p)\n", This
, event
);
1862 return E_INVALIDARG
;
1864 OSSpinLockLock(&This
->lock
);
1867 OSSpinLockUnlock(&This
->lock
);
1868 return AUDCLNT_E_NOT_INITIALIZED
;
1871 if(!(This
->flags
& AUDCLNT_STREAMFLAGS_EVENTCALLBACK
)){
1872 OSSpinLockUnlock(&This
->lock
);
1873 return AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED
;
1877 OSSpinLockUnlock(&This
->lock
);
1878 FIXME("called twice\n");
1879 return HRESULT_FROM_WIN32(ERROR_INVALID_NAME
);
1882 This
->event
= event
;
1884 OSSpinLockUnlock(&This
->lock
);
1889 static HRESULT WINAPI
AudioClient_GetService(IAudioClient
*iface
, REFIID riid
,
1892 ACImpl
*This
= impl_from_IAudioClient(iface
);
1894 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), ppv
);
1900 OSSpinLockLock(&This
->lock
);
1903 OSSpinLockUnlock(&This
->lock
);
1904 return AUDCLNT_E_NOT_INITIALIZED
;
1907 if(IsEqualIID(riid
, &IID_IAudioRenderClient
)){
1908 if(This
->dataflow
!= eRender
){
1909 OSSpinLockUnlock(&This
->lock
);
1910 return AUDCLNT_E_WRONG_ENDPOINT_TYPE
;
1912 IAudioRenderClient_AddRef(&This
->IAudioRenderClient_iface
);
1913 *ppv
= &This
->IAudioRenderClient_iface
;
1914 }else if(IsEqualIID(riid
, &IID_IAudioCaptureClient
)){
1915 if(This
->dataflow
!= eCapture
){
1916 OSSpinLockUnlock(&This
->lock
);
1917 return AUDCLNT_E_WRONG_ENDPOINT_TYPE
;
1919 IAudioCaptureClient_AddRef(&This
->IAudioCaptureClient_iface
);
1920 *ppv
= &This
->IAudioCaptureClient_iface
;
1921 }else if(IsEqualIID(riid
, &IID_IAudioClock
)){
1922 IAudioClock_AddRef(&This
->IAudioClock_iface
);
1923 *ppv
= &This
->IAudioClock_iface
;
1924 }else if(IsEqualIID(riid
, &IID_IAudioStreamVolume
)){
1925 IAudioStreamVolume_AddRef(&This
->IAudioStreamVolume_iface
);
1926 *ppv
= &This
->IAudioStreamVolume_iface
;
1927 }else if(IsEqualIID(riid
, &IID_IAudioSessionControl
)){
1928 if(!This
->session_wrapper
){
1929 This
->session_wrapper
= AudioSessionWrapper_Create(This
);
1930 if(!This
->session_wrapper
){
1931 OSSpinLockUnlock(&This
->lock
);
1932 return E_OUTOFMEMORY
;
1935 IAudioSessionControl2_AddRef(&This
->session_wrapper
->IAudioSessionControl2_iface
);
1937 *ppv
= &This
->session_wrapper
->IAudioSessionControl2_iface
;
1938 }else if(IsEqualIID(riid
, &IID_IChannelAudioVolume
)){
1939 if(!This
->session_wrapper
){
1940 This
->session_wrapper
= AudioSessionWrapper_Create(This
);
1941 if(!This
->session_wrapper
){
1942 OSSpinLockUnlock(&This
->lock
);
1943 return E_OUTOFMEMORY
;
1946 IChannelAudioVolume_AddRef(&This
->session_wrapper
->IChannelAudioVolume_iface
);
1948 *ppv
= &This
->session_wrapper
->IChannelAudioVolume_iface
;
1949 }else if(IsEqualIID(riid
, &IID_ISimpleAudioVolume
)){
1950 if(!This
->session_wrapper
){
1951 This
->session_wrapper
= AudioSessionWrapper_Create(This
);
1952 if(!This
->session_wrapper
){
1953 OSSpinLockUnlock(&This
->lock
);
1954 return E_OUTOFMEMORY
;
1957 ISimpleAudioVolume_AddRef(&This
->session_wrapper
->ISimpleAudioVolume_iface
);
1959 *ppv
= &This
->session_wrapper
->ISimpleAudioVolume_iface
;
1963 OSSpinLockUnlock(&This
->lock
);
1967 OSSpinLockUnlock(&This
->lock
);
1969 FIXME("stub %s\n", debugstr_guid(riid
));
1970 return E_NOINTERFACE
;
1973 static const IAudioClientVtbl AudioClient_Vtbl
=
1975 AudioClient_QueryInterface
,
1977 AudioClient_Release
,
1978 AudioClient_Initialize
,
1979 AudioClient_GetBufferSize
,
1980 AudioClient_GetStreamLatency
,
1981 AudioClient_GetCurrentPadding
,
1982 AudioClient_IsFormatSupported
,
1983 AudioClient_GetMixFormat
,
1984 AudioClient_GetDevicePeriod
,
1988 AudioClient_SetEventHandle
,
1989 AudioClient_GetService
1992 static HRESULT WINAPI
AudioRenderClient_QueryInterface(
1993 IAudioRenderClient
*iface
, REFIID riid
, void **ppv
)
1995 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1996 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2002 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2003 IsEqualIID(riid
, &IID_IAudioRenderClient
))
2005 else if(IsEqualIID(riid
, &IID_IMarshal
))
2006 return IUnknown_QueryInterface(This
->pUnkFTMarshal
, riid
, ppv
);
2009 IUnknown_AddRef((IUnknown
*)*ppv
);
2013 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2014 return E_NOINTERFACE
;
2017 static ULONG WINAPI
AudioRenderClient_AddRef(IAudioRenderClient
*iface
)
2019 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
2020 return AudioClient_AddRef(&This
->IAudioClient_iface
);
2023 static ULONG WINAPI
AudioRenderClient_Release(IAudioRenderClient
*iface
)
2025 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
2026 return AudioClient_Release(&This
->IAudioClient_iface
);
2029 static void silence_buffer(ACImpl
*This
, BYTE
*buffer
, UINT32 frames
)
2031 WAVEFORMATEXTENSIBLE
*fmtex
= (WAVEFORMATEXTENSIBLE
*)This
->fmt
;
2032 if((This
->fmt
->wFormatTag
== WAVE_FORMAT_PCM
||
2033 (This
->fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
2034 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
))) &&
2035 This
->fmt
->wBitsPerSample
== 8)
2036 memset(buffer
, 128, frames
* This
->fmt
->nBlockAlign
);
2038 memset(buffer
, 0, frames
* This
->fmt
->nBlockAlign
);
2041 static HRESULT WINAPI
AudioRenderClient_GetBuffer(IAudioRenderClient
*iface
,
2042 UINT32 frames
, BYTE
**data
)
2044 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
2050 TRACE("(%p)->(%u, %p)\n", This
, frames
, data
);
2056 OSSpinLockLock(&This
->lock
);
2058 if(This
->getbuf_last
){
2059 OSSpinLockUnlock(&This
->lock
);
2060 return AUDCLNT_E_OUT_OF_ORDER
;
2064 OSSpinLockUnlock(&This
->lock
);
2068 hr
= AudioClient_GetCurrentPadding_nolock(This
, &pad
);
2070 OSSpinLockUnlock(&This
->lock
);
2074 if(pad
+ frames
> This
->bufsize_frames
){
2075 OSSpinLockUnlock(&This
->lock
);
2076 return AUDCLNT_E_BUFFER_TOO_LARGE
;
2079 bytes
= frames
* This
->fmt
->nBlockAlign
;
2080 LIST_FOR_EACH_ENTRY(buf
, &This
->avail_buffers
, AQBuffer
, entry
){
2081 if(buf
->buf
->mAudioDataBytesCapacity
>= bytes
){
2082 This
->public_buffer
= buf
->buf
;
2083 list_remove(&buf
->entry
);
2088 if(&buf
->entry
== &This
->avail_buffers
){
2089 sc
= AudioQueueAllocateBuffer(This
->aqueue
, bytes
,
2090 &This
->public_buffer
);
2092 This
->public_buffer
= NULL
;
2093 OSSpinLockUnlock(&This
->lock
);
2094 WARN("Unable to allocate buffer: %lx\n", sc
);
2095 return E_OUTOFMEMORY
;
2097 buf
= HeapAlloc(GetProcessHeap(), 0, sizeof(AQBuffer
));
2099 AudioQueueFreeBuffer(This
->aqueue
, This
->public_buffer
);
2100 This
->public_buffer
= NULL
;
2101 OSSpinLockUnlock(&This
->lock
);
2102 return E_OUTOFMEMORY
;
2105 buf
->buf
= This
->public_buffer
;
2106 This
->public_buffer
->mUserData
= buf
;
2109 This
->getbuf_last
= frames
;
2110 *data
= This
->public_buffer
->mAudioData
;
2111 silence_buffer(This
, *data
, frames
);
2113 OSSpinLockUnlock(&This
->lock
);
2118 static HRESULT WINAPI
AudioRenderClient_ReleaseBuffer(
2119 IAudioRenderClient
*iface
, UINT32 frames
, DWORD flags
)
2121 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
2123 AudioTimeStamp start_time
, req_time
= {0}, *passed_time
= NULL
;
2126 TRACE("(%p)->(%u, %x)\n", This
, frames
, flags
);
2128 OSSpinLockLock(&This
->lock
);
2131 This
->getbuf_last
= 0;
2132 if(This
->public_buffer
){
2133 buf
= This
->public_buffer
->mUserData
;
2134 list_add_head(&This
->avail_buffers
, &buf
->entry
);
2135 This
->public_buffer
= NULL
;
2137 OSSpinLockUnlock(&This
->lock
);
2141 if(!This
->getbuf_last
){
2142 OSSpinLockUnlock(&This
->lock
);
2143 return AUDCLNT_E_OUT_OF_ORDER
;
2146 if(frames
> This
->getbuf_last
){
2147 OSSpinLockUnlock(&This
->lock
);
2148 return AUDCLNT_E_INVALID_SIZE
;
2151 if(flags
& AUDCLNT_BUFFERFLAGS_SILENT
)
2152 silence_buffer(This
, This
->public_buffer
->mAudioData
, frames
);
2154 This
->public_buffer
->mAudioDataByteSize
= frames
* This
->fmt
->nBlockAlign
;
2156 buf
= This
->public_buffer
->mUserData
;
2159 if(list_empty(&This
->queued_bufinfos
)){
2160 sc
= AudioQueueGetCurrentTime(This
->aqueue
, NULL
, &req_time
, NULL
);
2162 passed_time
= &req_time
;
2164 TRACE("AudioQueueGetCurrentTime failed: %lx\n", sc
);
2166 req_time
.mSampleTime
= This
->next_sampletime
;
2167 req_time
.mFlags
= kAudioTimeStampSampleTimeValid
;
2168 passed_time
= &req_time
;
2171 sc
= AudioQueueEnqueueBufferWithParameters(This
->aqueue
,
2172 This
->public_buffer
, 0, NULL
, 0, 0, 0, NULL
, passed_time
,
2175 OSSpinLockUnlock(&This
->lock
);
2176 ERR("Unable to enqueue buffer: %lx\n", sc
);
2177 return AUDCLNT_E_DEVICE_INVALIDATED
;
2179 list_add_tail(&This
->queued_buffers
, &buf
->entry
);
2181 if(start_time
.mFlags
& kAudioTimeStampSampleTimeValid
){
2182 QueuedBufInfo
*bufinfo
;
2184 bufinfo
= HeapAlloc(GetProcessHeap(), 0, sizeof(*bufinfo
));
2185 bufinfo
->start_sampletime
= start_time
.mSampleTime
;
2186 bufinfo
->start_pos
= This
->written_frames
;
2187 bufinfo
->len_frames
= frames
;
2189 list_add_tail(&This
->queued_bufinfos
, &bufinfo
->entry
);
2191 This
->next_sampletime
= start_time
.mSampleTime
+ bufinfo
->len_frames
;
2193 WARN("Start time didn't contain valid SampleTime member\n");
2195 if(This
->playing
== StateStopped
)
2196 AudioQueuePrime(This
->aqueue
, 0, NULL
);
2198 This
->public_buffer
= NULL
;
2199 This
->getbuf_last
= 0;
2200 This
->written_frames
+= frames
;
2201 This
->inbuf_frames
+= frames
;
2203 OSSpinLockUnlock(&This
->lock
);
2208 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl
= {
2209 AudioRenderClient_QueryInterface
,
2210 AudioRenderClient_AddRef
,
2211 AudioRenderClient_Release
,
2212 AudioRenderClient_GetBuffer
,
2213 AudioRenderClient_ReleaseBuffer
2216 static HRESULT WINAPI
AudioCaptureClient_QueryInterface(
2217 IAudioCaptureClient
*iface
, REFIID riid
, void **ppv
)
2219 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
2220 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2226 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2227 IsEqualIID(riid
, &IID_IAudioCaptureClient
))
2229 else if(IsEqualIID(riid
, &IID_IMarshal
))
2230 return IUnknown_QueryInterface(This
->pUnkFTMarshal
, riid
, ppv
);
2233 IUnknown_AddRef((IUnknown
*)*ppv
);
2237 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2238 return E_NOINTERFACE
;
2241 static ULONG WINAPI
AudioCaptureClient_AddRef(IAudioCaptureClient
*iface
)
2243 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
2244 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2247 static ULONG WINAPI
AudioCaptureClient_Release(IAudioCaptureClient
*iface
)
2249 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
2250 return IAudioClient_Release(&This
->IAudioClient_iface
);
2253 static HRESULT WINAPI
AudioCaptureClient_GetBuffer(IAudioCaptureClient
*iface
,
2254 BYTE
**data
, UINT32
*frames
, DWORD
*flags
, UINT64
*devpos
,
2257 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
2260 TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This
, data
, frames
, flags
,
2263 if(!data
|| !frames
|| !flags
)
2266 OSSpinLockLock(&This
->lock
);
2268 if(This
->getbuf_last
){
2269 OSSpinLockUnlock(&This
->lock
);
2270 return AUDCLNT_E_OUT_OF_ORDER
;
2275 if(This
->inbuf_frames
< This
->period_frames
){
2277 OSSpinLockUnlock(&This
->lock
);
2278 return AUDCLNT_S_BUFFER_EMPTY
;
2283 chunk_bytes
= This
->bufsize_frames
* This
->fmt
->nBlockAlign
- This
->read_offs_bytes
;
2284 if(chunk_bytes
< This
->period_frames
* This
->fmt
->nBlockAlign
){
2285 if(!This
->tmp_buffer
)
2286 This
->tmp_buffer
= HeapAlloc(GetProcessHeap(), 0, This
->period_frames
* This
->fmt
->nBlockAlign
);
2287 *data
= This
->tmp_buffer
;
2288 memcpy(*data
, This
->capture_buf
+ This
->read_offs_bytes
, chunk_bytes
);
2289 memcpy((*data
) + chunk_bytes
, This
->capture_buf
, This
->period_frames
* This
->fmt
->nBlockAlign
- chunk_bytes
);
2291 *data
= This
->capture_buf
+ This
->read_offs_bytes
;
2293 This
->getbuf_last
= *frames
= This
->period_frames
;
2296 *devpos
= This
->written_frames
;
2297 if(qpcpos
){ /* fixme: qpc of recording time */
2298 LARGE_INTEGER stamp
, freq
;
2299 QueryPerformanceCounter(&stamp
);
2300 QueryPerformanceFrequency(&freq
);
2301 *qpcpos
= (stamp
.QuadPart
* (INT64
)10000000) / freq
.QuadPart
;
2304 OSSpinLockUnlock(&This
->lock
);
2309 static HRESULT WINAPI
AudioCaptureClient_ReleaseBuffer(
2310 IAudioCaptureClient
*iface
, UINT32 done
)
2312 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
2314 TRACE("(%p)->(%u)\n", This
, done
);
2316 OSSpinLockLock(&This
->lock
);
2319 This
->getbuf_last
= 0;
2320 OSSpinLockUnlock(&This
->lock
);
2324 if(!This
->getbuf_last
){
2325 OSSpinLockUnlock(&This
->lock
);
2326 return AUDCLNT_E_OUT_OF_ORDER
;
2329 if(This
->getbuf_last
!= done
){
2330 OSSpinLockUnlock(&This
->lock
);
2331 return AUDCLNT_E_INVALID_SIZE
;
2334 This
->written_frames
+= done
;
2335 This
->inbuf_frames
-= done
;
2336 This
->read_offs_bytes
+= done
* This
->fmt
->nBlockAlign
;
2337 This
->read_offs_bytes
%= This
->bufsize_frames
* This
->fmt
->nBlockAlign
;
2338 This
->getbuf_last
= 0;
2340 OSSpinLockUnlock(&This
->lock
);
2345 static HRESULT WINAPI
AudioCaptureClient_GetNextPacketSize(
2346 IAudioCaptureClient
*iface
, UINT32
*frames
)
2348 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
2350 TRACE("(%p)->(%p)\n", This
, frames
);
2355 OSSpinLockLock(&This
->lock
);
2359 if(This
->inbuf_frames
>= This
->period_frames
)
2360 *frames
= This
->period_frames
;
2364 OSSpinLockUnlock(&This
->lock
);
2369 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl
=
2371 AudioCaptureClient_QueryInterface
,
2372 AudioCaptureClient_AddRef
,
2373 AudioCaptureClient_Release
,
2374 AudioCaptureClient_GetBuffer
,
2375 AudioCaptureClient_ReleaseBuffer
,
2376 AudioCaptureClient_GetNextPacketSize
2379 static HRESULT WINAPI
AudioClock_QueryInterface(IAudioClock
*iface
,
2380 REFIID riid
, void **ppv
)
2382 ACImpl
*This
= impl_from_IAudioClock(iface
);
2384 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2390 if(IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IAudioClock
))
2392 else if(IsEqualIID(riid
, &IID_IAudioClock2
))
2393 *ppv
= &This
->IAudioClock2_iface
;
2395 IUnknown_AddRef((IUnknown
*)*ppv
);
2399 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2400 return E_NOINTERFACE
;
2403 static ULONG WINAPI
AudioClock_AddRef(IAudioClock
*iface
)
2405 ACImpl
*This
= impl_from_IAudioClock(iface
);
2406 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2409 static ULONG WINAPI
AudioClock_Release(IAudioClock
*iface
)
2411 ACImpl
*This
= impl_from_IAudioClock(iface
);
2412 return IAudioClient_Release(&This
->IAudioClient_iface
);
2415 static HRESULT WINAPI
AudioClock_GetFrequency(IAudioClock
*iface
, UINT64
*freq
)
2417 ACImpl
*This
= impl_from_IAudioClock(iface
);
2419 TRACE("(%p)->(%p)\n", This
, freq
);
2421 *freq
= This
->fmt
->nSamplesPerSec
;
2426 static HRESULT
AudioClock_GetPosition_nolock(ACImpl
*This
,
2427 UINT64
*pos
, UINT64
*qpctime
)
2431 if(This
->dataflow
== eRender
)
2432 *pos
= get_current_aqbuffer_position(This
, BUFPOS_ABSOLUTE
);
2434 *pos
= This
->inbuf_frames
+ This
->written_frames
;
2437 LARGE_INTEGER stamp
, freq
;
2438 QueryPerformanceCounter(&stamp
);
2439 QueryPerformanceFrequency(&freq
);
2440 *qpctime
= (stamp
.QuadPart
* (INT64
)10000000) / freq
.QuadPart
;
2446 static HRESULT WINAPI
AudioClock_GetPosition(IAudioClock
*iface
, UINT64
*pos
,
2449 ACImpl
*This
= impl_from_IAudioClock(iface
);
2452 TRACE("(%p)->(%p, %p)\n", This
, pos
, qpctime
);
2457 OSSpinLockLock(&This
->lock
);
2459 hr
= AudioClock_GetPosition_nolock(This
, pos
, qpctime
);
2461 OSSpinLockUnlock(&This
->lock
);
2466 static HRESULT WINAPI
AudioClock_GetCharacteristics(IAudioClock
*iface
,
2469 ACImpl
*This
= impl_from_IAudioClock(iface
);
2471 TRACE("(%p)->(%p)\n", This
, chars
);
2476 *chars
= AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ
;
2481 static const IAudioClockVtbl AudioClock_Vtbl
=
2483 AudioClock_QueryInterface
,
2486 AudioClock_GetFrequency
,
2487 AudioClock_GetPosition
,
2488 AudioClock_GetCharacteristics
2491 static HRESULT WINAPI
AudioClock2_QueryInterface(IAudioClock2
*iface
,
2492 REFIID riid
, void **ppv
)
2494 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2495 return IAudioClock_QueryInterface(&This
->IAudioClock_iface
, riid
, ppv
);
2498 static ULONG WINAPI
AudioClock2_AddRef(IAudioClock2
*iface
)
2500 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2501 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2504 static ULONG WINAPI
AudioClock2_Release(IAudioClock2
*iface
)
2506 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2507 return IAudioClient_Release(&This
->IAudioClient_iface
);
2510 static HRESULT WINAPI
AudioClock2_GetDevicePosition(IAudioClock2
*iface
,
2511 UINT64
*pos
, UINT64
*qpctime
)
2513 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2515 FIXME("(%p)->(%p, %p)\n", This
, pos
, qpctime
);
2520 static const IAudioClock2Vtbl AudioClock2_Vtbl
=
2522 AudioClock2_QueryInterface
,
2524 AudioClock2_Release
,
2525 AudioClock2_GetDevicePosition
2528 static AudioSessionWrapper
*AudioSessionWrapper_Create(ACImpl
*client
)
2530 AudioSessionWrapper
*ret
;
2532 ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2533 sizeof(AudioSessionWrapper
));
2537 ret
->IAudioSessionControl2_iface
.lpVtbl
= &AudioSessionControl2_Vtbl
;
2538 ret
->ISimpleAudioVolume_iface
.lpVtbl
= &SimpleAudioVolume_Vtbl
;
2539 ret
->IChannelAudioVolume_iface
.lpVtbl
= &ChannelAudioVolume_Vtbl
;
2543 ret
->client
= client
;
2545 ret
->session
= client
->session
;
2546 AudioClient_AddRef(&client
->IAudioClient_iface
);
2552 static HRESULT WINAPI
AudioSessionControl_QueryInterface(
2553 IAudioSessionControl2
*iface
, REFIID riid
, void **ppv
)
2555 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2561 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2562 IsEqualIID(riid
, &IID_IAudioSessionControl
) ||
2563 IsEqualIID(riid
, &IID_IAudioSessionControl2
))
2566 IUnknown_AddRef((IUnknown
*)*ppv
);
2570 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2571 return E_NOINTERFACE
;
2574 static ULONG WINAPI
AudioSessionControl_AddRef(IAudioSessionControl2
*iface
)
2576 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2578 ref
= InterlockedIncrement(&This
->ref
);
2579 TRACE("(%p) Refcount now %u\n", This
, ref
);
2583 static ULONG WINAPI
AudioSessionControl_Release(IAudioSessionControl2
*iface
)
2585 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2587 ref
= InterlockedDecrement(&This
->ref
);
2588 TRACE("(%p) Refcount now %u\n", This
, ref
);
2591 OSSpinLockLock(&This
->client
->lock
);
2592 This
->client
->session_wrapper
= NULL
;
2593 OSSpinLockUnlock(&This
->client
->lock
);
2594 AudioClient_Release(&This
->client
->IAudioClient_iface
);
2596 HeapFree(GetProcessHeap(), 0, This
);
2601 static HRESULT WINAPI
AudioSessionControl_GetState(IAudioSessionControl2
*iface
,
2602 AudioSessionState
*state
)
2604 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2607 TRACE("(%p)->(%p)\n", This
, state
);
2610 return NULL_PTR_ERR
;
2612 EnterCriticalSection(&g_sessions_lock
);
2614 if(list_empty(&This
->session
->clients
)){
2615 *state
= AudioSessionStateExpired
;
2616 LeaveCriticalSection(&g_sessions_lock
);
2620 LIST_FOR_EACH_ENTRY(client
, &This
->session
->clients
, ACImpl
, entry
){
2621 OSSpinLockLock(&client
->lock
);
2622 if(client
->playing
== StatePlaying
||
2623 client
->playing
== StateInTransition
){
2624 *state
= AudioSessionStateActive
;
2625 OSSpinLockUnlock(&client
->lock
);
2626 LeaveCriticalSection(&g_sessions_lock
);
2629 OSSpinLockUnlock(&client
->lock
);
2632 LeaveCriticalSection(&g_sessions_lock
);
2634 *state
= AudioSessionStateInactive
;
2639 static HRESULT WINAPI
AudioSessionControl_GetDisplayName(
2640 IAudioSessionControl2
*iface
, WCHAR
**name
)
2642 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2644 FIXME("(%p)->(%p) - stub\n", This
, name
);
2649 static HRESULT WINAPI
AudioSessionControl_SetDisplayName(
2650 IAudioSessionControl2
*iface
, const WCHAR
*name
, const GUID
*session
)
2652 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2654 FIXME("(%p)->(%p, %s) - stub\n", This
, name
, debugstr_guid(session
));
2659 static HRESULT WINAPI
AudioSessionControl_GetIconPath(
2660 IAudioSessionControl2
*iface
, WCHAR
**path
)
2662 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2664 FIXME("(%p)->(%p) - stub\n", This
, path
);
2669 static HRESULT WINAPI
AudioSessionControl_SetIconPath(
2670 IAudioSessionControl2
*iface
, const WCHAR
*path
, const GUID
*session
)
2672 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2674 FIXME("(%p)->(%p, %s) - stub\n", This
, path
, debugstr_guid(session
));
2679 static HRESULT WINAPI
AudioSessionControl_GetGroupingParam(
2680 IAudioSessionControl2
*iface
, GUID
*group
)
2682 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2684 FIXME("(%p)->(%p) - stub\n", This
, group
);
2689 static HRESULT WINAPI
AudioSessionControl_SetGroupingParam(
2690 IAudioSessionControl2
*iface
, const GUID
*group
, const GUID
*session
)
2692 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2694 FIXME("(%p)->(%s, %s) - stub\n", This
, debugstr_guid(group
),
2695 debugstr_guid(session
));
2700 static HRESULT WINAPI
AudioSessionControl_RegisterAudioSessionNotification(
2701 IAudioSessionControl2
*iface
, IAudioSessionEvents
*events
)
2703 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2705 FIXME("(%p)->(%p) - stub\n", This
, events
);
2710 static HRESULT WINAPI
AudioSessionControl_UnregisterAudioSessionNotification(
2711 IAudioSessionControl2
*iface
, IAudioSessionEvents
*events
)
2713 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2715 FIXME("(%p)->(%p) - stub\n", This
, events
);
2720 static HRESULT WINAPI
AudioSessionControl_GetSessionIdentifier(
2721 IAudioSessionControl2
*iface
, WCHAR
**id
)
2723 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2725 FIXME("(%p)->(%p) - stub\n", This
, id
);
2730 static HRESULT WINAPI
AudioSessionControl_GetSessionInstanceIdentifier(
2731 IAudioSessionControl2
*iface
, WCHAR
**id
)
2733 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2735 FIXME("(%p)->(%p) - stub\n", This
, id
);
2740 static HRESULT WINAPI
AudioSessionControl_GetProcessId(
2741 IAudioSessionControl2
*iface
, DWORD
*pid
)
2743 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2745 TRACE("(%p)->(%p)\n", This
, pid
);
2750 *pid
= GetCurrentProcessId();
2755 static HRESULT WINAPI
AudioSessionControl_IsSystemSoundsSession(
2756 IAudioSessionControl2
*iface
)
2758 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2760 TRACE("(%p)\n", This
);
2765 static HRESULT WINAPI
AudioSessionControl_SetDuckingPreference(
2766 IAudioSessionControl2
*iface
, BOOL optout
)
2768 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2770 TRACE("(%p)->(%d)\n", This
, optout
);
2775 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl
=
2777 AudioSessionControl_QueryInterface
,
2778 AudioSessionControl_AddRef
,
2779 AudioSessionControl_Release
,
2780 AudioSessionControl_GetState
,
2781 AudioSessionControl_GetDisplayName
,
2782 AudioSessionControl_SetDisplayName
,
2783 AudioSessionControl_GetIconPath
,
2784 AudioSessionControl_SetIconPath
,
2785 AudioSessionControl_GetGroupingParam
,
2786 AudioSessionControl_SetGroupingParam
,
2787 AudioSessionControl_RegisterAudioSessionNotification
,
2788 AudioSessionControl_UnregisterAudioSessionNotification
,
2789 AudioSessionControl_GetSessionIdentifier
,
2790 AudioSessionControl_GetSessionInstanceIdentifier
,
2791 AudioSessionControl_GetProcessId
,
2792 AudioSessionControl_IsSystemSoundsSession
,
2793 AudioSessionControl_SetDuckingPreference
2796 /* index == -1 means set all channels, otherwise sets only the given channel */
2797 static HRESULT
ca_setvol(ACImpl
*This
, UINT32 index
)
2802 if(index
== (UINT32
)-1){
2805 for(i
= 0; i
< This
->fmt
->nChannels
; ++i
){
2807 hr
= ca_setvol(This
, i
);
2814 if(This
->session
->mute
)
2817 level
= This
->session
->master_vol
*
2818 This
->session
->channel_vols
[index
] * This
->vols
[index
];
2820 sc
= AudioQueueSetParameter(This
->aqueue
, kAudioQueueParam_Volume
, level
);
2822 WARN("Setting _Volume property failed: %lx\n", sc
);
2827 static HRESULT
ca_session_setvol(AudioSession
*session
, UINT32 index
)
2832 LIST_FOR_EACH_ENTRY(client
, &session
->clients
, ACImpl
, entry
){
2834 hr
= ca_setvol(client
, index
);
2842 static HRESULT WINAPI
SimpleAudioVolume_QueryInterface(
2843 ISimpleAudioVolume
*iface
, REFIID riid
, void **ppv
)
2845 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2851 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2852 IsEqualIID(riid
, &IID_ISimpleAudioVolume
))
2855 IUnknown_AddRef((IUnknown
*)*ppv
);
2859 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2860 return E_NOINTERFACE
;
2863 static ULONG WINAPI
SimpleAudioVolume_AddRef(ISimpleAudioVolume
*iface
)
2865 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2866 return AudioSessionControl_AddRef(&This
->IAudioSessionControl2_iface
);
2869 static ULONG WINAPI
SimpleAudioVolume_Release(ISimpleAudioVolume
*iface
)
2871 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2872 return AudioSessionControl_Release(&This
->IAudioSessionControl2_iface
);
2875 static HRESULT WINAPI
SimpleAudioVolume_SetMasterVolume(
2876 ISimpleAudioVolume
*iface
, float level
, const GUID
*context
)
2878 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2879 AudioSession
*session
= This
->session
;
2882 TRACE("(%p)->(%f, %s)\n", session
, level
, wine_dbgstr_guid(context
));
2884 if(level
< 0.f
|| level
> 1.f
)
2885 return E_INVALIDARG
;
2888 FIXME("Notifications not supported yet\n");
2890 EnterCriticalSection(&session
->lock
);
2892 session
->master_vol
= level
;
2894 ret
= ca_session_setvol(session
, -1);
2896 LeaveCriticalSection(&session
->lock
);
2901 static HRESULT WINAPI
SimpleAudioVolume_GetMasterVolume(
2902 ISimpleAudioVolume
*iface
, float *level
)
2904 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2905 AudioSession
*session
= This
->session
;
2907 TRACE("(%p)->(%p)\n", session
, level
);
2910 return NULL_PTR_ERR
;
2912 *level
= session
->master_vol
;
2917 static HRESULT WINAPI
SimpleAudioVolume_SetMute(ISimpleAudioVolume
*iface
,
2918 BOOL mute
, const GUID
*context
)
2920 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2921 AudioSession
*session
= This
->session
;
2923 TRACE("(%p)->(%u, %p)\n", session
, mute
, context
);
2926 FIXME("Notifications not supported yet\n");
2928 EnterCriticalSection(&session
->lock
);
2930 session
->mute
= mute
;
2932 ca_session_setvol(session
, -1);
2934 LeaveCriticalSection(&session
->lock
);
2939 static HRESULT WINAPI
SimpleAudioVolume_GetMute(ISimpleAudioVolume
*iface
,
2942 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2943 AudioSession
*session
= This
->session
;
2945 TRACE("(%p)->(%p)\n", session
, mute
);
2948 return NULL_PTR_ERR
;
2950 *mute
= session
->mute
;
2955 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl
=
2957 SimpleAudioVolume_QueryInterface
,
2958 SimpleAudioVolume_AddRef
,
2959 SimpleAudioVolume_Release
,
2960 SimpleAudioVolume_SetMasterVolume
,
2961 SimpleAudioVolume_GetMasterVolume
,
2962 SimpleAudioVolume_SetMute
,
2963 SimpleAudioVolume_GetMute
2966 static HRESULT WINAPI
AudioStreamVolume_QueryInterface(
2967 IAudioStreamVolume
*iface
, REFIID riid
, void **ppv
)
2969 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2975 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2976 IsEqualIID(riid
, &IID_IAudioStreamVolume
))
2979 IUnknown_AddRef((IUnknown
*)*ppv
);
2983 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2984 return E_NOINTERFACE
;
2987 static ULONG WINAPI
AudioStreamVolume_AddRef(IAudioStreamVolume
*iface
)
2989 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2990 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2993 static ULONG WINAPI
AudioStreamVolume_Release(IAudioStreamVolume
*iface
)
2995 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2996 return IAudioClient_Release(&This
->IAudioClient_iface
);
2999 static HRESULT WINAPI
AudioStreamVolume_GetChannelCount(
3000 IAudioStreamVolume
*iface
, UINT32
*out
)
3002 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
3004 TRACE("(%p)->(%p)\n", This
, out
);
3009 *out
= This
->fmt
->nChannels
;
3014 static HRESULT WINAPI
AudioStreamVolume_SetChannelVolume(
3015 IAudioStreamVolume
*iface
, UINT32 index
, float level
)
3017 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
3020 TRACE("(%p)->(%d, %f)\n", This
, index
, level
);
3022 if(level
< 0.f
|| level
> 1.f
)
3023 return E_INVALIDARG
;
3025 if(index
>= This
->fmt
->nChannels
)
3026 return E_INVALIDARG
;
3028 OSSpinLockLock(&This
->lock
);
3030 This
->vols
[index
] = level
;
3032 WARN("AudioQueue doesn't support per-channel volume control\n");
3033 ret
= ca_setvol(This
, index
);
3035 OSSpinLockUnlock(&This
->lock
);
3040 static HRESULT WINAPI
AudioStreamVolume_GetChannelVolume(
3041 IAudioStreamVolume
*iface
, UINT32 index
, float *level
)
3043 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
3045 TRACE("(%p)->(%d, %p)\n", This
, index
, level
);
3050 if(index
>= This
->fmt
->nChannels
)
3051 return E_INVALIDARG
;
3053 *level
= This
->vols
[index
];
3058 static HRESULT WINAPI
AudioStreamVolume_SetAllVolumes(
3059 IAudioStreamVolume
*iface
, UINT32 count
, const float *levels
)
3061 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
3065 TRACE("(%p)->(%d, %p)\n", This
, count
, levels
);
3070 if(count
!= This
->fmt
->nChannels
)
3071 return E_INVALIDARG
;
3073 OSSpinLockLock(&This
->lock
);
3075 for(i
= 0; i
< count
; ++i
)
3076 This
->vols
[i
] = levels
[i
];
3078 ret
= ca_setvol(This
, -1);
3080 OSSpinLockUnlock(&This
->lock
);
3085 static HRESULT WINAPI
AudioStreamVolume_GetAllVolumes(
3086 IAudioStreamVolume
*iface
, UINT32 count
, float *levels
)
3088 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
3091 TRACE("(%p)->(%d, %p)\n", This
, count
, levels
);
3096 if(count
!= This
->fmt
->nChannels
)
3097 return E_INVALIDARG
;
3099 OSSpinLockLock(&This
->lock
);
3101 for(i
= 0; i
< count
; ++i
)
3102 levels
[i
] = This
->vols
[i
];
3104 OSSpinLockUnlock(&This
->lock
);
3109 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl
=
3111 AudioStreamVolume_QueryInterface
,
3112 AudioStreamVolume_AddRef
,
3113 AudioStreamVolume_Release
,
3114 AudioStreamVolume_GetChannelCount
,
3115 AudioStreamVolume_SetChannelVolume
,
3116 AudioStreamVolume_GetChannelVolume
,
3117 AudioStreamVolume_SetAllVolumes
,
3118 AudioStreamVolume_GetAllVolumes
3121 static HRESULT WINAPI
ChannelAudioVolume_QueryInterface(
3122 IChannelAudioVolume
*iface
, REFIID riid
, void **ppv
)
3124 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
3130 if(IsEqualIID(riid
, &IID_IUnknown
) ||
3131 IsEqualIID(riid
, &IID_IChannelAudioVolume
))
3134 IUnknown_AddRef((IUnknown
*)*ppv
);
3138 WARN("Unknown interface %s\n", debugstr_guid(riid
));
3139 return E_NOINTERFACE
;
3142 static ULONG WINAPI
ChannelAudioVolume_AddRef(IChannelAudioVolume
*iface
)
3144 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3145 return AudioSessionControl_AddRef(&This
->IAudioSessionControl2_iface
);
3148 static ULONG WINAPI
ChannelAudioVolume_Release(IChannelAudioVolume
*iface
)
3150 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3151 return AudioSessionControl_Release(&This
->IAudioSessionControl2_iface
);
3154 static HRESULT WINAPI
ChannelAudioVolume_GetChannelCount(
3155 IChannelAudioVolume
*iface
, UINT32
*out
)
3157 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3158 AudioSession
*session
= This
->session
;
3160 TRACE("(%p)->(%p)\n", session
, out
);
3163 return NULL_PTR_ERR
;
3165 *out
= session
->channel_count
;
3170 static HRESULT WINAPI
ChannelAudioVolume_SetChannelVolume(
3171 IChannelAudioVolume
*iface
, UINT32 index
, float level
,
3172 const GUID
*context
)
3174 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3175 AudioSession
*session
= This
->session
;
3178 TRACE("(%p)->(%d, %f, %s)\n", session
, index
, level
,
3179 wine_dbgstr_guid(context
));
3181 if(level
< 0.f
|| level
> 1.f
)
3182 return E_INVALIDARG
;
3184 if(index
>= session
->channel_count
)
3185 return E_INVALIDARG
;
3188 FIXME("Notifications not supported yet\n");
3190 EnterCriticalSection(&session
->lock
);
3192 session
->channel_vols
[index
] = level
;
3194 WARN("AudioQueue doesn't support per-channel volume control\n");
3195 ret
= ca_session_setvol(session
, index
);
3197 LeaveCriticalSection(&session
->lock
);
3202 static HRESULT WINAPI
ChannelAudioVolume_GetChannelVolume(
3203 IChannelAudioVolume
*iface
, UINT32 index
, float *level
)
3205 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3206 AudioSession
*session
= This
->session
;
3208 TRACE("(%p)->(%d, %p)\n", session
, index
, level
);
3211 return NULL_PTR_ERR
;
3213 if(index
>= session
->channel_count
)
3214 return E_INVALIDARG
;
3216 *level
= session
->channel_vols
[index
];
3221 static HRESULT WINAPI
ChannelAudioVolume_SetAllVolumes(
3222 IChannelAudioVolume
*iface
, UINT32 count
, const float *levels
,
3223 const GUID
*context
)
3225 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3226 AudioSession
*session
= This
->session
;
3230 TRACE("(%p)->(%d, %p, %s)\n", session
, count
, levels
,
3231 wine_dbgstr_guid(context
));
3234 return NULL_PTR_ERR
;
3236 if(count
!= session
->channel_count
)
3237 return E_INVALIDARG
;
3240 FIXME("Notifications not supported yet\n");
3242 EnterCriticalSection(&session
->lock
);
3244 for(i
= 0; i
< count
; ++i
)
3245 session
->channel_vols
[i
] = levels
[i
];
3247 ret
= ca_session_setvol(session
, -1);
3249 LeaveCriticalSection(&session
->lock
);
3254 static HRESULT WINAPI
ChannelAudioVolume_GetAllVolumes(
3255 IChannelAudioVolume
*iface
, UINT32 count
, float *levels
)
3257 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3258 AudioSession
*session
= This
->session
;
3261 TRACE("(%p)->(%d, %p)\n", session
, count
, levels
);
3264 return NULL_PTR_ERR
;
3266 if(count
!= session
->channel_count
)
3267 return E_INVALIDARG
;
3269 for(i
= 0; i
< count
; ++i
)
3270 levels
[i
] = session
->channel_vols
[i
];
3275 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl
=
3277 ChannelAudioVolume_QueryInterface
,
3278 ChannelAudioVolume_AddRef
,
3279 ChannelAudioVolume_Release
,
3280 ChannelAudioVolume_GetChannelCount
,
3281 ChannelAudioVolume_SetChannelVolume
,
3282 ChannelAudioVolume_GetChannelVolume
,
3283 ChannelAudioVolume_SetAllVolumes
,
3284 ChannelAudioVolume_GetAllVolumes
3287 static HRESULT WINAPI
AudioSessionManager_QueryInterface(IAudioSessionManager2
*iface
,
3288 REFIID riid
, void **ppv
)
3290 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
3296 if(IsEqualIID(riid
, &IID_IUnknown
) ||
3297 IsEqualIID(riid
, &IID_IAudioSessionManager
) ||
3298 IsEqualIID(riid
, &IID_IAudioSessionManager2
))
3301 IUnknown_AddRef((IUnknown
*)*ppv
);
3305 WARN("Unknown interface %s\n", debugstr_guid(riid
));
3306 return E_NOINTERFACE
;
3309 static ULONG WINAPI
AudioSessionManager_AddRef(IAudioSessionManager2
*iface
)
3311 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3313 ref
= InterlockedIncrement(&This
->ref
);
3314 TRACE("(%p) Refcount now %u\n", This
, ref
);
3318 static ULONG WINAPI
AudioSessionManager_Release(IAudioSessionManager2
*iface
)
3320 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3322 ref
= InterlockedDecrement(&This
->ref
);
3323 TRACE("(%p) Refcount now %u\n", This
, ref
);
3325 HeapFree(GetProcessHeap(), 0, This
);
3329 static HRESULT WINAPI
AudioSessionManager_GetAudioSessionControl(
3330 IAudioSessionManager2
*iface
, const GUID
*session_guid
, DWORD flags
,
3331 IAudioSessionControl
**out
)
3333 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3334 AudioSession
*session
;
3335 AudioSessionWrapper
*wrapper
;
3338 TRACE("(%p)->(%s, %x, %p)\n", This
, debugstr_guid(session_guid
),
3341 hr
= get_audio_session(session_guid
, This
->device
, 0, &session
);
3345 wrapper
= AudioSessionWrapper_Create(NULL
);
3347 return E_OUTOFMEMORY
;
3349 wrapper
->session
= session
;
3351 *out
= (IAudioSessionControl
*)&wrapper
->IAudioSessionControl2_iface
;
3356 static HRESULT WINAPI
AudioSessionManager_GetSimpleAudioVolume(
3357 IAudioSessionManager2
*iface
, const GUID
*session_guid
, DWORD flags
,
3358 ISimpleAudioVolume
**out
)
3360 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3361 AudioSession
*session
;
3362 AudioSessionWrapper
*wrapper
;
3365 TRACE("(%p)->(%s, %x, %p)\n", This
, debugstr_guid(session_guid
),
3368 hr
= get_audio_session(session_guid
, This
->device
, 0, &session
);
3372 wrapper
= AudioSessionWrapper_Create(NULL
);
3374 return E_OUTOFMEMORY
;
3376 wrapper
->session
= session
;
3378 *out
= &wrapper
->ISimpleAudioVolume_iface
;
3383 static HRESULT WINAPI
AudioSessionManager_GetSessionEnumerator(
3384 IAudioSessionManager2
*iface
, IAudioSessionEnumerator
**out
)
3386 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3387 FIXME("(%p)->(%p) - stub\n", This
, out
);
3391 static HRESULT WINAPI
AudioSessionManager_RegisterSessionNotification(
3392 IAudioSessionManager2
*iface
, IAudioSessionNotification
*notification
)
3394 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3395 FIXME("(%p)->(%p) - stub\n", This
, notification
);
3399 static HRESULT WINAPI
AudioSessionManager_UnregisterSessionNotification(
3400 IAudioSessionManager2
*iface
, IAudioSessionNotification
*notification
)
3402 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3403 FIXME("(%p)->(%p) - stub\n", This
, notification
);
3407 static HRESULT WINAPI
AudioSessionManager_RegisterDuckNotification(
3408 IAudioSessionManager2
*iface
, const WCHAR
*session_id
,
3409 IAudioVolumeDuckNotification
*notification
)
3411 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3412 FIXME("(%p)->(%p) - stub\n", This
, notification
);
3416 static HRESULT WINAPI
AudioSessionManager_UnregisterDuckNotification(
3417 IAudioSessionManager2
*iface
,
3418 IAudioVolumeDuckNotification
*notification
)
3420 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3421 FIXME("(%p)->(%p) - stub\n", This
, notification
);
3425 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl
=
3427 AudioSessionManager_QueryInterface
,
3428 AudioSessionManager_AddRef
,
3429 AudioSessionManager_Release
,
3430 AudioSessionManager_GetAudioSessionControl
,
3431 AudioSessionManager_GetSimpleAudioVolume
,
3432 AudioSessionManager_GetSessionEnumerator
,
3433 AudioSessionManager_RegisterSessionNotification
,
3434 AudioSessionManager_UnregisterSessionNotification
,
3435 AudioSessionManager_RegisterDuckNotification
,
3436 AudioSessionManager_UnregisterDuckNotification
3439 HRESULT WINAPI
AUDDRV_GetAudioSessionManager(IMMDevice
*device
,
3440 IAudioSessionManager2
**out
)
3444 This
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(SessionMgr
));
3446 return E_OUTOFMEMORY
;
3448 This
->IAudioSessionManager2_iface
.lpVtbl
= &AudioSessionManager2_Vtbl
;
3449 This
->device
= device
;
3452 *out
= &This
->IAudioSessionManager2_iface
;