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
28 #include <sys/types.h>
30 #include <sys/ioctl.h>
34 #include <sys/soundcard.h>
40 #include "wine/debug.h"
41 #include "wine/unicode.h"
42 #include "wine/list.h"
45 #include "mmdeviceapi.h"
51 #include "endpointvolume.h"
52 #include "audiopolicy.h"
53 #include "audioclient.h"
55 WINE_DEFAULT_DEBUG_CHANNEL(oss
);
57 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
59 static const REFERENCE_TIME DefaultPeriod
= 100000;
60 static const REFERENCE_TIME MinimumPeriod
= 50000;
63 typedef struct ACImpl ACImpl
;
65 typedef struct _AudioSession
{
76 CRITICAL_SECTION lock
;
81 typedef struct _AudioSessionWrapper
{
82 IAudioSessionControl2 IAudioSessionControl2_iface
;
83 IChannelAudioVolume IChannelAudioVolume_iface
;
84 ISimpleAudioVolume ISimpleAudioVolume_iface
;
89 AudioSession
*session
;
90 } AudioSessionWrapper
;
93 IAudioClient IAudioClient_iface
;
94 IAudioRenderClient IAudioRenderClient_iface
;
95 IAudioCaptureClient IAudioCaptureClient_iface
;
96 IAudioClock IAudioClock_iface
;
97 IAudioClock2 IAudioClock2_iface
;
98 IAudioStreamVolume IAudioStreamVolume_iface
;
103 IUnknown
*pUnkFTMarshal
;
109 AUDCLNT_SHAREMODE share
;
115 char devnode
[OSS_DEVNODE_SIZE
];
117 BOOL initted
, playing
;
118 UINT64 written_frames
, last_pos_frames
;
119 UINT32 period_us
, period_frames
, bufsize_frames
, held_frames
, tmp_buffer_frames
, in_oss_frames
;
120 UINT32 oss_bufsize_bytes
, lcl_offs_frames
; /* offs into local_buffer where valid data starts */
122 BYTE
*local_buffer
, *tmp_buffer
;
123 LONG32 getbuf_last
; /* <0 when using tmp_buffer */
126 CRITICAL_SECTION lock
;
128 AudioSession
*session
;
129 AudioSessionWrapper
*session_wrapper
;
134 typedef struct _SessionMgr
{
135 IAudioSessionManager2 IAudioSessionManager2_iface
;
142 typedef struct _OSSDevice
{
144 char devnode
[OSS_DEVNODE_SIZE
];
150 static struct list g_devices
= LIST_INIT(g_devices
);
152 static const WCHAR drv_key_devicesW
[] = {'S','o','f','t','w','a','r','e','\\',
153 'W','i','n','e','\\','D','r','i','v','e','r','s','\\',
154 'w','i','n','e','o','s','s','.','d','r','v','\\','d','e','v','i','c','e','s',0};
155 static const WCHAR guidW
[] = {'g','u','i','d',0};
157 static HANDLE g_timer_q
;
159 static CRITICAL_SECTION g_sessions_lock
;
160 static CRITICAL_SECTION_DEBUG g_sessions_lock_debug
=
162 0, 0, &g_sessions_lock
,
163 { &g_sessions_lock_debug
.ProcessLocksList
, &g_sessions_lock_debug
.ProcessLocksList
},
164 0, 0, { (DWORD_PTR
)(__FILE__
": g_sessions_lock") }
166 static CRITICAL_SECTION g_sessions_lock
= { &g_sessions_lock_debug
, -1, 0, 0, 0, 0 };
167 static struct list g_sessions
= LIST_INIT(g_sessions
);
169 static AudioSessionWrapper
*AudioSessionWrapper_Create(ACImpl
*client
);
171 static const IAudioClientVtbl AudioClient_Vtbl
;
172 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl
;
173 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl
;
174 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl
;
175 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl
;
176 static const IAudioClockVtbl AudioClock_Vtbl
;
177 static const IAudioClock2Vtbl AudioClock2_Vtbl
;
178 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl
;
179 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl
;
180 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl
;
182 static inline ACImpl
*impl_from_IAudioClient(IAudioClient
*iface
)
184 return CONTAINING_RECORD(iface
, ACImpl
, IAudioClient_iface
);
187 static inline ACImpl
*impl_from_IAudioRenderClient(IAudioRenderClient
*iface
)
189 return CONTAINING_RECORD(iface
, ACImpl
, IAudioRenderClient_iface
);
192 static inline ACImpl
*impl_from_IAudioCaptureClient(IAudioCaptureClient
*iface
)
194 return CONTAINING_RECORD(iface
, ACImpl
, IAudioCaptureClient_iface
);
197 static inline AudioSessionWrapper
*impl_from_IAudioSessionControl2(IAudioSessionControl2
*iface
)
199 return CONTAINING_RECORD(iface
, AudioSessionWrapper
, IAudioSessionControl2_iface
);
202 static inline AudioSessionWrapper
*impl_from_ISimpleAudioVolume(ISimpleAudioVolume
*iface
)
204 return CONTAINING_RECORD(iface
, AudioSessionWrapper
, ISimpleAudioVolume_iface
);
207 static inline AudioSessionWrapper
*impl_from_IChannelAudioVolume(IChannelAudioVolume
*iface
)
209 return CONTAINING_RECORD(iface
, AudioSessionWrapper
, IChannelAudioVolume_iface
);
212 static inline ACImpl
*impl_from_IAudioClock(IAudioClock
*iface
)
214 return CONTAINING_RECORD(iface
, ACImpl
, IAudioClock_iface
);
217 static inline ACImpl
*impl_from_IAudioClock2(IAudioClock2
*iface
)
219 return CONTAINING_RECORD(iface
, ACImpl
, IAudioClock2_iface
);
222 static inline ACImpl
*impl_from_IAudioStreamVolume(IAudioStreamVolume
*iface
)
224 return CONTAINING_RECORD(iface
, ACImpl
, IAudioStreamVolume_iface
);
227 static inline SessionMgr
*impl_from_IAudioSessionManager2(IAudioSessionManager2
*iface
)
229 return CONTAINING_RECORD(iface
, SessionMgr
, IAudioSessionManager2_iface
);
232 BOOL WINAPI
DllMain(HINSTANCE dll
, DWORD reason
, void *reserved
)
236 case DLL_PROCESS_ATTACH
:
237 g_timer_q
= CreateTimerQueue();
242 case DLL_PROCESS_DETACH
:
245 OSSDevice
*iter
, *iter2
;
247 DeleteCriticalSection(&g_sessions_lock
);
249 LIST_FOR_EACH_ENTRY_SAFE(iter
, iter2
, &g_devices
, OSSDevice
, entry
){
250 HeapFree(GetProcessHeap(), 0, iter
);
258 /* From <dlls/mmdevapi/mmdevapi.h> */
259 enum DriverPriority
{
260 Priority_Unavailable
= 0,
266 int WINAPI
AUDDRV_GetPriority(void)
271 /* Attempt to determine if we are running on OSS or ALSA's OSS
272 * compatibility layer. There is no official way to do that, so just check
273 * for validity as best as possible, without rejecting valid OSS
274 * implementations. */
276 mixer_fd
= open("/dev/mixer", O_RDONLY
, 0);
278 TRACE("Priority_Unavailable: open failed\n");
279 return Priority_Unavailable
;
282 sysinfo
.version
[0] = 0xFF;
283 sysinfo
.versionnum
= ~0;
284 if(ioctl(mixer_fd
, SNDCTL_SYSINFO
, &sysinfo
) < 0){
285 TRACE("Priority_Unavailable: ioctl failed\n");
287 return Priority_Unavailable
;
292 if(sysinfo
.version
[0] < '4' || sysinfo
.version
[0] > '9'){
293 TRACE("Priority_Low: sysinfo.version[0]: %x\n", sysinfo
.version
[0]);
296 if(sysinfo
.versionnum
& 0x80000000){
297 TRACE("Priority_Low: sysinfo.versionnum: %x\n", sysinfo
.versionnum
);
301 TRACE("Priority_Preferred: Seems like valid OSS!\n");
303 return Priority_Preferred
;
306 static void set_device_guid(EDataFlow flow
, HKEY drv_key
, const WCHAR
*key_name
,
314 lr
= RegCreateKeyExW(HKEY_CURRENT_USER
, drv_key_devicesW
, 0, NULL
, 0, KEY_WRITE
,
315 NULL
, &drv_key
, NULL
);
316 if(lr
!= ERROR_SUCCESS
){
317 ERR("RegCreateKeyEx(drv_key) failed: %u\n", lr
);
323 lr
= RegCreateKeyExW(drv_key
, key_name
, 0, NULL
, 0, KEY_WRITE
,
325 if(lr
!= ERROR_SUCCESS
){
326 ERR("RegCreateKeyEx(%s) failed: %u\n", wine_dbgstr_w(key_name
), lr
);
330 lr
= RegSetValueExW(key
, guidW
, 0, REG_BINARY
, (BYTE
*)guid
,
332 if(lr
!= ERROR_SUCCESS
)
333 ERR("RegSetValueEx(%s\\guid) failed: %u\n", wine_dbgstr_w(key_name
), lr
);
338 RegCloseKey(drv_key
);
341 static void get_device_guid(EDataFlow flow
, const char *device
, GUID
*guid
)
343 HKEY key
= NULL
, dev_key
;
344 DWORD type
, size
= sizeof(*guid
);
352 MultiByteToWideChar(CP_UNIXCP
, 0, device
, -1, key_name
+ 2, ARRAY_SIZE(key_name
) - 2);
354 if(RegOpenKeyExW(HKEY_CURRENT_USER
, drv_key_devicesW
, 0, KEY_WRITE
|KEY_READ
, &key
) == ERROR_SUCCESS
){
355 if(RegOpenKeyExW(key
, key_name
, 0, KEY_READ
, &dev_key
) == ERROR_SUCCESS
){
356 if(RegQueryValueExW(dev_key
, guidW
, 0, &type
,
357 (BYTE
*)guid
, &size
) == ERROR_SUCCESS
){
358 if(type
== REG_BINARY
){
359 RegCloseKey(dev_key
);
363 ERR("Invalid type for device %s GUID: %u; ignoring and overwriting\n",
364 wine_dbgstr_w(key_name
), type
);
366 RegCloseKey(dev_key
);
372 set_device_guid(flow
, key
, key_name
, guid
);
378 static const char *oss_clean_devnode(const char *devnode
)
380 static char ret
[OSS_DEVNODE_SIZE
];
382 const char *dot
, *slash
;
385 dot
= strrchr(devnode
, '.');
389 slash
= strrchr(devnode
, '/');
390 if(slash
&& dot
< slash
)
395 memcpy(ret
, devnode
, len
);
401 static UINT
get_default_index(EDataFlow flow
)
410 fd
= open("/dev/dsp", O_WRONLY
| O_NONBLOCK
);
412 fd
= open("/dev/dsp", O_RDONLY
| O_NONBLOCK
);
415 WARN("Couldn't open default device!\n");
420 if((err
= ioctl(fd
, SNDCTL_ENGINEINFO
, &ai
)) < 0){
421 WARN("SNDCTL_ENGINEINFO failed: %d (%s)\n", err
, strerror(errno
));
428 TRACE("Default devnode: %s\n", ai
.devnode
);
429 devnode
= oss_clean_devnode(ai
.devnode
);
431 LIST_FOR_EACH_ENTRY(dev_item
, &g_devices
, OSSDevice
, entry
){
432 if(dev_item
->flow
== flow
){
433 if(!strcmp(devnode
, dev_item
->devnode
))
439 WARN("Couldn't find default device! Choosing first.\n");
443 HRESULT WINAPI
AUDDRV_GetEndpointIDs(EDataFlow flow
, WCHAR
***ids
, GUID
**guids
,
444 UINT
*num
, UINT
*def_index
)
448 static int print_once
= 0;
450 static const WCHAR outW
[] = {'O','u','t',':',' ',0};
451 static const WCHAR inW
[] = {'I','n',':',' ',0};
453 TRACE("%d %p %p %p %p\n", flow
, ids
, guids
, num
, def_index
);
455 mixer_fd
= open("/dev/mixer", O_RDONLY
, 0);
457 ERR("OSS /dev/mixer doesn't seem to exist\n");
458 return AUDCLNT_E_SERVICE_NOT_RUNNING
;
461 if(ioctl(mixer_fd
, SNDCTL_SYSINFO
, &sysinfo
) < 0){
465 ERR("OSS version too old, need at least OSSv4\n");
466 return AUDCLNT_E_SERVICE_NOT_RUNNING
;
469 ERR("Error getting SNDCTL_SYSINFO: %d (%s)\n", errno
, strerror(errno
));
474 TRACE("OSS sysinfo:\n");
475 TRACE("product: %s\n", sysinfo
.product
);
476 TRACE("version: %s\n", sysinfo
.version
);
477 TRACE("versionnum: %x\n", sysinfo
.versionnum
);
478 TRACE("numaudios: %d\n", sysinfo
.numaudios
);
479 TRACE("nummixers: %d\n", sysinfo
.nummixers
);
480 TRACE("numcards: %d\n", sysinfo
.numcards
);
481 TRACE("numaudioengines: %d\n", sysinfo
.numaudioengines
);
485 if(sysinfo
.numaudios
<= 0){
486 WARN("No audio devices!\n");
488 return AUDCLNT_E_SERVICE_NOT_RUNNING
;
491 *ids
= HeapAlloc(GetProcessHeap(), 0, sysinfo
.numaudios
* sizeof(WCHAR
*));
492 *guids
= HeapAlloc(GetProcessHeap(), 0, sysinfo
.numaudios
* sizeof(GUID
));
495 for(i
= 0; i
< sysinfo
.numaudios
; ++i
){
496 oss_audioinfo ai
= {0};
502 if(ioctl(mixer_fd
, SNDCTL_AUDIOINFO
, &ai
) < 0){
503 WARN("Error getting AUDIOINFO for dev %d: %d (%s)\n", i
, errno
,
508 devnode
= oss_clean_devnode(ai
.devnode
);
510 /* check for duplicates */
511 LIST_FOR_EACH_ENTRY(dev_item
, &g_devices
, OSSDevice
, entry
){
512 if(dev_item
->flow
== flow
&& !strcmp(devnode
, dev_item
->devnode
))
515 if(&dev_item
->entry
!= &g_devices
)
519 fd
= open(devnode
, O_WRONLY
| O_NONBLOCK
, 0);
521 fd
= open(devnode
, O_RDONLY
| O_NONBLOCK
, 0);
523 WARN("Opening device \"%s\" failed, pretending it doesn't exist: %d (%s)\n",
524 devnode
, errno
, strerror(errno
));
529 if((flow
== eCapture
&& (ai
.caps
& PCM_CAP_INPUT
)) ||
530 (flow
== eRender
&& (ai
.caps
& PCM_CAP_OUTPUT
))){
531 size_t len
, prefix_len
;
534 dev_item
= HeapAlloc(GetProcessHeap(), 0, sizeof(*dev_item
));
536 dev_item
->flow
= flow
;
537 get_device_guid(flow
, devnode
, &dev_item
->guid
);
538 strcpy(dev_item
->devnode
, devnode
);
540 (*guids
)[*num
] = dev_item
->guid
;
542 len
= MultiByteToWideChar(CP_UNIXCP
, 0, ai
.name
, -1, NULL
, 0);
545 prefix_len
= ARRAY_SIZE(outW
) - 1;
549 prefix_len
= ARRAY_SIZE(inW
) - 1;
552 (*ids
)[*num
] = HeapAlloc(GetProcessHeap(), 0,
553 len
* sizeof(WCHAR
));
555 for(i
= 0; i
< *num
; ++i
)
556 HeapFree(GetProcessHeap(), 0, (*ids
)[i
]);
557 HeapFree(GetProcessHeap(), 0, *ids
);
558 HeapFree(GetProcessHeap(), 0, *guids
);
559 HeapFree(GetProcessHeap(), 0, dev_item
);
561 return E_OUTOFMEMORY
;
563 memcpy((*ids
)[*num
], prefix
, prefix_len
* sizeof(WCHAR
));
564 MultiByteToWideChar(CP_UNIXCP
, 0, ai
.name
, -1,
565 (*ids
)[*num
] + prefix_len
, len
- prefix_len
);
567 list_add_tail(&g_devices
, &dev_item
->entry
);
575 *def_index
= get_default_index(flow
);
580 static const OSSDevice
*get_ossdevice_from_guid(const GUID
*guid
)
583 LIST_FOR_EACH_ENTRY(dev_item
, &g_devices
, OSSDevice
, entry
)
584 if(IsEqualGUID(guid
, &dev_item
->guid
))
589 HRESULT WINAPI
AUDDRV_GetAudioEndpoint(GUID
*guid
, IMMDevice
*dev
,
593 const OSSDevice
*oss_dev
;
596 TRACE("%s %p %p\n", debugstr_guid(guid
), dev
, out
);
598 oss_dev
= get_ossdevice_from_guid(guid
);
600 WARN("Unknown GUID: %s\n", debugstr_guid(guid
));
601 return AUDCLNT_E_DEVICE_INVALIDATED
;
604 This
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(ACImpl
));
606 return E_OUTOFMEMORY
;
608 hr
= CoCreateFreeThreadedMarshaler((IUnknown
*)&This
->IAudioClient_iface
,
609 (IUnknown
**)&This
->pUnkFTMarshal
);
611 HeapFree(GetProcessHeap(), 0, This
);
615 if(oss_dev
->flow
== eRender
)
616 This
->fd
= open(oss_dev
->devnode
, O_WRONLY
| O_NONBLOCK
, 0);
617 else if(oss_dev
->flow
== eCapture
)
618 This
->fd
= open(oss_dev
->devnode
, O_RDONLY
| O_NONBLOCK
, 0);
620 HeapFree(GetProcessHeap(), 0, This
);
624 WARN("Unable to open device %s: %d (%s)\n", oss_dev
->devnode
, errno
,
626 HeapFree(GetProcessHeap(), 0, This
);
627 return AUDCLNT_E_DEVICE_INVALIDATED
;
630 This
->dataflow
= oss_dev
->flow
;
633 if(ioctl(This
->fd
, SNDCTL_ENGINEINFO
, &This
->ai
) < 0){
634 WARN("Unable to get audio info for device %s: %d (%s)\n", oss_dev
->devnode
,
635 errno
, strerror(errno
));
637 HeapFree(GetProcessHeap(), 0, This
);
641 strcpy(This
->devnode
, oss_dev
->devnode
);
643 TRACE("OSS audioinfo:\n");
644 TRACE("devnode: %s\n", This
->ai
.devnode
);
645 TRACE("name: %s\n", This
->ai
.name
);
646 TRACE("busy: %x\n", This
->ai
.busy
);
647 TRACE("caps: %x\n", This
->ai
.caps
);
648 TRACE("iformats: %x\n", This
->ai
.iformats
);
649 TRACE("oformats: %x\n", This
->ai
.oformats
);
650 TRACE("enabled: %d\n", This
->ai
.enabled
);
651 TRACE("min_rate: %d\n", This
->ai
.min_rate
);
652 TRACE("max_rate: %d\n", This
->ai
.max_rate
);
653 TRACE("min_channels: %d\n", This
->ai
.min_channels
);
654 TRACE("max_channels: %d\n", This
->ai
.max_channels
);
656 This
->IAudioClient_iface
.lpVtbl
= &AudioClient_Vtbl
;
657 This
->IAudioRenderClient_iface
.lpVtbl
= &AudioRenderClient_Vtbl
;
658 This
->IAudioCaptureClient_iface
.lpVtbl
= &AudioCaptureClient_Vtbl
;
659 This
->IAudioClock_iface
.lpVtbl
= &AudioClock_Vtbl
;
660 This
->IAudioClock2_iface
.lpVtbl
= &AudioClock2_Vtbl
;
661 This
->IAudioStreamVolume_iface
.lpVtbl
= &AudioStreamVolume_Vtbl
;
663 InitializeCriticalSection(&This
->lock
);
664 This
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": ACImpl.lock");
667 IMMDevice_AddRef(This
->parent
);
669 IAudioClient_AddRef(&This
->IAudioClient_iface
);
671 *out
= &This
->IAudioClient_iface
;
676 static HRESULT WINAPI
AudioClient_QueryInterface(IAudioClient
*iface
,
677 REFIID riid
, void **ppv
)
679 ACImpl
*This
= impl_from_IAudioClient(iface
);
680 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
685 if(IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IAudioClient
))
687 else if(IsEqualIID(riid
, &IID_IMarshal
))
688 return IUnknown_QueryInterface(This
->pUnkFTMarshal
, riid
, ppv
);
690 IUnknown_AddRef((IUnknown
*)*ppv
);
693 WARN("Unknown interface %s\n", debugstr_guid(riid
));
694 return E_NOINTERFACE
;
697 static ULONG WINAPI
AudioClient_AddRef(IAudioClient
*iface
)
699 ACImpl
*This
= impl_from_IAudioClient(iface
);
701 ref
= InterlockedIncrement(&This
->ref
);
702 TRACE("(%p) Refcount now %u\n", This
, ref
);
706 static ULONG WINAPI
AudioClient_Release(IAudioClient
*iface
)
708 ACImpl
*This
= impl_from_IAudioClient(iface
);
711 ref
= InterlockedDecrement(&This
->ref
);
712 TRACE("(%p) Refcount now %u\n", This
, ref
);
717 event
= CreateEventW(NULL
, TRUE
, FALSE
, NULL
);
718 wait
= !DeleteTimerQueueTimer(g_timer_q
, This
->timer
, event
);
719 wait
= wait
&& GetLastError() == ERROR_IO_PENDING
;
721 WaitForSingleObject(event
, INFINITE
);
725 IAudioClient_Stop(iface
);
726 IMMDevice_Release(This
->parent
);
727 IUnknown_Release(This
->pUnkFTMarshal
);
728 This
->lock
.DebugInfo
->Spare
[0] = 0;
729 DeleteCriticalSection(&This
->lock
);
732 EnterCriticalSection(&g_sessions_lock
);
733 list_remove(&This
->entry
);
734 LeaveCriticalSection(&g_sessions_lock
);
736 HeapFree(GetProcessHeap(), 0, This
->vols
);
737 HeapFree(GetProcessHeap(), 0, This
->local_buffer
);
738 HeapFree(GetProcessHeap(), 0, This
->tmp_buffer
);
739 CoTaskMemFree(This
->fmt
);
740 HeapFree(GetProcessHeap(), 0, This
);
745 static void dump_fmt(const WAVEFORMATEX
*fmt
)
747 TRACE("wFormatTag: 0x%x (", fmt
->wFormatTag
);
748 switch(fmt
->wFormatTag
){
749 case WAVE_FORMAT_PCM
:
750 TRACE("WAVE_FORMAT_PCM");
752 case WAVE_FORMAT_IEEE_FLOAT
:
753 TRACE("WAVE_FORMAT_IEEE_FLOAT");
755 case WAVE_FORMAT_EXTENSIBLE
:
756 TRACE("WAVE_FORMAT_EXTENSIBLE");
764 TRACE("nChannels: %u\n", fmt
->nChannels
);
765 TRACE("nSamplesPerSec: %u\n", fmt
->nSamplesPerSec
);
766 TRACE("nAvgBytesPerSec: %u\n", fmt
->nAvgBytesPerSec
);
767 TRACE("nBlockAlign: %u\n", fmt
->nBlockAlign
);
768 TRACE("wBitsPerSample: %u\n", fmt
->wBitsPerSample
);
769 TRACE("cbSize: %u\n", fmt
->cbSize
);
771 if(fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
){
772 WAVEFORMATEXTENSIBLE
*fmtex
= (void*)fmt
;
773 TRACE("dwChannelMask: %08x\n", fmtex
->dwChannelMask
);
774 TRACE("Samples: %04x\n", fmtex
->Samples
.wReserved
);
775 TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex
->SubFormat
));
779 static DWORD
get_channel_mask(unsigned int channels
)
785 return KSAUDIO_SPEAKER_MONO
;
787 return KSAUDIO_SPEAKER_STEREO
;
789 return KSAUDIO_SPEAKER_STEREO
| SPEAKER_LOW_FREQUENCY
;
791 return KSAUDIO_SPEAKER_QUAD
; /* not _SURROUND */
793 return KSAUDIO_SPEAKER_QUAD
| SPEAKER_LOW_FREQUENCY
;
795 return KSAUDIO_SPEAKER_5POINT1
; /* not 5POINT1_SURROUND */
797 return KSAUDIO_SPEAKER_5POINT1
| SPEAKER_BACK_CENTER
;
799 return KSAUDIO_SPEAKER_7POINT1_SURROUND
; /* Vista deprecates 7POINT1 */
801 FIXME("Unknown speaker configuration: %u\n", channels
);
805 static int get_oss_format(const WAVEFORMATEX
*fmt
)
807 WAVEFORMATEXTENSIBLE
*fmtex
= (WAVEFORMATEXTENSIBLE
*)fmt
;
809 if(fmt
->wFormatTag
== WAVE_FORMAT_PCM
||
810 (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
811 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
))){
812 switch(fmt
->wBitsPerSample
){
826 if(fmt
->wFormatTag
== WAVE_FORMAT_IEEE_FLOAT
||
827 (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
828 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
))){
829 if(fmt
->wBitsPerSample
!= 32)
839 static WAVEFORMATEX
*clone_format(const WAVEFORMATEX
*fmt
)
844 if(fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
)
845 size
= sizeof(WAVEFORMATEXTENSIBLE
);
847 size
= sizeof(WAVEFORMATEX
);
849 ret
= CoTaskMemAlloc(size
);
853 memcpy(ret
, fmt
, size
);
855 ret
->cbSize
= size
- sizeof(WAVEFORMATEX
);
860 static HRESULT
setup_oss_device(AUDCLNT_SHAREMODE mode
, int fd
,
861 const WAVEFORMATEX
*fmt
, WAVEFORMATEX
**out
)
866 WAVEFORMATEX
*closest
= NULL
;
868 tmp
= oss_format
= get_oss_format(fmt
);
870 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
871 if(ioctl(fd
, SNDCTL_DSP_SETFMT
, &tmp
) < 0){
872 WARN("SETFMT failed: %d (%s)\n", errno
, strerror(errno
));
875 if(tmp
!= oss_format
){
876 TRACE("Format unsupported by this OSS version: %x\n", oss_format
);
877 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
880 if(fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
881 (fmt
->nAvgBytesPerSec
== 0 ||
882 fmt
->nBlockAlign
== 0 ||
883 ((WAVEFORMATEXTENSIBLE
*)fmt
)->Samples
.wValidBitsPerSample
> fmt
->wBitsPerSample
))
886 if(fmt
->nChannels
== 0)
887 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
889 closest
= clone_format(fmt
);
891 return E_OUTOFMEMORY
;
893 tmp
= fmt
->nSamplesPerSec
;
894 if(ioctl(fd
, SNDCTL_DSP_SPEED
, &tmp
) < 0){
895 WARN("SPEED failed: %d (%s)\n", errno
, strerror(errno
));
896 CoTaskMemFree(closest
);
899 tenth
= fmt
->nSamplesPerSec
* 0.1;
900 if(tmp
> fmt
->nSamplesPerSec
+ tenth
|| tmp
< fmt
->nSamplesPerSec
- tenth
){
902 closest
->nSamplesPerSec
= tmp
;
905 tmp
= fmt
->nChannels
;
906 if(ioctl(fd
, SNDCTL_DSP_CHANNELS
, &tmp
) < 0){
907 WARN("CHANNELS failed: %d (%s)\n", errno
, strerror(errno
));
908 CoTaskMemFree(closest
);
911 if(tmp
!= fmt
->nChannels
){
913 closest
->nChannels
= tmp
;
916 if(closest
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
)
917 ((WAVEFORMATEXTENSIBLE
*)closest
)->dwChannelMask
= get_channel_mask(closest
->nChannels
);
919 if(fmt
->nBlockAlign
!= fmt
->nChannels
* fmt
->wBitsPerSample
/ 8 ||
920 fmt
->nAvgBytesPerSec
!= fmt
->nBlockAlign
* fmt
->nSamplesPerSec
||
921 (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
922 ((WAVEFORMATEXTENSIBLE
*)fmt
)->Samples
.wValidBitsPerSample
< fmt
->wBitsPerSample
))
925 if(mode
== AUDCLNT_SHAREMODE_EXCLUSIVE
&&
926 fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
){
927 if(((WAVEFORMATEXTENSIBLE
*)fmt
)->dwChannelMask
== 0 ||
928 ((WAVEFORMATEXTENSIBLE
*)fmt
)->dwChannelMask
& SPEAKER_RESERVED
)
932 if(ret
== S_FALSE
&& !out
)
933 ret
= AUDCLNT_E_UNSUPPORTED_FORMAT
;
935 if(ret
== S_FALSE
&& out
){
936 closest
->nBlockAlign
=
937 closest
->nChannels
* closest
->wBitsPerSample
/ 8;
938 closest
->nAvgBytesPerSec
=
939 closest
->nBlockAlign
* closest
->nSamplesPerSec
;
940 if(closest
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
)
941 ((WAVEFORMATEXTENSIBLE
*)closest
)->Samples
.wValidBitsPerSample
= closest
->wBitsPerSample
;
944 CoTaskMemFree(closest
);
946 TRACE("returning: %08x\n", ret
);
950 static void session_init_vols(AudioSession
*session
, UINT channels
)
952 if(session
->channel_count
< channels
){
955 if(session
->channel_vols
)
956 session
->channel_vols
= HeapReAlloc(GetProcessHeap(), 0,
957 session
->channel_vols
, sizeof(float) * channels
);
959 session
->channel_vols
= HeapAlloc(GetProcessHeap(), 0,
960 sizeof(float) * channels
);
961 if(!session
->channel_vols
)
964 for(i
= session
->channel_count
; i
< channels
; ++i
)
965 session
->channel_vols
[i
] = 1.f
;
967 session
->channel_count
= channels
;
971 static AudioSession
*create_session(const GUID
*guid
, IMMDevice
*device
,
976 ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(AudioSession
));
980 memcpy(&ret
->guid
, guid
, sizeof(GUID
));
982 ret
->device
= device
;
984 list_init(&ret
->clients
);
986 list_add_head(&g_sessions
, &ret
->entry
);
988 InitializeCriticalSection(&ret
->lock
);
989 ret
->lock
.DebugInfo
->Spare
[0] = (DWORD_PTR
)(__FILE__
": AudioSession.lock");
991 session_init_vols(ret
, num_channels
);
993 ret
->master_vol
= 1.f
;
998 /* if channels == 0, then this will return or create a session with
999 * matching dataflow and GUID. otherwise, channels must also match */
1000 static HRESULT
get_audio_session(const GUID
*sessionguid
,
1001 IMMDevice
*device
, UINT channels
, AudioSession
**out
)
1003 AudioSession
*session
;
1005 if(!sessionguid
|| IsEqualGUID(sessionguid
, &GUID_NULL
)){
1006 *out
= create_session(&GUID_NULL
, device
, channels
);
1008 return E_OUTOFMEMORY
;
1014 LIST_FOR_EACH_ENTRY(session
, &g_sessions
, AudioSession
, entry
){
1015 if(session
->device
== device
&&
1016 IsEqualGUID(sessionguid
, &session
->guid
)){
1017 session_init_vols(session
, channels
);
1024 *out
= create_session(sessionguid
, device
, channels
);
1026 return E_OUTOFMEMORY
;
1032 static HRESULT WINAPI
AudioClient_Initialize(IAudioClient
*iface
,
1033 AUDCLNT_SHAREMODE mode
, DWORD flags
, REFERENCE_TIME duration
,
1034 REFERENCE_TIME period
, const WAVEFORMATEX
*fmt
,
1035 const GUID
*sessionguid
)
1037 ACImpl
*This
= impl_from_IAudioClient(iface
);
1041 TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This
, mode
, flags
,
1042 wine_dbgstr_longlong(duration
), wine_dbgstr_longlong(period
), fmt
, debugstr_guid(sessionguid
));
1049 if(mode
!= AUDCLNT_SHAREMODE_SHARED
&& mode
!= AUDCLNT_SHAREMODE_EXCLUSIVE
)
1050 return AUDCLNT_E_NOT_INITIALIZED
;
1052 if(flags
& ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS
|
1053 AUDCLNT_STREAMFLAGS_LOOPBACK
|
1054 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
|
1055 AUDCLNT_STREAMFLAGS_NOPERSIST
|
1056 AUDCLNT_STREAMFLAGS_RATEADJUST
|
1057 AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED
|
1058 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE
|
1059 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED
)){
1060 TRACE("Unknown flags: %08x\n", flags
);
1061 return E_INVALIDARG
;
1064 if(mode
== AUDCLNT_SHAREMODE_SHARED
){
1065 period
= DefaultPeriod
;
1066 if( duration
< 3 * period
)
1067 duration
= 3 * period
;
1070 period
= DefaultPeriod
; /* not minimum */
1071 if(period
< MinimumPeriod
|| period
> 5000000)
1072 return AUDCLNT_E_INVALID_DEVICE_PERIOD
;
1073 if(duration
> 20000000) /* the smaller the period, the lower this limit */
1074 return AUDCLNT_E_BUFFER_SIZE_ERROR
;
1075 if(flags
& AUDCLNT_STREAMFLAGS_EVENTCALLBACK
){
1076 if(duration
!= period
)
1077 return AUDCLNT_E_BUFDURATION_PERIOD_NOT_EQUAL
;
1078 FIXME("EXCLUSIVE mode with EVENTCALLBACK\n");
1079 return AUDCLNT_E_DEVICE_IN_USE
;
1081 if( duration
< 8 * period
)
1082 duration
= 8 * period
; /* may grow above 2s */
1086 EnterCriticalSection(&This
->lock
);
1089 LeaveCriticalSection(&This
->lock
);
1090 return AUDCLNT_E_ALREADY_INITIALIZED
;
1093 hr
= setup_oss_device(mode
, This
->fd
, fmt
, NULL
);
1095 LeaveCriticalSection(&This
->lock
);
1099 This
->fmt
= clone_format(fmt
);
1101 LeaveCriticalSection(&This
->lock
);
1102 return E_OUTOFMEMORY
;
1105 This
->period_us
= period
/ 10;
1106 This
->period_frames
= MulDiv(fmt
->nSamplesPerSec
, period
, 10000000);
1108 This
->bufsize_frames
= MulDiv(duration
, fmt
->nSamplesPerSec
, 10000000);
1109 if(mode
== AUDCLNT_SHAREMODE_EXCLUSIVE
)
1110 This
->bufsize_frames
-= This
->bufsize_frames
% This
->period_frames
;
1111 This
->local_buffer
= HeapAlloc(GetProcessHeap(), 0,
1112 This
->bufsize_frames
* fmt
->nBlockAlign
);
1113 if(!This
->local_buffer
){
1114 CoTaskMemFree(This
->fmt
);
1116 LeaveCriticalSection(&This
->lock
);
1117 return E_OUTOFMEMORY
;
1120 This
->vols
= HeapAlloc(GetProcessHeap(), 0, fmt
->nChannels
* sizeof(float));
1122 CoTaskMemFree(This
->fmt
);
1124 LeaveCriticalSection(&This
->lock
);
1125 return E_OUTOFMEMORY
;
1128 for(i
= 0; i
< fmt
->nChannels
; ++i
)
1129 This
->vols
[i
] = 1.f
;
1132 This
->flags
= flags
;
1133 This
->oss_bufsize_bytes
= 0;
1135 EnterCriticalSection(&g_sessions_lock
);
1137 hr
= get_audio_session(sessionguid
, This
->parent
, fmt
->nChannels
,
1140 LeaveCriticalSection(&g_sessions_lock
);
1141 HeapFree(GetProcessHeap(), 0, This
->vols
);
1143 CoTaskMemFree(This
->fmt
);
1145 LeaveCriticalSection(&This
->lock
);
1149 list_add_tail(&This
->session
->clients
, &This
->entry
);
1151 LeaveCriticalSection(&g_sessions_lock
);
1153 This
->initted
= TRUE
;
1155 LeaveCriticalSection(&This
->lock
);
1160 static HRESULT WINAPI
AudioClient_GetBufferSize(IAudioClient
*iface
,
1163 ACImpl
*This
= impl_from_IAudioClient(iface
);
1165 TRACE("(%p)->(%p)\n", This
, frames
);
1170 EnterCriticalSection(&This
->lock
);
1173 LeaveCriticalSection(&This
->lock
);
1174 return AUDCLNT_E_NOT_INITIALIZED
;
1177 *frames
= This
->bufsize_frames
;
1179 TRACE("buffer size: %u\n", *frames
);
1181 LeaveCriticalSection(&This
->lock
);
1186 static HRESULT WINAPI
AudioClient_GetStreamLatency(IAudioClient
*iface
,
1187 REFERENCE_TIME
*latency
)
1189 ACImpl
*This
= impl_from_IAudioClient(iface
);
1191 TRACE("(%p)->(%p)\n", This
, latency
);
1196 EnterCriticalSection(&This
->lock
);
1199 LeaveCriticalSection(&This
->lock
);
1200 return AUDCLNT_E_NOT_INITIALIZED
;
1203 /* pretend we process audio in Period chunks, so max latency includes
1204 * the period time. Some native machines add .6666ms in shared mode. */
1205 *latency
= (REFERENCE_TIME
)This
->period_us
* 10 + 6666;
1207 LeaveCriticalSection(&This
->lock
);
1212 static HRESULT WINAPI
AudioClient_GetCurrentPadding(IAudioClient
*iface
,
1215 ACImpl
*This
= impl_from_IAudioClient(iface
);
1217 TRACE("(%p)->(%p)\n", This
, numpad
);
1222 EnterCriticalSection(&This
->lock
);
1225 LeaveCriticalSection(&This
->lock
);
1226 return AUDCLNT_E_NOT_INITIALIZED
;
1229 *numpad
= This
->held_frames
;
1231 TRACE("padding: %u\n", *numpad
);
1233 LeaveCriticalSection(&This
->lock
);
1238 static HRESULT WINAPI
AudioClient_IsFormatSupported(IAudioClient
*iface
,
1239 AUDCLNT_SHAREMODE mode
, const WAVEFORMATEX
*pwfx
,
1240 WAVEFORMATEX
**outpwfx
)
1242 ACImpl
*This
= impl_from_IAudioClient(iface
);
1246 TRACE("(%p)->(%x, %p, %p)\n", This
, mode
, pwfx
, outpwfx
);
1248 if(!pwfx
|| (mode
== AUDCLNT_SHAREMODE_SHARED
&& !outpwfx
))
1251 if(mode
!= AUDCLNT_SHAREMODE_SHARED
&& mode
!= AUDCLNT_SHAREMODE_EXCLUSIVE
)
1252 return E_INVALIDARG
;
1254 if(pwfx
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
1255 pwfx
->cbSize
< sizeof(WAVEFORMATEXTENSIBLE
) - sizeof(WAVEFORMATEX
))
1256 return E_INVALIDARG
;
1262 if(mode
!= AUDCLNT_SHAREMODE_SHARED
)
1266 if(This
->dataflow
== eRender
)
1267 fd
= open(This
->devnode
, O_WRONLY
| O_NONBLOCK
, 0);
1268 else if(This
->dataflow
== eCapture
)
1269 fd
= open(This
->devnode
, O_RDONLY
| O_NONBLOCK
, 0);
1272 WARN("Unable to open device %s: %d (%s)\n", This
->devnode
, errno
,
1274 return AUDCLNT_E_DEVICE_INVALIDATED
;
1277 ret
= setup_oss_device(mode
, fd
, pwfx
, outpwfx
);
1284 static HRESULT WINAPI
AudioClient_GetMixFormat(IAudioClient
*iface
,
1285 WAVEFORMATEX
**pwfx
)
1287 ACImpl
*This
= impl_from_IAudioClient(iface
);
1288 WAVEFORMATEXTENSIBLE
*fmt
;
1291 TRACE("(%p)->(%p)\n", This
, pwfx
);
1297 if(This
->dataflow
== eRender
)
1298 formats
= This
->ai
.oformats
;
1299 else if(This
->dataflow
== eCapture
)
1300 formats
= This
->ai
.iformats
;
1302 return E_UNEXPECTED
;
1304 fmt
= CoTaskMemAlloc(sizeof(WAVEFORMATEXTENSIBLE
));
1306 return E_OUTOFMEMORY
;
1308 fmt
->Format
.wFormatTag
= WAVE_FORMAT_EXTENSIBLE
;
1309 if(formats
& AFMT_S16_LE
){
1310 fmt
->Format
.wBitsPerSample
= 16;
1311 fmt
->SubFormat
= KSDATAFORMAT_SUBTYPE_PCM
;
1313 }else if(formats
& AFMT_FLOAT
){
1314 fmt
->Format
.wBitsPerSample
= 32;
1315 fmt
->SubFormat
= KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
;
1317 }else if(formats
& AFMT_U8
){
1318 fmt
->Format
.wBitsPerSample
= 8;
1319 fmt
->SubFormat
= KSDATAFORMAT_SUBTYPE_PCM
;
1320 }else if(formats
& AFMT_S32_LE
){
1321 fmt
->Format
.wBitsPerSample
= 32;
1322 fmt
->SubFormat
= KSDATAFORMAT_SUBTYPE_PCM
;
1323 }else if(formats
& AFMT_S24_LE
){
1324 fmt
->Format
.wBitsPerSample
= 24;
1325 fmt
->SubFormat
= KSDATAFORMAT_SUBTYPE_PCM
;
1327 WARN("Didn't recognize any available OSS formats: %x\n", formats
);
1332 /* some OSS drivers are buggy, so set reasonable defaults if
1333 * the reported values seem wacky */
1334 fmt
->Format
.nChannels
= max(This
->ai
.max_channels
, This
->ai
.min_channels
);
1335 if(fmt
->Format
.nChannels
== 0 || fmt
->Format
.nChannels
> 8)
1336 fmt
->Format
.nChannels
= 2;
1338 if(This
->ai
.max_rate
== 0)
1339 fmt
->Format
.nSamplesPerSec
= 44100;
1341 fmt
->Format
.nSamplesPerSec
= min(This
->ai
.max_rate
, 44100);
1342 if(fmt
->Format
.nSamplesPerSec
< This
->ai
.min_rate
)
1343 fmt
->Format
.nSamplesPerSec
= This
->ai
.min_rate
;
1345 fmt
->dwChannelMask
= get_channel_mask(fmt
->Format
.nChannels
);
1347 fmt
->Format
.nBlockAlign
= (fmt
->Format
.wBitsPerSample
*
1348 fmt
->Format
.nChannels
) / 8;
1349 fmt
->Format
.nAvgBytesPerSec
= fmt
->Format
.nSamplesPerSec
*
1350 fmt
->Format
.nBlockAlign
;
1352 fmt
->Samples
.wValidBitsPerSample
= fmt
->Format
.wBitsPerSample
;
1353 fmt
->Format
.cbSize
= sizeof(WAVEFORMATEXTENSIBLE
) - sizeof(WAVEFORMATEX
);
1355 *pwfx
= (WAVEFORMATEX
*)fmt
;
1361 static HRESULT WINAPI
AudioClient_GetDevicePeriod(IAudioClient
*iface
,
1362 REFERENCE_TIME
*defperiod
, REFERENCE_TIME
*minperiod
)
1364 ACImpl
*This
= impl_from_IAudioClient(iface
);
1366 TRACE("(%p)->(%p, %p)\n", This
, defperiod
, minperiod
);
1368 if(!defperiod
&& !minperiod
)
1372 *defperiod
= DefaultPeriod
;
1374 *minperiod
= MinimumPeriod
;
1379 static void silence_buffer(ACImpl
*This
, BYTE
*buffer
, UINT32 frames
)
1381 WAVEFORMATEXTENSIBLE
*fmtex
= (WAVEFORMATEXTENSIBLE
*)This
->fmt
;
1382 if((This
->fmt
->wFormatTag
== WAVE_FORMAT_PCM
||
1383 (This
->fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
&&
1384 IsEqualGUID(&fmtex
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
))) &&
1385 This
->fmt
->wBitsPerSample
== 8)
1386 memset(buffer
, 128, frames
* This
->fmt
->nBlockAlign
);
1388 memset(buffer
, 0, frames
* This
->fmt
->nBlockAlign
);
1391 static void oss_write_data(ACImpl
*This
)
1393 ssize_t written_bytes
;
1394 UINT32 written_frames
, in_oss_frames
, write_limit
, max_period
, write_offs_frames
, new_frames
;
1395 SIZE_T to_write_frames
, to_write_bytes
, advanced
;
1399 if(ioctl(This
->fd
, SNDCTL_DSP_GETOSPACE
, &bi
) < 0){
1400 WARN("GETOSPACE failed: %d (%s)\n", errno
, strerror(errno
));
1404 max_period
= max(bi
.fragsize
/ This
->fmt
->nBlockAlign
, This
->period_frames
);
1406 if(bi
.bytes
> This
->oss_bufsize_bytes
){
1407 TRACE("New buffer size (%u) is larger than old buffer size (%u)\n",
1408 bi
.bytes
, This
->oss_bufsize_bytes
);
1409 This
->oss_bufsize_bytes
= bi
.bytes
;
1412 in_oss_frames
= (This
->oss_bufsize_bytes
- bi
.bytes
) / This
->fmt
->nBlockAlign
;
1414 if(in_oss_frames
> This
->in_oss_frames
){
1415 TRACE("Capping reported frames from %u to %u\n",
1416 in_oss_frames
, This
->in_oss_frames
);
1417 in_oss_frames
= This
->in_oss_frames
;
1421 while(write_limit
+ in_oss_frames
< max_period
* 3)
1422 write_limit
+= max_period
;
1423 if(write_limit
== 0)
1426 /* vvvvvv - in_oss_frames
1429 * ^^^^^^^^^^ - held_frames
1430 * ^ - lcl_offs_frames
1432 advanced
= This
->in_oss_frames
- in_oss_frames
;
1433 if(advanced
> This
->held_frames
)
1434 advanced
= This
->held_frames
;
1435 This
->lcl_offs_frames
+= advanced
;
1436 This
->lcl_offs_frames
%= This
->bufsize_frames
;
1437 This
->held_frames
-= advanced
;
1438 This
->in_oss_frames
= in_oss_frames
;
1439 TRACE("advanced by %lu, lcl_offs: %u, held: %u, in_oss: %u\n",
1440 advanced
, This
->lcl_offs_frames
, This
->held_frames
, This
->in_oss_frames
);
1443 if(This
->held_frames
== This
->in_oss_frames
)
1446 write_offs_frames
= (This
->lcl_offs_frames
+ This
->in_oss_frames
) % This
->bufsize_frames
;
1447 new_frames
= This
->held_frames
- This
->in_oss_frames
;
1449 if(write_offs_frames
+ new_frames
> This
->bufsize_frames
)
1450 to_write_frames
= This
->bufsize_frames
- write_offs_frames
;
1452 to_write_frames
= new_frames
;
1454 to_write_frames
= min(to_write_frames
, write_limit
);
1455 to_write_bytes
= to_write_frames
* This
->fmt
->nBlockAlign
;
1456 TRACE("going to write %lu frames from %u (%lu of %u)\n", to_write_frames
,
1457 write_offs_frames
, to_write_frames
+ write_offs_frames
,
1458 This
->bufsize_frames
);
1460 buf
= This
->local_buffer
+ write_offs_frames
* This
->fmt
->nBlockAlign
;
1462 if(This
->session
->mute
)
1463 silence_buffer(This
, buf
, to_write_frames
);
1465 written_bytes
= write(This
->fd
, buf
, to_write_bytes
);
1466 if(written_bytes
< 0){
1467 /* EAGAIN is OSS buffer full, log that too */
1468 WARN("write failed: %d (%s)\n", errno
, strerror(errno
));
1471 written_frames
= written_bytes
/ This
->fmt
->nBlockAlign
;
1473 This
->in_oss_frames
+= written_frames
;
1475 if(written_frames
< to_write_frames
){
1476 /* OSS buffer probably full */
1480 if(new_frames
> written_frames
&& written_frames
< write_limit
){
1481 /* wrapped and have some data back at the start to write */
1483 to_write_frames
= min(write_limit
- written_frames
, new_frames
- written_frames
);
1484 to_write_bytes
= to_write_frames
* This
->fmt
->nBlockAlign
;
1486 if(This
->session
->mute
)
1487 silence_buffer(This
, This
->local_buffer
, to_write_frames
);
1489 TRACE("wrapping to write %lu frames from beginning\n", to_write_frames
);
1491 written_bytes
= write(This
->fd
, This
->local_buffer
, to_write_bytes
);
1492 if(written_bytes
< 0){
1493 WARN("write failed: %d (%s)\n", errno
, strerror(errno
));
1496 written_frames
= written_bytes
/ This
->fmt
->nBlockAlign
;
1497 This
->in_oss_frames
+= written_frames
;
1501 static void oss_read_data(ACImpl
*This
)
1503 UINT64 pos
, readable
;
1506 pos
= (This
->held_frames
+ This
->lcl_offs_frames
) % This
->bufsize_frames
;
1507 readable
= (This
->bufsize_frames
- pos
) * This
->fmt
->nBlockAlign
;
1509 nread
= read(This
->fd
, This
->local_buffer
+ pos
* This
->fmt
->nBlockAlign
,
1512 WARN("read failed: %d (%s)\n", errno
, strerror(errno
));
1516 This
->held_frames
+= nread
/ This
->fmt
->nBlockAlign
;
1518 if(This
->held_frames
> This
->bufsize_frames
){
1519 WARN("Overflow of unread data\n");
1520 This
->lcl_offs_frames
+= This
->held_frames
;
1521 This
->lcl_offs_frames
%= This
->bufsize_frames
;
1522 This
->held_frames
= This
->bufsize_frames
;
1526 static void CALLBACK
oss_period_callback(void *user
, BOOLEAN timer
)
1528 ACImpl
*This
= user
;
1530 EnterCriticalSection(&This
->lock
);
1533 if(This
->dataflow
== eRender
&& This
->held_frames
)
1534 oss_write_data(This
);
1535 else if(This
->dataflow
== eCapture
)
1536 oss_read_data(This
);
1539 LeaveCriticalSection(&This
->lock
);
1542 SetEvent(This
->event
);
1545 static HRESULT WINAPI
AudioClient_Start(IAudioClient
*iface
)
1547 ACImpl
*This
= impl_from_IAudioClient(iface
);
1549 TRACE("(%p)\n", This
);
1551 EnterCriticalSection(&This
->lock
);
1554 LeaveCriticalSection(&This
->lock
);
1555 return AUDCLNT_E_NOT_INITIALIZED
;
1558 if((This
->flags
& AUDCLNT_STREAMFLAGS_EVENTCALLBACK
) && !This
->event
){
1559 LeaveCriticalSection(&This
->lock
);
1560 return AUDCLNT_E_EVENTHANDLE_NOT_SET
;
1564 LeaveCriticalSection(&This
->lock
);
1565 return AUDCLNT_E_NOT_STOPPED
;
1569 if(!CreateTimerQueueTimer(&This
->timer
, g_timer_q
,
1570 oss_period_callback
, This
, 0, This
->period_us
/ 1000,
1571 WT_EXECUTEINTIMERTHREAD
))
1572 ERR("Unable to create period timer: %u\n", GetLastError());
1575 This
->playing
= TRUE
;
1577 LeaveCriticalSection(&This
->lock
);
1582 static HRESULT WINAPI
AudioClient_Stop(IAudioClient
*iface
)
1584 ACImpl
*This
= impl_from_IAudioClient(iface
);
1586 TRACE("(%p)\n", This
);
1588 EnterCriticalSection(&This
->lock
);
1591 LeaveCriticalSection(&This
->lock
);
1592 return AUDCLNT_E_NOT_INITIALIZED
;
1596 LeaveCriticalSection(&This
->lock
);
1600 This
->playing
= FALSE
;
1601 This
->in_oss_frames
= 0;
1603 LeaveCriticalSection(&This
->lock
);
1608 static HRESULT WINAPI
AudioClient_Reset(IAudioClient
*iface
)
1610 ACImpl
*This
= impl_from_IAudioClient(iface
);
1612 TRACE("(%p)\n", This
);
1614 EnterCriticalSection(&This
->lock
);
1617 LeaveCriticalSection(&This
->lock
);
1618 return AUDCLNT_E_NOT_INITIALIZED
;
1622 LeaveCriticalSection(&This
->lock
);
1623 return AUDCLNT_E_NOT_STOPPED
;
1626 if(This
->getbuf_last
){
1627 LeaveCriticalSection(&This
->lock
);
1628 return AUDCLNT_E_BUFFER_OPERATION_PENDING
;
1631 if(This
->dataflow
== eRender
){
1632 This
->written_frames
= 0;
1633 This
->last_pos_frames
= 0;
1635 This
->written_frames
+= This
->held_frames
;
1637 This
->held_frames
= 0;
1638 This
->lcl_offs_frames
= 0;
1639 This
->in_oss_frames
= 0;
1641 LeaveCriticalSection(&This
->lock
);
1646 static HRESULT WINAPI
AudioClient_SetEventHandle(IAudioClient
*iface
,
1649 ACImpl
*This
= impl_from_IAudioClient(iface
);
1651 TRACE("(%p)->(%p)\n", This
, event
);
1654 return E_INVALIDARG
;
1656 EnterCriticalSection(&This
->lock
);
1659 LeaveCriticalSection(&This
->lock
);
1660 return AUDCLNT_E_NOT_INITIALIZED
;
1663 if(!(This
->flags
& AUDCLNT_STREAMFLAGS_EVENTCALLBACK
)){
1664 LeaveCriticalSection(&This
->lock
);
1665 return AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED
;
1669 LeaveCriticalSection(&This
->lock
);
1670 FIXME("called twice\n");
1671 return HRESULT_FROM_WIN32(ERROR_INVALID_NAME
);
1674 This
->event
= event
;
1676 LeaveCriticalSection(&This
->lock
);
1681 static HRESULT WINAPI
AudioClient_GetService(IAudioClient
*iface
, REFIID riid
,
1684 ACImpl
*This
= impl_from_IAudioClient(iface
);
1686 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), ppv
);
1692 EnterCriticalSection(&This
->lock
);
1695 LeaveCriticalSection(&This
->lock
);
1696 return AUDCLNT_E_NOT_INITIALIZED
;
1699 if(IsEqualIID(riid
, &IID_IAudioRenderClient
)){
1700 if(This
->dataflow
!= eRender
){
1701 LeaveCriticalSection(&This
->lock
);
1702 return AUDCLNT_E_WRONG_ENDPOINT_TYPE
;
1704 IAudioRenderClient_AddRef(&This
->IAudioRenderClient_iface
);
1705 *ppv
= &This
->IAudioRenderClient_iface
;
1706 }else if(IsEqualIID(riid
, &IID_IAudioCaptureClient
)){
1707 if(This
->dataflow
!= eCapture
){
1708 LeaveCriticalSection(&This
->lock
);
1709 return AUDCLNT_E_WRONG_ENDPOINT_TYPE
;
1711 IAudioCaptureClient_AddRef(&This
->IAudioCaptureClient_iface
);
1712 *ppv
= &This
->IAudioCaptureClient_iface
;
1713 }else if(IsEqualIID(riid
, &IID_IAudioClock
)){
1714 IAudioClock_AddRef(&This
->IAudioClock_iface
);
1715 *ppv
= &This
->IAudioClock_iface
;
1716 }else if(IsEqualIID(riid
, &IID_IAudioStreamVolume
)){
1717 IAudioStreamVolume_AddRef(&This
->IAudioStreamVolume_iface
);
1718 *ppv
= &This
->IAudioStreamVolume_iface
;
1719 }else if(IsEqualIID(riid
, &IID_IAudioSessionControl
)){
1720 if(!This
->session_wrapper
){
1721 This
->session_wrapper
= AudioSessionWrapper_Create(This
);
1722 if(!This
->session_wrapper
){
1723 LeaveCriticalSection(&This
->lock
);
1724 return E_OUTOFMEMORY
;
1727 IAudioSessionControl2_AddRef(&This
->session_wrapper
->IAudioSessionControl2_iface
);
1729 *ppv
= &This
->session_wrapper
->IAudioSessionControl2_iface
;
1730 }else if(IsEqualIID(riid
, &IID_IChannelAudioVolume
)){
1731 if(!This
->session_wrapper
){
1732 This
->session_wrapper
= AudioSessionWrapper_Create(This
);
1733 if(!This
->session_wrapper
){
1734 LeaveCriticalSection(&This
->lock
);
1735 return E_OUTOFMEMORY
;
1738 IChannelAudioVolume_AddRef(&This
->session_wrapper
->IChannelAudioVolume_iface
);
1740 *ppv
= &This
->session_wrapper
->IChannelAudioVolume_iface
;
1741 }else if(IsEqualIID(riid
, &IID_ISimpleAudioVolume
)){
1742 if(!This
->session_wrapper
){
1743 This
->session_wrapper
= AudioSessionWrapper_Create(This
);
1744 if(!This
->session_wrapper
){
1745 LeaveCriticalSection(&This
->lock
);
1746 return E_OUTOFMEMORY
;
1749 ISimpleAudioVolume_AddRef(&This
->session_wrapper
->ISimpleAudioVolume_iface
);
1751 *ppv
= &This
->session_wrapper
->ISimpleAudioVolume_iface
;
1755 LeaveCriticalSection(&This
->lock
);
1759 LeaveCriticalSection(&This
->lock
);
1761 FIXME("stub %s\n", debugstr_guid(riid
));
1762 return E_NOINTERFACE
;
1765 static const IAudioClientVtbl AudioClient_Vtbl
=
1767 AudioClient_QueryInterface
,
1769 AudioClient_Release
,
1770 AudioClient_Initialize
,
1771 AudioClient_GetBufferSize
,
1772 AudioClient_GetStreamLatency
,
1773 AudioClient_GetCurrentPadding
,
1774 AudioClient_IsFormatSupported
,
1775 AudioClient_GetMixFormat
,
1776 AudioClient_GetDevicePeriod
,
1780 AudioClient_SetEventHandle
,
1781 AudioClient_GetService
1784 static HRESULT WINAPI
AudioRenderClient_QueryInterface(
1785 IAudioRenderClient
*iface
, REFIID riid
, void **ppv
)
1787 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1788 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
1794 if(IsEqualIID(riid
, &IID_IUnknown
) ||
1795 IsEqualIID(riid
, &IID_IAudioRenderClient
))
1797 else if(IsEqualIID(riid
, &IID_IMarshal
))
1798 return IUnknown_QueryInterface(This
->pUnkFTMarshal
, riid
, ppv
);
1800 IUnknown_AddRef((IUnknown
*)*ppv
);
1804 WARN("Unknown interface %s\n", debugstr_guid(riid
));
1805 return E_NOINTERFACE
;
1808 static ULONG WINAPI
AudioRenderClient_AddRef(IAudioRenderClient
*iface
)
1810 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1811 return AudioClient_AddRef(&This
->IAudioClient_iface
);
1814 static ULONG WINAPI
AudioRenderClient_Release(IAudioRenderClient
*iface
)
1816 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1817 return AudioClient_Release(&This
->IAudioClient_iface
);
1820 static HRESULT WINAPI
AudioRenderClient_GetBuffer(IAudioRenderClient
*iface
,
1821 UINT32 frames
, BYTE
**data
)
1823 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1826 TRACE("(%p)->(%u, %p)\n", This
, frames
, data
);
1833 EnterCriticalSection(&This
->lock
);
1835 if(This
->getbuf_last
){
1836 LeaveCriticalSection(&This
->lock
);
1837 return AUDCLNT_E_OUT_OF_ORDER
;
1841 LeaveCriticalSection(&This
->lock
);
1845 if(This
->held_frames
+ frames
> This
->bufsize_frames
){
1846 LeaveCriticalSection(&This
->lock
);
1847 return AUDCLNT_E_BUFFER_TOO_LARGE
;
1851 (This
->lcl_offs_frames
+ This
->held_frames
) % This
->bufsize_frames
;
1852 if(write_pos
+ frames
> This
->bufsize_frames
){
1853 if(This
->tmp_buffer_frames
< frames
){
1854 HeapFree(GetProcessHeap(), 0, This
->tmp_buffer
);
1855 This
->tmp_buffer
= HeapAlloc(GetProcessHeap(), 0,
1856 frames
* This
->fmt
->nBlockAlign
);
1857 if(!This
->tmp_buffer
){
1858 LeaveCriticalSection(&This
->lock
);
1859 return E_OUTOFMEMORY
;
1861 This
->tmp_buffer_frames
= frames
;
1863 *data
= This
->tmp_buffer
;
1864 This
->getbuf_last
= -frames
;
1866 *data
= This
->local_buffer
+ write_pos
* This
->fmt
->nBlockAlign
;
1867 This
->getbuf_last
= frames
;
1870 silence_buffer(This
, *data
, frames
);
1872 LeaveCriticalSection(&This
->lock
);
1877 static void oss_wrap_buffer(ACImpl
*This
, BYTE
*buffer
, UINT32 written_frames
)
1879 UINT32 write_offs_frames
=
1880 (This
->lcl_offs_frames
+ This
->held_frames
) % This
->bufsize_frames
;
1881 UINT32 write_offs_bytes
= write_offs_frames
* This
->fmt
->nBlockAlign
;
1882 UINT32 chunk_frames
= This
->bufsize_frames
- write_offs_frames
;
1883 UINT32 chunk_bytes
= chunk_frames
* This
->fmt
->nBlockAlign
;
1884 UINT32 written_bytes
= written_frames
* This
->fmt
->nBlockAlign
;
1886 if(written_bytes
<= chunk_bytes
){
1887 memcpy(This
->local_buffer
+ write_offs_bytes
, buffer
, written_bytes
);
1889 memcpy(This
->local_buffer
+ write_offs_bytes
, buffer
, chunk_bytes
);
1890 memcpy(This
->local_buffer
, buffer
+ chunk_bytes
,
1891 written_bytes
- chunk_bytes
);
1895 static HRESULT WINAPI
AudioRenderClient_ReleaseBuffer(
1896 IAudioRenderClient
*iface
, UINT32 written_frames
, DWORD flags
)
1898 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1901 TRACE("(%p)->(%u, %x)\n", This
, written_frames
, flags
);
1903 EnterCriticalSection(&This
->lock
);
1905 if(!written_frames
){
1906 This
->getbuf_last
= 0;
1907 LeaveCriticalSection(&This
->lock
);
1911 if(!This
->getbuf_last
){
1912 LeaveCriticalSection(&This
->lock
);
1913 return AUDCLNT_E_OUT_OF_ORDER
;
1916 if(written_frames
> (This
->getbuf_last
>= 0 ? This
->getbuf_last
: -This
->getbuf_last
)){
1917 LeaveCriticalSection(&This
->lock
);
1918 return AUDCLNT_E_INVALID_SIZE
;
1921 if(This
->getbuf_last
>= 0)
1922 buffer
= This
->local_buffer
+ This
->fmt
->nBlockAlign
*
1923 ((This
->lcl_offs_frames
+ This
->held_frames
) % This
->bufsize_frames
);
1925 buffer
= This
->tmp_buffer
;
1927 if(flags
& AUDCLNT_BUFFERFLAGS_SILENT
)
1928 silence_buffer(This
, buffer
, written_frames
);
1930 if(This
->getbuf_last
< 0)
1931 oss_wrap_buffer(This
, buffer
, written_frames
);
1933 This
->held_frames
+= written_frames
;
1934 This
->written_frames
+= written_frames
;
1935 This
->getbuf_last
= 0;
1937 LeaveCriticalSection(&This
->lock
);
1942 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl
= {
1943 AudioRenderClient_QueryInterface
,
1944 AudioRenderClient_AddRef
,
1945 AudioRenderClient_Release
,
1946 AudioRenderClient_GetBuffer
,
1947 AudioRenderClient_ReleaseBuffer
1950 static HRESULT WINAPI
AudioCaptureClient_QueryInterface(
1951 IAudioCaptureClient
*iface
, REFIID riid
, void **ppv
)
1953 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
1954 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
1960 if(IsEqualIID(riid
, &IID_IUnknown
) ||
1961 IsEqualIID(riid
, &IID_IAudioCaptureClient
))
1963 else if(IsEqualIID(riid
, &IID_IMarshal
))
1964 return IUnknown_QueryInterface(This
->pUnkFTMarshal
, riid
, ppv
);
1966 IUnknown_AddRef((IUnknown
*)*ppv
);
1970 WARN("Unknown interface %s\n", debugstr_guid(riid
));
1971 return E_NOINTERFACE
;
1974 static ULONG WINAPI
AudioCaptureClient_AddRef(IAudioCaptureClient
*iface
)
1976 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
1977 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
1980 static ULONG WINAPI
AudioCaptureClient_Release(IAudioCaptureClient
*iface
)
1982 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
1983 return IAudioClient_Release(&This
->IAudioClient_iface
);
1986 static HRESULT WINAPI
AudioCaptureClient_GetBuffer(IAudioCaptureClient
*iface
,
1987 BYTE
**data
, UINT32
*frames
, DWORD
*flags
, UINT64
*devpos
,
1990 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
1992 TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This
, data
, frames
, flags
,
1995 if(!data
|| !frames
|| !flags
)
1998 EnterCriticalSection(&This
->lock
);
2000 if(This
->getbuf_last
){
2001 LeaveCriticalSection(&This
->lock
);
2002 return AUDCLNT_E_OUT_OF_ORDER
;
2005 if(This
->held_frames
< This
->period_frames
){
2007 LeaveCriticalSection(&This
->lock
);
2008 return AUDCLNT_S_BUFFER_EMPTY
;
2013 *frames
= This
->period_frames
;
2015 if(This
->lcl_offs_frames
+ *frames
> This
->bufsize_frames
){
2016 UINT32 chunk_bytes
, offs_bytes
, frames_bytes
;
2017 if(This
->tmp_buffer_frames
< *frames
){
2018 HeapFree(GetProcessHeap(), 0, This
->tmp_buffer
);
2019 This
->tmp_buffer
= HeapAlloc(GetProcessHeap(), 0,
2020 *frames
* This
->fmt
->nBlockAlign
);
2021 if(!This
->tmp_buffer
){
2022 LeaveCriticalSection(&This
->lock
);
2023 return E_OUTOFMEMORY
;
2025 This
->tmp_buffer_frames
= *frames
;
2028 *data
= This
->tmp_buffer
;
2029 chunk_bytes
= (This
->bufsize_frames
- This
->lcl_offs_frames
) *
2030 This
->fmt
->nBlockAlign
;
2031 offs_bytes
= This
->lcl_offs_frames
* This
->fmt
->nBlockAlign
;
2032 frames_bytes
= *frames
* This
->fmt
->nBlockAlign
;
2033 memcpy(This
->tmp_buffer
, This
->local_buffer
+ offs_bytes
, chunk_bytes
);
2034 memcpy(This
->tmp_buffer
+ chunk_bytes
, This
->local_buffer
,
2035 frames_bytes
- chunk_bytes
);
2037 *data
= This
->local_buffer
+
2038 This
->lcl_offs_frames
* This
->fmt
->nBlockAlign
;
2040 This
->getbuf_last
= *frames
;
2043 *devpos
= This
->written_frames
;
2045 LARGE_INTEGER stamp
, freq
;
2046 QueryPerformanceCounter(&stamp
);
2047 QueryPerformanceFrequency(&freq
);
2048 *qpcpos
= (stamp
.QuadPart
* (INT64
)10000000) / freq
.QuadPart
;
2051 LeaveCriticalSection(&This
->lock
);
2053 return *frames
? S_OK
: AUDCLNT_S_BUFFER_EMPTY
;
2056 static HRESULT WINAPI
AudioCaptureClient_ReleaseBuffer(
2057 IAudioCaptureClient
*iface
, UINT32 done
)
2059 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
2061 TRACE("(%p)->(%u)\n", This
, done
);
2063 EnterCriticalSection(&This
->lock
);
2066 This
->getbuf_last
= 0;
2067 LeaveCriticalSection(&This
->lock
);
2071 if(!This
->getbuf_last
){
2072 LeaveCriticalSection(&This
->lock
);
2073 return AUDCLNT_E_OUT_OF_ORDER
;
2076 if(This
->getbuf_last
!= done
){
2077 LeaveCriticalSection(&This
->lock
);
2078 return AUDCLNT_E_INVALID_SIZE
;
2081 This
->written_frames
+= done
;
2082 This
->held_frames
-= done
;
2083 This
->lcl_offs_frames
+= done
;
2084 This
->lcl_offs_frames
%= This
->bufsize_frames
;
2085 This
->getbuf_last
= 0;
2087 LeaveCriticalSection(&This
->lock
);
2092 static HRESULT WINAPI
AudioCaptureClient_GetNextPacketSize(
2093 IAudioCaptureClient
*iface
, UINT32
*frames
)
2095 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
2097 TRACE("(%p)->(%p)\n", This
, frames
);
2102 EnterCriticalSection(&This
->lock
);
2104 *frames
= This
->held_frames
< This
->period_frames
? 0 : This
->period_frames
;
2106 LeaveCriticalSection(&This
->lock
);
2111 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl
=
2113 AudioCaptureClient_QueryInterface
,
2114 AudioCaptureClient_AddRef
,
2115 AudioCaptureClient_Release
,
2116 AudioCaptureClient_GetBuffer
,
2117 AudioCaptureClient_ReleaseBuffer
,
2118 AudioCaptureClient_GetNextPacketSize
2121 static HRESULT WINAPI
AudioClock_QueryInterface(IAudioClock
*iface
,
2122 REFIID riid
, void **ppv
)
2124 ACImpl
*This
= impl_from_IAudioClock(iface
);
2126 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2132 if(IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IAudioClock
))
2134 else if(IsEqualIID(riid
, &IID_IAudioClock2
))
2135 *ppv
= &This
->IAudioClock2_iface
;
2137 IUnknown_AddRef((IUnknown
*)*ppv
);
2141 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2142 return E_NOINTERFACE
;
2145 static ULONG WINAPI
AudioClock_AddRef(IAudioClock
*iface
)
2147 ACImpl
*This
= impl_from_IAudioClock(iface
);
2148 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2151 static ULONG WINAPI
AudioClock_Release(IAudioClock
*iface
)
2153 ACImpl
*This
= impl_from_IAudioClock(iface
);
2154 return IAudioClient_Release(&This
->IAudioClient_iface
);
2157 static HRESULT WINAPI
AudioClock_GetFrequency(IAudioClock
*iface
, UINT64
*freq
)
2159 ACImpl
*This
= impl_from_IAudioClock(iface
);
2161 TRACE("(%p)->(%p)\n", This
, freq
);
2163 if(This
->share
== AUDCLNT_SHAREMODE_SHARED
)
2164 *freq
= (UINT64
)This
->fmt
->nSamplesPerSec
* This
->fmt
->nBlockAlign
;
2166 *freq
= This
->fmt
->nSamplesPerSec
;
2171 static HRESULT WINAPI
AudioClock_GetPosition(IAudioClock
*iface
, UINT64
*pos
,
2174 ACImpl
*This
= impl_from_IAudioClock(iface
);
2176 TRACE("(%p)->(%p, %p)\n", This
, pos
, qpctime
);
2181 EnterCriticalSection(&This
->lock
);
2183 if(This
->dataflow
== eRender
){
2184 *pos
= This
->written_frames
- This
->held_frames
;
2185 if(*pos
< This
->last_pos_frames
)
2186 *pos
= This
->last_pos_frames
;
2187 }else if(This
->dataflow
== eCapture
){
2191 if(ioctl(This
->fd
, SNDCTL_DSP_GETISPACE
, &bi
) < 0){
2192 TRACE("GETISPACE failed: %d (%s)\n", errno
, strerror(errno
));
2195 if(bi
.bytes
<= bi
.fragsize
)
2198 held
= bi
.bytes
/ This
->fmt
->nBlockAlign
;
2201 *pos
= This
->written_frames
+ held
;
2204 This
->last_pos_frames
= *pos
;
2206 TRACE("returning: %s\n", wine_dbgstr_longlong(*pos
));
2207 if(This
->share
== AUDCLNT_SHAREMODE_SHARED
)
2208 *pos
*= This
->fmt
->nBlockAlign
;
2210 LeaveCriticalSection(&This
->lock
);
2213 LARGE_INTEGER stamp
, freq
;
2214 QueryPerformanceCounter(&stamp
);
2215 QueryPerformanceFrequency(&freq
);
2216 *qpctime
= (stamp
.QuadPart
* (INT64
)10000000) / freq
.QuadPart
;
2222 static HRESULT WINAPI
AudioClock_GetCharacteristics(IAudioClock
*iface
,
2225 ACImpl
*This
= impl_from_IAudioClock(iface
);
2227 TRACE("(%p)->(%p)\n", This
, chars
);
2232 *chars
= AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ
;
2237 static const IAudioClockVtbl AudioClock_Vtbl
=
2239 AudioClock_QueryInterface
,
2242 AudioClock_GetFrequency
,
2243 AudioClock_GetPosition
,
2244 AudioClock_GetCharacteristics
2247 static HRESULT WINAPI
AudioClock2_QueryInterface(IAudioClock2
*iface
,
2248 REFIID riid
, void **ppv
)
2250 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2251 return IAudioClock_QueryInterface(&This
->IAudioClock_iface
, riid
, ppv
);
2254 static ULONG WINAPI
AudioClock2_AddRef(IAudioClock2
*iface
)
2256 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2257 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2260 static ULONG WINAPI
AudioClock2_Release(IAudioClock2
*iface
)
2262 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2263 return IAudioClient_Release(&This
->IAudioClient_iface
);
2266 static HRESULT WINAPI
AudioClock2_GetDevicePosition(IAudioClock2
*iface
,
2267 UINT64
*pos
, UINT64
*qpctime
)
2269 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2271 FIXME("(%p)->(%p, %p)\n", This
, pos
, qpctime
);
2276 static const IAudioClock2Vtbl AudioClock2_Vtbl
=
2278 AudioClock2_QueryInterface
,
2280 AudioClock2_Release
,
2281 AudioClock2_GetDevicePosition
2284 static AudioSessionWrapper
*AudioSessionWrapper_Create(ACImpl
*client
)
2286 AudioSessionWrapper
*ret
;
2288 ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2289 sizeof(AudioSessionWrapper
));
2293 ret
->IAudioSessionControl2_iface
.lpVtbl
= &AudioSessionControl2_Vtbl
;
2294 ret
->ISimpleAudioVolume_iface
.lpVtbl
= &SimpleAudioVolume_Vtbl
;
2295 ret
->IChannelAudioVolume_iface
.lpVtbl
= &ChannelAudioVolume_Vtbl
;
2299 ret
->client
= client
;
2301 ret
->session
= client
->session
;
2302 AudioClient_AddRef(&client
->IAudioClient_iface
);
2308 static HRESULT WINAPI
AudioSessionControl_QueryInterface(
2309 IAudioSessionControl2
*iface
, REFIID riid
, void **ppv
)
2311 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2317 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2318 IsEqualIID(riid
, &IID_IAudioSessionControl
) ||
2319 IsEqualIID(riid
, &IID_IAudioSessionControl2
))
2322 IUnknown_AddRef((IUnknown
*)*ppv
);
2326 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2327 return E_NOINTERFACE
;
2330 static ULONG WINAPI
AudioSessionControl_AddRef(IAudioSessionControl2
*iface
)
2332 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2334 ref
= InterlockedIncrement(&This
->ref
);
2335 TRACE("(%p) Refcount now %u\n", This
, ref
);
2339 static ULONG WINAPI
AudioSessionControl_Release(IAudioSessionControl2
*iface
)
2341 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2343 ref
= InterlockedDecrement(&This
->ref
);
2344 TRACE("(%p) Refcount now %u\n", This
, ref
);
2347 EnterCriticalSection(&This
->client
->lock
);
2348 This
->client
->session_wrapper
= NULL
;
2349 LeaveCriticalSection(&This
->client
->lock
);
2350 AudioClient_Release(&This
->client
->IAudioClient_iface
);
2352 HeapFree(GetProcessHeap(), 0, This
);
2357 static HRESULT WINAPI
AudioSessionControl_GetState(IAudioSessionControl2
*iface
,
2358 AudioSessionState
*state
)
2360 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2363 TRACE("(%p)->(%p)\n", This
, state
);
2366 return NULL_PTR_ERR
;
2368 EnterCriticalSection(&g_sessions_lock
);
2370 if(list_empty(&This
->session
->clients
)){
2371 *state
= AudioSessionStateExpired
;
2372 LeaveCriticalSection(&g_sessions_lock
);
2376 LIST_FOR_EACH_ENTRY(client
, &This
->session
->clients
, ACImpl
, entry
){
2377 EnterCriticalSection(&client
->lock
);
2378 if(client
->playing
){
2379 *state
= AudioSessionStateActive
;
2380 LeaveCriticalSection(&client
->lock
);
2381 LeaveCriticalSection(&g_sessions_lock
);
2384 LeaveCriticalSection(&client
->lock
);
2387 LeaveCriticalSection(&g_sessions_lock
);
2389 *state
= AudioSessionStateInactive
;
2394 static HRESULT WINAPI
AudioSessionControl_GetDisplayName(
2395 IAudioSessionControl2
*iface
, WCHAR
**name
)
2397 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2399 FIXME("(%p)->(%p) - stub\n", This
, name
);
2404 static HRESULT WINAPI
AudioSessionControl_SetDisplayName(
2405 IAudioSessionControl2
*iface
, const WCHAR
*name
, const GUID
*session
)
2407 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2409 FIXME("(%p)->(%p, %s) - stub\n", This
, name
, debugstr_guid(session
));
2414 static HRESULT WINAPI
AudioSessionControl_GetIconPath(
2415 IAudioSessionControl2
*iface
, WCHAR
**path
)
2417 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2419 FIXME("(%p)->(%p) - stub\n", This
, path
);
2424 static HRESULT WINAPI
AudioSessionControl_SetIconPath(
2425 IAudioSessionControl2
*iface
, const WCHAR
*path
, const GUID
*session
)
2427 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2429 FIXME("(%p)->(%p, %s) - stub\n", This
, path
, debugstr_guid(session
));
2434 static HRESULT WINAPI
AudioSessionControl_GetGroupingParam(
2435 IAudioSessionControl2
*iface
, GUID
*group
)
2437 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2439 FIXME("(%p)->(%p) - stub\n", This
, group
);
2444 static HRESULT WINAPI
AudioSessionControl_SetGroupingParam(
2445 IAudioSessionControl2
*iface
, const GUID
*group
, const GUID
*session
)
2447 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2449 FIXME("(%p)->(%s, %s) - stub\n", This
, debugstr_guid(group
),
2450 debugstr_guid(session
));
2455 static HRESULT WINAPI
AudioSessionControl_RegisterAudioSessionNotification(
2456 IAudioSessionControl2
*iface
, IAudioSessionEvents
*events
)
2458 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2460 FIXME("(%p)->(%p) - stub\n", This
, events
);
2465 static HRESULT WINAPI
AudioSessionControl_UnregisterAudioSessionNotification(
2466 IAudioSessionControl2
*iface
, IAudioSessionEvents
*events
)
2468 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2470 FIXME("(%p)->(%p) - stub\n", This
, events
);
2475 static HRESULT WINAPI
AudioSessionControl_GetSessionIdentifier(
2476 IAudioSessionControl2
*iface
, WCHAR
**id
)
2478 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2480 FIXME("(%p)->(%p) - stub\n", This
, id
);
2485 static HRESULT WINAPI
AudioSessionControl_GetSessionInstanceIdentifier(
2486 IAudioSessionControl2
*iface
, WCHAR
**id
)
2488 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2490 FIXME("(%p)->(%p) - stub\n", This
, id
);
2495 static HRESULT WINAPI
AudioSessionControl_GetProcessId(
2496 IAudioSessionControl2
*iface
, DWORD
*pid
)
2498 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2500 TRACE("(%p)->(%p)\n", This
, pid
);
2505 *pid
= GetCurrentProcessId();
2510 static HRESULT WINAPI
AudioSessionControl_IsSystemSoundsSession(
2511 IAudioSessionControl2
*iface
)
2513 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2515 TRACE("(%p)\n", This
);
2520 static HRESULT WINAPI
AudioSessionControl_SetDuckingPreference(
2521 IAudioSessionControl2
*iface
, BOOL optout
)
2523 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2525 TRACE("(%p)->(%d)\n", This
, optout
);
2530 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl
=
2532 AudioSessionControl_QueryInterface
,
2533 AudioSessionControl_AddRef
,
2534 AudioSessionControl_Release
,
2535 AudioSessionControl_GetState
,
2536 AudioSessionControl_GetDisplayName
,
2537 AudioSessionControl_SetDisplayName
,
2538 AudioSessionControl_GetIconPath
,
2539 AudioSessionControl_SetIconPath
,
2540 AudioSessionControl_GetGroupingParam
,
2541 AudioSessionControl_SetGroupingParam
,
2542 AudioSessionControl_RegisterAudioSessionNotification
,
2543 AudioSessionControl_UnregisterAudioSessionNotification
,
2544 AudioSessionControl_GetSessionIdentifier
,
2545 AudioSessionControl_GetSessionInstanceIdentifier
,
2546 AudioSessionControl_GetProcessId
,
2547 AudioSessionControl_IsSystemSoundsSession
,
2548 AudioSessionControl_SetDuckingPreference
2551 static HRESULT WINAPI
SimpleAudioVolume_QueryInterface(
2552 ISimpleAudioVolume
*iface
, REFIID riid
, void **ppv
)
2554 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2560 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2561 IsEqualIID(riid
, &IID_ISimpleAudioVolume
))
2564 IUnknown_AddRef((IUnknown
*)*ppv
);
2568 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2569 return E_NOINTERFACE
;
2572 static ULONG WINAPI
SimpleAudioVolume_AddRef(ISimpleAudioVolume
*iface
)
2574 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2575 return AudioSessionControl_AddRef(&This
->IAudioSessionControl2_iface
);
2578 static ULONG WINAPI
SimpleAudioVolume_Release(ISimpleAudioVolume
*iface
)
2580 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2581 return AudioSessionControl_Release(&This
->IAudioSessionControl2_iface
);
2584 static HRESULT WINAPI
SimpleAudioVolume_SetMasterVolume(
2585 ISimpleAudioVolume
*iface
, float level
, const GUID
*context
)
2587 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2588 AudioSession
*session
= This
->session
;
2590 TRACE("(%p)->(%f, %s)\n", session
, level
, wine_dbgstr_guid(context
));
2592 if(level
< 0.f
|| level
> 1.f
)
2593 return E_INVALIDARG
;
2596 FIXME("Notifications not supported yet\n");
2598 EnterCriticalSection(&session
->lock
);
2600 session
->master_vol
= level
;
2602 TRACE("OSS doesn't support setting volume\n");
2604 LeaveCriticalSection(&session
->lock
);
2609 static HRESULT WINAPI
SimpleAudioVolume_GetMasterVolume(
2610 ISimpleAudioVolume
*iface
, float *level
)
2612 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2613 AudioSession
*session
= This
->session
;
2615 TRACE("(%p)->(%p)\n", session
, level
);
2618 return NULL_PTR_ERR
;
2620 *level
= session
->master_vol
;
2625 static HRESULT WINAPI
SimpleAudioVolume_SetMute(ISimpleAudioVolume
*iface
,
2626 BOOL mute
, const GUID
*context
)
2628 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2629 AudioSession
*session
= This
->session
;
2631 TRACE("(%p)->(%u, %s)\n", session
, mute
, debugstr_guid(context
));
2633 EnterCriticalSection(&session
->lock
);
2635 session
->mute
= mute
;
2637 LeaveCriticalSection(&session
->lock
);
2642 static HRESULT WINAPI
SimpleAudioVolume_GetMute(ISimpleAudioVolume
*iface
,
2645 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2646 AudioSession
*session
= This
->session
;
2648 TRACE("(%p)->(%p)\n", session
, mute
);
2651 return NULL_PTR_ERR
;
2653 *mute
= This
->session
->mute
;
2658 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl
=
2660 SimpleAudioVolume_QueryInterface
,
2661 SimpleAudioVolume_AddRef
,
2662 SimpleAudioVolume_Release
,
2663 SimpleAudioVolume_SetMasterVolume
,
2664 SimpleAudioVolume_GetMasterVolume
,
2665 SimpleAudioVolume_SetMute
,
2666 SimpleAudioVolume_GetMute
2669 static HRESULT WINAPI
AudioStreamVolume_QueryInterface(
2670 IAudioStreamVolume
*iface
, REFIID riid
, void **ppv
)
2672 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2678 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2679 IsEqualIID(riid
, &IID_IAudioStreamVolume
))
2682 IUnknown_AddRef((IUnknown
*)*ppv
);
2686 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2687 return E_NOINTERFACE
;
2690 static ULONG WINAPI
AudioStreamVolume_AddRef(IAudioStreamVolume
*iface
)
2692 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2693 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2696 static ULONG WINAPI
AudioStreamVolume_Release(IAudioStreamVolume
*iface
)
2698 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2699 return IAudioClient_Release(&This
->IAudioClient_iface
);
2702 static HRESULT WINAPI
AudioStreamVolume_GetChannelCount(
2703 IAudioStreamVolume
*iface
, UINT32
*out
)
2705 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2707 TRACE("(%p)->(%p)\n", This
, out
);
2712 *out
= This
->fmt
->nChannels
;
2717 static HRESULT WINAPI
AudioStreamVolume_SetChannelVolume(
2718 IAudioStreamVolume
*iface
, UINT32 index
, float level
)
2720 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2722 TRACE("(%p)->(%d, %f)\n", This
, index
, level
);
2724 if(level
< 0.f
|| level
> 1.f
)
2725 return E_INVALIDARG
;
2727 if(index
>= This
->fmt
->nChannels
)
2728 return E_INVALIDARG
;
2730 EnterCriticalSection(&This
->lock
);
2732 This
->vols
[index
] = level
;
2734 TRACE("OSS doesn't support setting volume\n");
2736 LeaveCriticalSection(&This
->lock
);
2741 static HRESULT WINAPI
AudioStreamVolume_GetChannelVolume(
2742 IAudioStreamVolume
*iface
, UINT32 index
, float *level
)
2744 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2746 TRACE("(%p)->(%d, %p)\n", This
, index
, level
);
2751 if(index
>= This
->fmt
->nChannels
)
2752 return E_INVALIDARG
;
2754 *level
= This
->vols
[index
];
2759 static HRESULT WINAPI
AudioStreamVolume_SetAllVolumes(
2760 IAudioStreamVolume
*iface
, UINT32 count
, const float *levels
)
2762 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2765 TRACE("(%p)->(%d, %p)\n", This
, count
, levels
);
2770 if(count
!= This
->fmt
->nChannels
)
2771 return E_INVALIDARG
;
2773 EnterCriticalSection(&This
->lock
);
2775 for(i
= 0; i
< count
; ++i
)
2776 This
->vols
[i
] = levels
[i
];
2778 TRACE("OSS doesn't support setting volume\n");
2780 LeaveCriticalSection(&This
->lock
);
2785 static HRESULT WINAPI
AudioStreamVolume_GetAllVolumes(
2786 IAudioStreamVolume
*iface
, UINT32 count
, float *levels
)
2788 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2791 TRACE("(%p)->(%d, %p)\n", This
, count
, levels
);
2796 if(count
!= This
->fmt
->nChannels
)
2797 return E_INVALIDARG
;
2799 EnterCriticalSection(&This
->lock
);
2801 for(i
= 0; i
< count
; ++i
)
2802 levels
[i
] = This
->vols
[i
];
2804 LeaveCriticalSection(&This
->lock
);
2809 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl
=
2811 AudioStreamVolume_QueryInterface
,
2812 AudioStreamVolume_AddRef
,
2813 AudioStreamVolume_Release
,
2814 AudioStreamVolume_GetChannelCount
,
2815 AudioStreamVolume_SetChannelVolume
,
2816 AudioStreamVolume_GetChannelVolume
,
2817 AudioStreamVolume_SetAllVolumes
,
2818 AudioStreamVolume_GetAllVolumes
2821 static HRESULT WINAPI
ChannelAudioVolume_QueryInterface(
2822 IChannelAudioVolume
*iface
, REFIID riid
, void **ppv
)
2824 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2830 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2831 IsEqualIID(riid
, &IID_IChannelAudioVolume
))
2834 IUnknown_AddRef((IUnknown
*)*ppv
);
2838 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2839 return E_NOINTERFACE
;
2842 static ULONG WINAPI
ChannelAudioVolume_AddRef(IChannelAudioVolume
*iface
)
2844 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2845 return AudioSessionControl_AddRef(&This
->IAudioSessionControl2_iface
);
2848 static ULONG WINAPI
ChannelAudioVolume_Release(IChannelAudioVolume
*iface
)
2850 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2851 return AudioSessionControl_Release(&This
->IAudioSessionControl2_iface
);
2854 static HRESULT WINAPI
ChannelAudioVolume_GetChannelCount(
2855 IChannelAudioVolume
*iface
, UINT32
*out
)
2857 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2858 AudioSession
*session
= This
->session
;
2860 TRACE("(%p)->(%p)\n", session
, out
);
2863 return NULL_PTR_ERR
;
2865 *out
= session
->channel_count
;
2870 static HRESULT WINAPI
ChannelAudioVolume_SetChannelVolume(
2871 IChannelAudioVolume
*iface
, UINT32 index
, float level
,
2872 const GUID
*context
)
2874 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2875 AudioSession
*session
= This
->session
;
2877 TRACE("(%p)->(%d, %f, %s)\n", session
, index
, level
,
2878 wine_dbgstr_guid(context
));
2880 if(level
< 0.f
|| level
> 1.f
)
2881 return E_INVALIDARG
;
2883 if(index
>= session
->channel_count
)
2884 return E_INVALIDARG
;
2887 FIXME("Notifications not supported yet\n");
2889 EnterCriticalSection(&session
->lock
);
2891 session
->channel_vols
[index
] = level
;
2893 TRACE("OSS doesn't support setting volume\n");
2895 LeaveCriticalSection(&session
->lock
);
2900 static HRESULT WINAPI
ChannelAudioVolume_GetChannelVolume(
2901 IChannelAudioVolume
*iface
, UINT32 index
, float *level
)
2903 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2904 AudioSession
*session
= This
->session
;
2906 TRACE("(%p)->(%d, %p)\n", session
, index
, level
);
2909 return NULL_PTR_ERR
;
2911 if(index
>= session
->channel_count
)
2912 return E_INVALIDARG
;
2914 *level
= session
->channel_vols
[index
];
2919 static HRESULT WINAPI
ChannelAudioVolume_SetAllVolumes(
2920 IChannelAudioVolume
*iface
, UINT32 count
, const float *levels
,
2921 const GUID
*context
)
2923 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2924 AudioSession
*session
= This
->session
;
2927 TRACE("(%p)->(%d, %p, %s)\n", session
, count
, levels
,
2928 wine_dbgstr_guid(context
));
2931 return NULL_PTR_ERR
;
2933 if(count
!= session
->channel_count
)
2934 return E_INVALIDARG
;
2937 FIXME("Notifications not supported yet\n");
2939 EnterCriticalSection(&session
->lock
);
2941 for(i
= 0; i
< count
; ++i
)
2942 session
->channel_vols
[i
] = levels
[i
];
2944 TRACE("OSS doesn't support setting volume\n");
2946 LeaveCriticalSection(&session
->lock
);
2951 static HRESULT WINAPI
ChannelAudioVolume_GetAllVolumes(
2952 IChannelAudioVolume
*iface
, UINT32 count
, float *levels
)
2954 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2955 AudioSession
*session
= This
->session
;
2958 TRACE("(%p)->(%d, %p)\n", session
, count
, levels
);
2961 return NULL_PTR_ERR
;
2963 if(count
!= session
->channel_count
)
2964 return E_INVALIDARG
;
2966 for(i
= 0; i
< count
; ++i
)
2967 levels
[i
] = session
->channel_vols
[i
];
2972 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl
=
2974 ChannelAudioVolume_QueryInterface
,
2975 ChannelAudioVolume_AddRef
,
2976 ChannelAudioVolume_Release
,
2977 ChannelAudioVolume_GetChannelCount
,
2978 ChannelAudioVolume_SetChannelVolume
,
2979 ChannelAudioVolume_GetChannelVolume
,
2980 ChannelAudioVolume_SetAllVolumes
,
2981 ChannelAudioVolume_GetAllVolumes
2984 static HRESULT WINAPI
AudioSessionManager_QueryInterface(IAudioSessionManager2
*iface
,
2985 REFIID riid
, void **ppv
)
2987 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2993 if(IsEqualIID(riid
, &IID_IUnknown
) ||
2994 IsEqualIID(riid
, &IID_IAudioSessionManager
) ||
2995 IsEqualIID(riid
, &IID_IAudioSessionManager2
))
2998 IUnknown_AddRef((IUnknown
*)*ppv
);
3002 WARN("Unknown interface %s\n", debugstr_guid(riid
));
3003 return E_NOINTERFACE
;
3006 static ULONG WINAPI
AudioSessionManager_AddRef(IAudioSessionManager2
*iface
)
3008 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3010 ref
= InterlockedIncrement(&This
->ref
);
3011 TRACE("(%p) Refcount now %u\n", This
, ref
);
3015 static ULONG WINAPI
AudioSessionManager_Release(IAudioSessionManager2
*iface
)
3017 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3019 ref
= InterlockedDecrement(&This
->ref
);
3020 TRACE("(%p) Refcount now %u\n", This
, ref
);
3022 HeapFree(GetProcessHeap(), 0, This
);
3026 static HRESULT WINAPI
AudioSessionManager_GetAudioSessionControl(
3027 IAudioSessionManager2
*iface
, const GUID
*session_guid
, DWORD flags
,
3028 IAudioSessionControl
**out
)
3030 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3031 AudioSession
*session
;
3032 AudioSessionWrapper
*wrapper
;
3035 TRACE("(%p)->(%s, %x, %p)\n", This
, debugstr_guid(session_guid
),
3038 hr
= get_audio_session(session_guid
, This
->device
, 0, &session
);
3042 wrapper
= AudioSessionWrapper_Create(NULL
);
3044 return E_OUTOFMEMORY
;
3046 wrapper
->session
= session
;
3048 *out
= (IAudioSessionControl
*)&wrapper
->IAudioSessionControl2_iface
;
3053 static HRESULT WINAPI
AudioSessionManager_GetSimpleAudioVolume(
3054 IAudioSessionManager2
*iface
, const GUID
*session_guid
, DWORD flags
,
3055 ISimpleAudioVolume
**out
)
3057 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3058 AudioSession
*session
;
3059 AudioSessionWrapper
*wrapper
;
3062 TRACE("(%p)->(%s, %x, %p)\n", This
, debugstr_guid(session_guid
),
3065 hr
= get_audio_session(session_guid
, This
->device
, 0, &session
);
3069 wrapper
= AudioSessionWrapper_Create(NULL
);
3071 return E_OUTOFMEMORY
;
3073 wrapper
->session
= session
;
3075 *out
= &wrapper
->ISimpleAudioVolume_iface
;
3080 static HRESULT WINAPI
AudioSessionManager_GetSessionEnumerator(
3081 IAudioSessionManager2
*iface
, IAudioSessionEnumerator
**out
)
3083 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3084 FIXME("(%p)->(%p) - stub\n", This
, out
);
3088 static HRESULT WINAPI
AudioSessionManager_RegisterSessionNotification(
3089 IAudioSessionManager2
*iface
, IAudioSessionNotification
*notification
)
3091 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3092 FIXME("(%p)->(%p) - stub\n", This
, notification
);
3096 static HRESULT WINAPI
AudioSessionManager_UnregisterSessionNotification(
3097 IAudioSessionManager2
*iface
, IAudioSessionNotification
*notification
)
3099 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3100 FIXME("(%p)->(%p) - stub\n", This
, notification
);
3104 static HRESULT WINAPI
AudioSessionManager_RegisterDuckNotification(
3105 IAudioSessionManager2
*iface
, const WCHAR
*session_id
,
3106 IAudioVolumeDuckNotification
*notification
)
3108 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3109 FIXME("(%p)->(%p) - stub\n", This
, notification
);
3113 static HRESULT WINAPI
AudioSessionManager_UnregisterDuckNotification(
3114 IAudioSessionManager2
*iface
,
3115 IAudioVolumeDuckNotification
*notification
)
3117 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
3118 FIXME("(%p)->(%p) - stub\n", This
, notification
);
3122 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl
=
3124 AudioSessionManager_QueryInterface
,
3125 AudioSessionManager_AddRef
,
3126 AudioSessionManager_Release
,
3127 AudioSessionManager_GetAudioSessionControl
,
3128 AudioSessionManager_GetSimpleAudioVolume
,
3129 AudioSessionManager_GetSessionEnumerator
,
3130 AudioSessionManager_RegisterSessionNotification
,
3131 AudioSessionManager_UnregisterSessionNotification
,
3132 AudioSessionManager_RegisterDuckNotification
,
3133 AudioSessionManager_UnregisterDuckNotification
3136 HRESULT WINAPI
AUDDRV_GetAudioSessionManager(IMMDevice
*device
,
3137 IAudioSessionManager2
**out
)
3141 This
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(SessionMgr
));
3143 return E_OUTOFMEMORY
;
3145 This
->IAudioSessionManager2_iface
.lpVtbl
= &AudioSessionManager2_Vtbl
;
3146 This
->device
= device
;
3149 *out
= &This
->IAudioSessionManager2_iface
;