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 <sys/types.h>
31 #include <sys/ioctl.h>
35 #include <sys/soundcard.h>
41 #include "wine/debug.h"
42 #include "wine/unicode.h"
43 #include "wine/list.h"
46 #include "mmdeviceapi.h"
52 #include "endpointvolume.h"
53 #include "audiopolicy.h"
54 #include "audioclient.h"
57 /* Some implementations of OSS, such as FreeBSD older than 9.0, lack
58 SNDCTL_DSP_HALT which is just a synonym for the older SNDCTL_DSP_RESET. */
59 #ifndef SNDCTL_DSP_HALT
60 #define SNDCTL_DSP_HALT SNDCTL_DSP_RESET
63 WINE_DEFAULT_DEBUG_CHANNEL(oss);
65 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
67 static const REFERENCE_TIME DefaultPeriod = 200000;
68 static const REFERENCE_TIME MinimumPeriod = 100000;
71 typedef struct ACImpl ACImpl;
73 typedef struct _AudioSession {
84 CRITICAL_SECTION lock;
89 typedef struct _AudioSessionWrapper {
90 IAudioSessionControl2 IAudioSessionControl2_iface;
91 IChannelAudioVolume IChannelAudioVolume_iface;
92 ISimpleAudioVolume ISimpleAudioVolume_iface;
97 AudioSession *session;
98 } AudioSessionWrapper;
101 IAudioClient IAudioClient_iface;
102 IAudioRenderClient IAudioRenderClient_iface;
103 IAudioCaptureClient IAudioCaptureClient_iface;
104 IAudioClock IAudioClock_iface;
105 IAudioClock2 IAudioClock2_iface;
106 IAudioStreamVolume IAudioStreamVolume_iface;
116 AUDCLNT_SHAREMODE share;
122 char devnode[OSS_DEVNODE_SIZE];
124 BOOL initted, playing;
125 UINT64 written_frames;
126 UINT32 period_us, bufsize_frames, held_frames, tmp_buffer_frames, inbuf_frames;
127 UINT32 lcl_offs_frames; /* offs into local_buffer where valid data starts */
129 BYTE *local_buffer, *tmp_buffer;
133 CRITICAL_SECTION lock;
135 AudioSession *session;
136 AudioSessionWrapper *session_wrapper;
143 LOCKED_NORMAL, /* public buffer piece is from local_buffer */
144 LOCKED_WRAPPED /* public buffer piece is in tmp_buffer */
147 typedef struct _SessionMgr {
148 IAudioSessionManager2 IAudioSessionManager2_iface;
155 static HANDLE g_timer_q;
157 static CRITICAL_SECTION g_sessions_lock;
158 static struct list g_sessions = LIST_INIT(g_sessions);
160 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client);
161 static HRESULT oss_setvol(ACImpl *This, UINT32 index);
163 static const IAudioClientVtbl AudioClient_Vtbl;
164 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl;
165 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl;
166 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl;
167 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl;
168 static const IAudioClockVtbl AudioClock_Vtbl;
169 static const IAudioClock2Vtbl AudioClock2_Vtbl;
170 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl;
171 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl;
172 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl;
174 static inline ACImpl *impl_from_IAudioClient(IAudioClient *iface)
176 return CONTAINING_RECORD(iface, ACImpl, IAudioClient_iface);
179 static inline ACImpl *impl_from_IAudioRenderClient(IAudioRenderClient *iface)
181 return CONTAINING_RECORD(iface, ACImpl, IAudioRenderClient_iface);
184 static inline ACImpl *impl_from_IAudioCaptureClient(IAudioCaptureClient *iface)
186 return CONTAINING_RECORD(iface, ACImpl, IAudioCaptureClient_iface);
189 static inline AudioSessionWrapper *impl_from_IAudioSessionControl2(IAudioSessionControl2 *iface)
191 return CONTAINING_RECORD(iface, AudioSessionWrapper, IAudioSessionControl2_iface);
194 static inline AudioSessionWrapper *impl_from_ISimpleAudioVolume(ISimpleAudioVolume *iface)
196 return CONTAINING_RECORD(iface, AudioSessionWrapper, ISimpleAudioVolume_iface);
199 static inline AudioSessionWrapper *impl_from_IChannelAudioVolume(IChannelAudioVolume *iface)
201 return CONTAINING_RECORD(iface, AudioSessionWrapper, IChannelAudioVolume_iface);
204 static inline ACImpl *impl_from_IAudioClock(IAudioClock *iface)
206 return CONTAINING_RECORD(iface, ACImpl, IAudioClock_iface);
209 static inline ACImpl *impl_from_IAudioClock2(IAudioClock2 *iface)
211 return CONTAINING_RECORD(iface, ACImpl, IAudioClock2_iface);
214 static inline ACImpl *impl_from_IAudioStreamVolume(IAudioStreamVolume *iface)
216 return CONTAINING_RECORD(iface, ACImpl, IAudioStreamVolume_iface);
219 static inline SessionMgr *impl_from_IAudioSessionManager2(IAudioSessionManager2 *iface)
221 return CONTAINING_RECORD(iface, SessionMgr, IAudioSessionManager2_iface);
224 BOOL WINAPI DllMain(HINSTANCE dll, DWORD reason, void *reserved)
226 if(reason == DLL_PROCESS_ATTACH){
227 g_timer_q = CreateTimerQueue();
231 InitializeCriticalSection(&g_sessions_lock);
237 /* From <dlls/mmdevapi/mmdevapi.h> */
238 enum DriverPriority {
239 Priority_Unavailable = 0,
245 int WINAPI AUDDRV_GetPriority(void)
250 /* Attempt to determine if we are running on OSS or ALSA's OSS
251 * compatibility layer. There is no official way to do that, so just check
252 * for validity as best as possible, without rejecting valid OSS
253 * implementations. */
255 mixer_fd = open("/dev/mixer", O_RDONLY, 0);
257 TRACE("Priority_Unavailable: open failed\n");
258 return Priority_Unavailable;
261 sysinfo.version[0] = 0xFF;
262 sysinfo.versionnum = ~0;
263 if(ioctl(mixer_fd, SNDCTL_SYSINFO, &sysinfo) < 0){
264 TRACE("Priority_Unavailable: ioctl failed\n");
266 return Priority_Unavailable;
271 if(sysinfo.version[0] < '4' || sysinfo.version[0] > '9'){
272 TRACE("Priority_Low: sysinfo.version[0]: %x\n", sysinfo.version[0]);
275 if(sysinfo.versionnum & 0x80000000){
276 TRACE("Priority_Low: sysinfo.versionnum: %x\n", sysinfo.versionnum);
280 TRACE("Priority_Preferred: Seems like valid OSS!\n");
282 return Priority_Preferred;
285 static const char *oss_clean_devnode(const char *devnode)
287 static char ret[OSS_DEVNODE_SIZE];
289 const char *dot, *slash;
292 dot = strrchr(devnode, '.');
296 slash = strrchr(devnode, '/');
297 if(slash && dot < slash)
302 memcpy(ret, devnode, len);
308 static UINT get_default_index(EDataFlow flow, char **keys, UINT num)
315 fd = open("/dev/dsp", O_WRONLY);
317 fd = open("/dev/dsp", O_RDONLY);
320 WARN("Couldn't open default device!\n");
325 if((err = ioctl(fd, SNDCTL_ENGINEINFO, &ai)) < 0){
326 WARN("SNDCTL_ENGINEINFO failed: %d (%s)\n", err, strerror(errno));
333 TRACE("Default devnode: %s\n", ai.devnode);
334 devnode = oss_clean_devnode(ai.devnode);
335 for(i = 0; i < num; ++i)
336 if(!strcmp(devnode, keys[i]))
339 WARN("Couldn't find default device! Choosing first.\n");
343 HRESULT WINAPI AUDDRV_GetEndpointIDs(EDataFlow flow, WCHAR ***ids, char ***keys,
344 UINT *num, UINT *def_index)
348 static int print_once = 0;
350 TRACE("%d %p %p %p\n", flow, ids, num, def_index);
352 mixer_fd = open("/dev/mixer", O_RDONLY, 0);
354 ERR("OSS /dev/mixer doesn't seem to exist\n");
355 return AUDCLNT_E_SERVICE_NOT_RUNNING;
358 if(ioctl(mixer_fd, SNDCTL_SYSINFO, &sysinfo) < 0){
362 ERR("OSS version too old, need at least OSSv4\n");
363 return AUDCLNT_E_SERVICE_NOT_RUNNING;
366 ERR("Error getting SNDCTL_SYSINFO: %d (%s)\n", errno, strerror(errno));
371 TRACE("OSS sysinfo:\n");
372 TRACE("product: %s\n", sysinfo.product);
373 TRACE("version: %s\n", sysinfo.version);
374 TRACE("versionnum: %x\n", sysinfo.versionnum);
375 TRACE("numaudios: %d\n", sysinfo.numaudios);
376 TRACE("nummixers: %d\n", sysinfo.nummixers);
377 TRACE("numcards: %d\n", sysinfo.numcards);
378 TRACE("numaudioengines: %d\n", sysinfo.numaudioengines);
382 if(sysinfo.numaudios <= 0){
383 WARN("No audio devices!\n");
385 return AUDCLNT_E_SERVICE_NOT_RUNNING;
388 *ids = HeapAlloc(GetProcessHeap(), 0, sysinfo.numaudios * sizeof(WCHAR *));
389 *keys = HeapAlloc(GetProcessHeap(), 0, sysinfo.numaudios * sizeof(char *));
392 for(i = 0; i < sysinfo.numaudios; ++i){
393 oss_audioinfo ai = {0};
398 if(ioctl(mixer_fd, SNDCTL_AUDIOINFO, &ai) < 0){
399 WARN("Error getting AUDIOINFO for dev %d: %d (%s)\n", i, errno,
404 devnode = oss_clean_devnode(ai.devnode);
406 /* check for duplicates */
407 for(j = 0; j < *num; ++j)
408 if(!strcmp(devnode, (*keys)[j]))
414 fd = open(devnode, O_WRONLY, 0);
416 fd = open(devnode, O_RDONLY, 0);
418 WARN("Opening device \"%s\" failed, pretending it doesn't exist: %d (%s)\n",
419 devnode, errno, strerror(errno));
424 if((flow == eCapture && (ai.caps & PCM_CAP_INPUT)) ||
425 (flow == eRender && (ai.caps & PCM_CAP_OUTPUT))){
428 (*keys)[*num] = HeapAlloc(GetProcessHeap(), 0,
429 strlen(devnode) + 1);
431 for(i = 0; i < *num; ++i){
432 HeapFree(GetProcessHeap(), 0, (*ids)[i]);
433 HeapFree(GetProcessHeap(), 0, (*keys)[i]);
435 HeapFree(GetProcessHeap(), 0, *ids);
436 HeapFree(GetProcessHeap(), 0, *keys);
438 return E_OUTOFMEMORY;
440 strcpy((*keys)[*num], devnode);
442 len = MultiByteToWideChar(CP_UNIXCP, 0, ai.name, -1, NULL, 0);
443 (*ids)[*num] = HeapAlloc(GetProcessHeap(), 0,
444 len * sizeof(WCHAR));
446 HeapFree(GetProcessHeap(), 0, (*keys)[*num]);
447 for(i = 0; i < *num; ++i){
448 HeapFree(GetProcessHeap(), 0, (*ids)[i]);
449 HeapFree(GetProcessHeap(), 0, (*keys)[i]);
451 HeapFree(GetProcessHeap(), 0, *ids);
452 HeapFree(GetProcessHeap(), 0, *keys);
454 return E_OUTOFMEMORY;
456 MultiByteToWideChar(CP_UNIXCP, 0, ai.name, -1,
465 *def_index = get_default_index(flow, *keys, *num);
470 HRESULT WINAPI AUDDRV_GetAudioEndpoint(char *devnode, IMMDevice *dev,
471 EDataFlow dataflow, IAudioClient **out)
475 TRACE("%s %p %d %p\n", devnode, dev, dataflow, out);
477 This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ACImpl));
479 return E_OUTOFMEMORY;
481 if(dataflow == eRender)
482 This->fd = open(devnode, O_WRONLY, 0);
483 else if(dataflow == eCapture)
484 This->fd = open(devnode, O_RDONLY, 0);
486 HeapFree(GetProcessHeap(), 0, This);
490 ERR("Unable to open device %s: %d (%s)\n", devnode, errno,
492 HeapFree(GetProcessHeap(), 0, This);
493 return AUDCLNT_E_DEVICE_INVALIDATED;
496 This->dataflow = dataflow;
499 if(ioctl(This->fd, SNDCTL_ENGINEINFO, &This->ai) < 0){
500 ERR("Unable to get audio info for device %s: %d (%s)\n", devnode,
501 errno, strerror(errno));
503 HeapFree(GetProcessHeap(), 0, This);
507 strcpy(This->devnode, devnode);
509 TRACE("OSS audioinfo:\n");
510 TRACE("devnode: %s\n", This->ai.devnode);
511 TRACE("name: %s\n", This->ai.name);
512 TRACE("busy: %x\n", This->ai.busy);
513 TRACE("caps: %x\n", This->ai.caps);
514 TRACE("iformats: %x\n", This->ai.iformats);
515 TRACE("oformats: %x\n", This->ai.oformats);
516 TRACE("enabled: %d\n", This->ai.enabled);
517 TRACE("min_rate: %d\n", This->ai.min_rate);
518 TRACE("max_rate: %d\n", This->ai.max_rate);
519 TRACE("min_channels: %d\n", This->ai.min_channels);
520 TRACE("max_channels: %d\n", This->ai.max_channels);
522 This->IAudioClient_iface.lpVtbl = &AudioClient_Vtbl;
523 This->IAudioRenderClient_iface.lpVtbl = &AudioRenderClient_Vtbl;
524 This->IAudioCaptureClient_iface.lpVtbl = &AudioCaptureClient_Vtbl;
525 This->IAudioClock_iface.lpVtbl = &AudioClock_Vtbl;
526 This->IAudioClock2_iface.lpVtbl = &AudioClock2_Vtbl;
527 This->IAudioStreamVolume_iface.lpVtbl = &AudioStreamVolume_Vtbl;
529 InitializeCriticalSection(&This->lock);
532 IMMDevice_AddRef(This->parent);
534 IAudioClient_AddRef(&This->IAudioClient_iface);
536 *out = &This->IAudioClient_iface;
541 static HRESULT WINAPI AudioClient_QueryInterface(IAudioClient *iface,
542 REFIID riid, void **ppv)
544 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
549 if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAudioClient))
552 IUnknown_AddRef((IUnknown*)*ppv);
555 WARN("Unknown interface %s\n", debugstr_guid(riid));
556 return E_NOINTERFACE;
559 static ULONG WINAPI AudioClient_AddRef(IAudioClient *iface)
561 ACImpl *This = impl_from_IAudioClient(iface);
563 ref = InterlockedIncrement(&This->ref);
564 TRACE("(%p) Refcount now %u\n", This, ref);
568 static ULONG WINAPI AudioClient_Release(IAudioClient *iface)
570 ACImpl *This = impl_from_IAudioClient(iface);
572 ref = InterlockedDecrement(&This->ref);
573 TRACE("(%p) Refcount now %u\n", This, ref);
575 IAudioClient_Stop(iface);
576 IMMDevice_Release(This->parent);
577 DeleteCriticalSection(&This->lock);
580 EnterCriticalSection(&g_sessions_lock);
581 list_remove(&This->entry);
582 LeaveCriticalSection(&g_sessions_lock);
584 HeapFree(GetProcessHeap(), 0, This->vols);
585 HeapFree(GetProcessHeap(), 0, This->local_buffer);
586 HeapFree(GetProcessHeap(), 0, This->tmp_buffer);
587 CoTaskMemFree(This->fmt);
588 HeapFree(GetProcessHeap(), 0, This);
593 static void dump_fmt(const WAVEFORMATEX *fmt)
595 TRACE("wFormatTag: 0x%x (", fmt->wFormatTag);
596 switch(fmt->wFormatTag){
597 case WAVE_FORMAT_PCM:
598 TRACE("WAVE_FORMAT_PCM");
600 case WAVE_FORMAT_IEEE_FLOAT:
601 TRACE("WAVE_FORMAT_IEEE_FLOAT");
603 case WAVE_FORMAT_EXTENSIBLE:
604 TRACE("WAVE_FORMAT_EXTENSIBLE");
612 TRACE("nChannels: %u\n", fmt->nChannels);
613 TRACE("nSamplesPerSec: %u\n", fmt->nSamplesPerSec);
614 TRACE("nAvgBytesPerSec: %u\n", fmt->nAvgBytesPerSec);
615 TRACE("nBlockAlign: %u\n", fmt->nBlockAlign);
616 TRACE("wBitsPerSample: %u\n", fmt->wBitsPerSample);
617 TRACE("cbSize: %u\n", fmt->cbSize);
619 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
620 WAVEFORMATEXTENSIBLE *fmtex = (void*)fmt;
621 TRACE("dwChannelMask: %08x\n", fmtex->dwChannelMask);
622 TRACE("Samples: %04x\n", fmtex->Samples.wReserved);
623 TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex->SubFormat));
627 static DWORD get_channel_mask(unsigned int channels)
633 return KSAUDIO_SPEAKER_MONO;
635 return KSAUDIO_SPEAKER_STEREO;
637 return KSAUDIO_SPEAKER_STEREO | SPEAKER_LOW_FREQUENCY;
639 return KSAUDIO_SPEAKER_QUAD; /* not _SURROUND */
641 return KSAUDIO_SPEAKER_QUAD | SPEAKER_LOW_FREQUENCY;
643 return KSAUDIO_SPEAKER_5POINT1; /* not 5POINT1_SURROUND */
645 return KSAUDIO_SPEAKER_5POINT1 | SPEAKER_BACK_CENTER;
647 return KSAUDIO_SPEAKER_7POINT1; /* not 7POINT1_SURROUND */
649 FIXME("Unknown speaker configuration: %u\n", channels);
653 static int get_oss_format(const WAVEFORMATEX *fmt)
655 WAVEFORMATEXTENSIBLE *fmtex = (WAVEFORMATEXTENSIBLE*)fmt;
657 if(fmt->wFormatTag == WAVE_FORMAT_PCM ||
658 (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
659 IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))){
660 switch(fmt->wBitsPerSample){
674 if(fmt->wFormatTag == WAVE_FORMAT_IEEE_FLOAT ||
675 (fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
676 IsEqualGUID(&fmtex->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT))){
677 if(fmt->wBitsPerSample != 32)
687 static WAVEFORMATEX *clone_format(const WAVEFORMATEX *fmt)
692 if(fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
693 size = sizeof(WAVEFORMATEXTENSIBLE);
695 size = sizeof(WAVEFORMATEX);
697 ret = CoTaskMemAlloc(size);
701 memcpy(ret, fmt, size);
703 ret->cbSize = size - sizeof(WAVEFORMATEX);
708 static HRESULT setup_oss_device(int fd, const WAVEFORMATEX *fmt,
709 WAVEFORMATEX **out, BOOL query)
714 WAVEFORMATEXTENSIBLE *fmtex = (void*)fmt;
715 WAVEFORMATEX *closest = NULL;
717 tmp = oss_format = get_oss_format(fmt);
719 return AUDCLNT_E_UNSUPPORTED_FORMAT;
720 if(ioctl(fd, SNDCTL_DSP_SETFMT, &tmp) < 0){
721 WARN("SETFMT failed: %d (%s)\n", errno, strerror(errno));
724 if(tmp != oss_format){
725 TRACE("Format unsupported by this OSS version: %x\n", oss_format);
726 return AUDCLNT_E_UNSUPPORTED_FORMAT;
729 closest = clone_format(fmt);
731 return E_OUTOFMEMORY;
733 tmp = fmt->nSamplesPerSec;
734 if(ioctl(fd, SNDCTL_DSP_SPEED, &tmp) < 0){
735 WARN("SPEED failed: %d (%s)\n", errno, strerror(errno));
736 CoTaskMemFree(closest);
739 tenth = fmt->nSamplesPerSec * 0.1;
740 if(tmp > fmt->nSamplesPerSec + tenth || tmp < fmt->nSamplesPerSec - tenth){
742 closest->nSamplesPerSec = tmp;
745 tmp = fmt->nChannels;
746 if(ioctl(fd, SNDCTL_DSP_CHANNELS, &tmp) < 0){
747 WARN("CHANNELS failed: %d (%s)\n", errno, strerror(errno));
748 CoTaskMemFree(closest);
751 if(tmp != fmt->nChannels){
753 closest->nChannels = tmp;
756 if(closest->wFormatTag == WAVE_FORMAT_EXTENSIBLE){
757 DWORD mask = get_channel_mask(closest->nChannels);
759 ((WAVEFORMATEXTENSIBLE*)closest)->dwChannelMask = mask;
761 if(query && fmt->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
762 fmtex->dwChannelMask != 0 &&
763 fmtex->dwChannelMask != mask)
767 if(ret == S_FALSE && !out)
768 ret = AUDCLNT_E_UNSUPPORTED_FORMAT;
770 if(ret == S_FALSE && out){
771 closest->nBlockAlign =
772 closest->nChannels * closest->wBitsPerSample / 8;
773 closest->nAvgBytesPerSec =
774 closest->nBlockAlign * closest->nSamplesPerSec;
777 CoTaskMemFree(closest);
779 TRACE("returning: %08x\n", ret);
783 static void session_init_vols(AudioSession *session, UINT channels)
785 if(session->channel_count < channels){
788 if(session->channel_vols)
789 session->channel_vols = HeapReAlloc(GetProcessHeap(), 0,
790 session->channel_vols, sizeof(float) * channels);
792 session->channel_vols = HeapAlloc(GetProcessHeap(), 0,
793 sizeof(float) * channels);
794 if(!session->channel_vols)
797 for(i = session->channel_count; i < channels; ++i)
798 session->channel_vols[i] = 1.f;
800 session->channel_count = channels;
804 static AudioSession *create_session(const GUID *guid, IMMDevice *device,
809 ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(AudioSession));
813 memcpy(&ret->guid, guid, sizeof(GUID));
815 ret->device = device;
817 list_init(&ret->clients);
819 list_add_head(&g_sessions, &ret->entry);
821 InitializeCriticalSection(&ret->lock);
823 session_init_vols(ret, num_channels);
825 ret->master_vol = 1.f;
830 /* if channels == 0, then this will return or create a session with
831 * matching dataflow and GUID. otherwise, channels must also match */
832 static HRESULT get_audio_session(const GUID *sessionguid,
833 IMMDevice *device, UINT channels, AudioSession **out)
835 AudioSession *session;
837 if(!sessionguid || IsEqualGUID(sessionguid, &GUID_NULL)){
838 *out = create_session(&GUID_NULL, device, channels);
840 return E_OUTOFMEMORY;
846 LIST_FOR_EACH_ENTRY(session, &g_sessions, AudioSession, entry){
847 if(session->device == device &&
848 IsEqualGUID(sessionguid, &session->guid)){
849 session_init_vols(session, channels);
856 *out = create_session(sessionguid, device, channels);
858 return E_OUTOFMEMORY;
864 static HRESULT WINAPI AudioClient_Initialize(IAudioClient *iface,
865 AUDCLNT_SHAREMODE mode, DWORD flags, REFERENCE_TIME duration,
866 REFERENCE_TIME period, const WAVEFORMATEX *fmt,
867 const GUID *sessionguid)
869 ACImpl *This = impl_from_IAudioClient(iface);
873 TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This, mode, flags,
874 wine_dbgstr_longlong(duration), wine_dbgstr_longlong(period), fmt, debugstr_guid(sessionguid));
881 if(mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
882 return AUDCLNT_E_NOT_INITIALIZED;
884 if(flags & ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS |
885 AUDCLNT_STREAMFLAGS_LOOPBACK |
886 AUDCLNT_STREAMFLAGS_EVENTCALLBACK |
887 AUDCLNT_STREAMFLAGS_NOPERSIST |
888 AUDCLNT_STREAMFLAGS_RATEADJUST |
889 AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED |
890 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE |
891 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED)){
892 TRACE("Unknown flags: %08x\n", flags);
896 EnterCriticalSection(&This->lock);
899 LeaveCriticalSection(&This->lock);
900 return AUDCLNT_E_ALREADY_INITIALIZED;
903 hr = setup_oss_device(This->fd, fmt, NULL, FALSE);
905 LeaveCriticalSection(&This->lock);
910 if(ioctl(This->fd, SNDCTL_DSP_SETTRIGGER, &mask) < 0){
911 LeaveCriticalSection(&This->lock);
912 WARN("SETTRIGGER failed: %d (%s)\n", errno, strerror(errno));
916 mask = (100 << 8) | 100;
917 if(ioctl(This->fd, SNDCTL_DSP_SETPLAYVOL, &mask) < 0)
918 WARN("SETPLAYVOL failed: %d (%s)\n", errno, strerror(errno));
920 This->fmt = clone_format(fmt);
922 LeaveCriticalSection(&This->lock);
923 return E_OUTOFMEMORY;
927 This->period_us = period / 10;
929 This->period_us = DefaultPeriod / 10;
932 duration = 300000; /* 0.03s */
933 This->bufsize_frames = ceil(fmt->nSamplesPerSec * (duration / 10000000.));
934 This->local_buffer = HeapAlloc(GetProcessHeap(), 0,
935 This->bufsize_frames * fmt->nBlockAlign);
936 if(!This->local_buffer){
937 CoTaskMemFree(This->fmt);
939 LeaveCriticalSection(&This->lock);
940 return E_OUTOFMEMORY;
943 This->vols = HeapAlloc(GetProcessHeap(), 0, fmt->nChannels * sizeof(float));
945 CoTaskMemFree(This->fmt);
947 LeaveCriticalSection(&This->lock);
948 return E_OUTOFMEMORY;
951 for(i = 0; i < fmt->nChannels; ++i)
957 EnterCriticalSection(&g_sessions_lock);
959 hr = get_audio_session(sessionguid, This->parent, fmt->nChannels,
962 LeaveCriticalSection(&g_sessions_lock);
963 HeapFree(GetProcessHeap(), 0, This->vols);
965 CoTaskMemFree(This->fmt);
967 LeaveCriticalSection(&This->lock);
971 list_add_tail(&This->session->clients, &This->entry);
973 LeaveCriticalSection(&g_sessions_lock);
975 This->initted = TRUE;
977 oss_setvol(This, -1);
979 LeaveCriticalSection(&This->lock);
984 static HRESULT WINAPI AudioClient_GetBufferSize(IAudioClient *iface,
987 ACImpl *This = impl_from_IAudioClient(iface);
989 TRACE("(%p)->(%p)\n", This, frames);
994 EnterCriticalSection(&This->lock);
997 LeaveCriticalSection(&This->lock);
998 return AUDCLNT_E_NOT_INITIALIZED;
1001 *frames = This->bufsize_frames;
1003 LeaveCriticalSection(&This->lock);
1008 static HRESULT WINAPI AudioClient_GetStreamLatency(IAudioClient *iface,
1009 REFERENCE_TIME *latency)
1011 ACImpl *This = impl_from_IAudioClient(iface);
1013 TRACE("(%p)->(%p)\n", This, latency);
1018 EnterCriticalSection(&This->lock);
1021 LeaveCriticalSection(&This->lock);
1022 return AUDCLNT_E_NOT_INITIALIZED;
1025 if(This->dataflow == eRender){
1029 if(ioctl(This->fd, SNDCTL_DSP_GETODELAY, &delay_bytes) < 0){
1030 LeaveCriticalSection(&This->lock);
1031 WARN("GETODELAY failed: %d (%s)\n", errno, strerror(errno));
1035 delay_s = delay_bytes / (double)(This->fmt->nSamplesPerSec *
1036 This->fmt->nBlockAlign);
1038 *latency = delay_s * 10000000;
1040 *latency = 10000; /* OSS doesn't provide input latency */
1042 LeaveCriticalSection(&This->lock);
1047 static HRESULT WINAPI AudioClient_GetCurrentPadding(IAudioClient *iface,
1050 ACImpl *This = impl_from_IAudioClient(iface);
1053 TRACE("(%p)->(%p)\n", This, numpad);
1058 EnterCriticalSection(&This->lock);
1061 LeaveCriticalSection(&This->lock);
1062 return AUDCLNT_E_NOT_INITIALIZED;
1065 if(This->dataflow == eRender){
1066 if(ioctl(This->fd, SNDCTL_DSP_GETOSPACE, &bi) < 0){
1067 LeaveCriticalSection(&This->lock);
1068 WARN("GETOSPACE failed: %d (%s)\n", errno, strerror(errno));
1072 *numpad = (bi.fragstotal * bi.fragsize - bi.bytes) /
1073 This->fmt->nBlockAlign;
1075 /* when the OSS buffer has less than one fragment of data, including
1076 * no data, it often reports it as some non-zero portion of a
1077 * fragment. when it has more than one fragment of data, it reports
1078 * it as some multiple of that portion of the fragment size.
1080 * so, we have to do some ugly workarounds to report the timing
1081 * as accurately as possible */
1082 if(*numpad < bi.fragsize / This->fmt->nBlockAlign){
1083 *numpad = This->inbuf_frames;
1084 This->inbuf_frames = 0;
1086 if(*numpad < This->inbuf_frames)
1087 This->inbuf_frames = *numpad;
1089 *numpad = This->inbuf_frames;
1091 }else if(This->dataflow == eCapture){
1092 if(ioctl(This->fd, SNDCTL_DSP_GETISPACE, &bi) < 0){
1093 LeaveCriticalSection(&This->lock);
1094 WARN("GETISPACE failed: %d (%s)\n", errno, strerror(errno));
1098 if(bi.bytes <= bi.fragsize)
1101 *numpad = bi.bytes / This->fmt->nBlockAlign;
1103 LeaveCriticalSection(&This->lock);
1104 return E_UNEXPECTED;
1107 *numpad += This->held_frames;
1109 LeaveCriticalSection(&This->lock);
1114 static HRESULT WINAPI AudioClient_IsFormatSupported(IAudioClient *iface,
1115 AUDCLNT_SHAREMODE mode, const WAVEFORMATEX *pwfx,
1116 WAVEFORMATEX **outpwfx)
1118 ACImpl *This = impl_from_IAudioClient(iface);
1122 TRACE("(%p)->(%x, %p, %p)\n", This, mode, pwfx, outpwfx);
1124 if(!pwfx || (mode == AUDCLNT_SHAREMODE_SHARED && !outpwfx))
1127 if(mode != AUDCLNT_SHAREMODE_SHARED && mode != AUDCLNT_SHAREMODE_EXCLUSIVE)
1128 return E_INVALIDARG;
1130 if(pwfx->wFormatTag == WAVE_FORMAT_EXTENSIBLE &&
1131 pwfx->cbSize < sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX))
1132 return E_INVALIDARG;
1138 if(mode != AUDCLNT_SHAREMODE_SHARED)
1142 if(This->dataflow == eRender)
1143 fd = open(This->devnode, O_WRONLY, 0);
1144 else if(This->dataflow == eCapture)
1145 fd = open(This->devnode, O_RDONLY, 0);
1148 ERR("Unable to open device %s: %d (%s)\n", This->devnode, errno,
1150 return AUDCLNT_E_DEVICE_INVALIDATED;
1153 ret = setup_oss_device(fd, pwfx, outpwfx, TRUE);
1160 static HRESULT WINAPI AudioClient_GetMixFormat(IAudioClient *iface,
1161 WAVEFORMATEX **pwfx)
1163 ACImpl *This = impl_from_IAudioClient(iface);
1164 WAVEFORMATEXTENSIBLE *fmt;
1167 TRACE("(%p)->(%p)\n", This, pwfx);
1173 if(This->dataflow == eRender)
1174 formats = This->ai.oformats;
1175 else if(This->dataflow == eCapture)
1176 formats = This->ai.iformats;
1178 return E_UNEXPECTED;
1180 fmt = CoTaskMemAlloc(sizeof(WAVEFORMATEXTENSIBLE));
1182 return E_OUTOFMEMORY;
1184 fmt->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
1185 if(formats & AFMT_S16_LE){
1186 fmt->Format.wBitsPerSample = 16;
1187 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1189 }else if(formats & AFMT_FLOAT){
1190 fmt->Format.wBitsPerSample = 32;
1191 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
1193 }else if(formats & AFMT_U8){
1194 fmt->Format.wBitsPerSample = 8;
1195 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1196 }else if(formats & AFMT_S32_LE){
1197 fmt->Format.wBitsPerSample = 32;
1198 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1199 }else if(formats & AFMT_S24_LE){
1200 fmt->Format.wBitsPerSample = 24;
1201 fmt->SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1203 ERR("Didn't recognize any available OSS formats: %x\n", formats);
1208 fmt->Format.nChannels = This->ai.max_channels;
1209 fmt->Format.nSamplesPerSec = This->ai.max_rate;
1210 fmt->dwChannelMask = get_channel_mask(fmt->Format.nChannels);
1212 fmt->Format.nBlockAlign = (fmt->Format.wBitsPerSample *
1213 fmt->Format.nChannels) / 8;
1214 fmt->Format.nAvgBytesPerSec = fmt->Format.nSamplesPerSec *
1215 fmt->Format.nBlockAlign;
1217 fmt->Samples.wValidBitsPerSample = fmt->Format.wBitsPerSample;
1218 fmt->Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
1220 *pwfx = (WAVEFORMATEX*)fmt;
1226 static HRESULT WINAPI AudioClient_GetDevicePeriod(IAudioClient *iface,
1227 REFERENCE_TIME *defperiod, REFERENCE_TIME *minperiod)
1229 ACImpl *This = impl_from_IAudioClient(iface);
1231 TRACE("(%p)->(%p, %p)\n", This, defperiod, minperiod);
1233 if(!defperiod && !minperiod)
1236 EnterCriticalSection(&This->lock);
1239 *defperiod = DefaultPeriod;
1241 *minperiod = MinimumPeriod;
1243 LeaveCriticalSection(&This->lock);
1248 static void oss_silence_buffer(ACImpl *This, BYTE *buf, UINT32 frames)
1250 if(This->fmt->wBitsPerSample == 8)
1251 memset(buf, 128, frames * This->fmt->nBlockAlign);
1253 memset(buf, 0, frames * This->fmt->nBlockAlign);
1256 static void oss_write_data(ACImpl *This)
1258 ssize_t written_bytes;
1259 UINT32 written_frames;
1260 size_t to_write_frames, to_write_bytes;
1263 This->local_buffer + (This->lcl_offs_frames * This->fmt->nBlockAlign);
1265 if(This->lcl_offs_frames + This->held_frames > This->bufsize_frames)
1266 to_write_frames = This->bufsize_frames - This->lcl_offs_frames;
1268 to_write_frames = This->held_frames;
1269 to_write_bytes = to_write_frames * This->fmt->nBlockAlign;
1271 if(ioctl(This->fd, SNDCTL_DSP_GETOSPACE, &bi) < 0){
1272 WARN("GETOSPACE failed: %d (%s)\n", errno, strerror(errno));
1276 if(bi.bytes < to_write_bytes){
1277 to_write_frames = bi.bytes / This->fmt->nBlockAlign;
1278 to_write_bytes = to_write_frames * This->fmt->nBlockAlign;
1281 if(This->session->mute)
1282 oss_silence_buffer(This, buf, to_write_frames);
1284 written_bytes = write(This->fd, buf, to_write_bytes);
1285 if(written_bytes < 0){
1286 /* EAGAIN is OSS buffer full, log that too */
1287 WARN("write failed: %d (%s)\n", errno, strerror(errno));
1290 written_frames = written_bytes / This->fmt->nBlockAlign;
1292 This->lcl_offs_frames += written_frames;
1293 This->lcl_offs_frames %= This->bufsize_frames;
1294 This->held_frames -= written_frames;
1295 This->inbuf_frames += written_frames;
1297 if(written_frames < to_write_frames){
1298 /* OSS buffer probably full */
1302 bi.bytes -= written_bytes;
1303 if(This->held_frames && bi.bytes >= This->fmt->nBlockAlign){
1304 /* wrapped and have some data back at the start to write */
1306 to_write_frames = bi.bytes / This->fmt->nBlockAlign;
1307 to_write_bytes = to_write_frames * This->fmt->nBlockAlign;
1309 if(This->session->mute)
1310 oss_silence_buffer(This, This->local_buffer, to_write_frames);
1312 written_bytes = write(This->fd, This->local_buffer, to_write_bytes);
1313 if(written_bytes < 0){
1314 WARN("write failed: %d (%s)\n", errno, strerror(errno));
1317 written_frames = written_bytes / This->fmt->nBlockAlign;
1319 This->lcl_offs_frames += written_frames;
1320 This->lcl_offs_frames %= This->bufsize_frames;
1321 This->held_frames -= written_frames;
1322 This->inbuf_frames += written_frames;
1326 static void oss_read_data(ACImpl *This)
1328 UINT64 pos, readable;
1332 if(ioctl(This->fd, SNDCTL_DSP_GETISPACE, &bi) < 0){
1333 WARN("GETISPACE failed: %d (%s)\n", errno, strerror(errno));
1337 pos = (This->held_frames + This->lcl_offs_frames) % This->bufsize_frames;
1338 readable = (This->bufsize_frames - pos) * This->fmt->nBlockAlign;
1340 if(bi.bytes < readable)
1341 readable = bi.bytes;
1343 nread = read(This->fd, This->local_buffer + pos * This->fmt->nBlockAlign,
1346 WARN("read failed: %d (%s)\n", errno, strerror(errno));
1350 This->held_frames += nread / This->fmt->nBlockAlign;
1352 if(This->held_frames > This->bufsize_frames){
1353 WARN("Overflow of unread data\n");
1354 This->lcl_offs_frames += This->held_frames;
1355 This->lcl_offs_frames %= This->bufsize_frames;
1356 This->held_frames = This->bufsize_frames;
1360 static void CALLBACK oss_period_callback(void *user, BOOLEAN timer)
1362 ACImpl *This = user;
1364 EnterCriticalSection(&This->lock);
1366 if(This->dataflow == eRender && This->held_frames)
1367 oss_write_data(This);
1368 else if(This->dataflow == eCapture)
1369 oss_read_data(This);
1372 SetEvent(This->event);
1374 LeaveCriticalSection(&This->lock);
1377 static HRESULT WINAPI AudioClient_Start(IAudioClient *iface)
1379 ACImpl *This = impl_from_IAudioClient(iface);
1382 TRACE("(%p)\n", This);
1384 EnterCriticalSection(&This->lock);
1387 LeaveCriticalSection(&This->lock);
1388 return AUDCLNT_E_NOT_INITIALIZED;
1391 if((This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK) && !This->event){
1392 LeaveCriticalSection(&This->lock);
1393 return AUDCLNT_E_EVENTHANDLE_NOT_SET;
1397 LeaveCriticalSection(&This->lock);
1398 return AUDCLNT_E_NOT_STOPPED;
1401 if(This->dataflow == eRender)
1402 mask = PCM_ENABLE_OUTPUT;
1403 else if(This->dataflow == eCapture)
1404 mask = PCM_ENABLE_INPUT;
1406 LeaveCriticalSection(&This->lock);
1407 return E_UNEXPECTED;
1410 if(ioctl(This->fd, SNDCTL_DSP_SETTRIGGER, &mask) < 0){
1411 LeaveCriticalSection(&This->lock);
1412 WARN("SETTRIGGER failed: %d (%s)\n", errno, strerror(errno));
1416 if(!CreateTimerQueueTimer(&This->timer, g_timer_q,
1417 oss_period_callback, This, 0, This->period_us / 1000,
1418 WT_EXECUTEINTIMERTHREAD))
1419 ERR("Unable to create period timer: %u\n", GetLastError());
1421 This->playing = TRUE;
1423 LeaveCriticalSection(&This->lock);
1428 static HRESULT WINAPI AudioClient_Stop(IAudioClient *iface)
1430 ACImpl *This = impl_from_IAudioClient(iface);
1433 TRACE("(%p)\n", This);
1435 EnterCriticalSection(&This->lock);
1438 LeaveCriticalSection(&This->lock);
1439 return AUDCLNT_E_NOT_INITIALIZED;
1443 LeaveCriticalSection(&This->lock);
1447 if(This->timer && This->timer != INVALID_HANDLE_VALUE){
1448 DeleteTimerQueueTimer(g_timer_q, This->timer,
1449 INVALID_HANDLE_VALUE);
1453 if(ioctl(This->fd, SNDCTL_DSP_HALT, NULL) < 0){
1454 LeaveCriticalSection(&This->lock);
1455 WARN("HALT failed: %d (%s)\n", errno, strerror(errno));
1460 if(ioctl(This->fd, SNDCTL_DSP_SETTRIGGER, &mask) < 0){
1461 LeaveCriticalSection(&This->lock);
1462 WARN("SETTRIGGER failed: %d (%s)\n", errno, strerror(errno));
1466 This->playing = FALSE;
1468 LeaveCriticalSection(&This->lock);
1473 static HRESULT WINAPI AudioClient_Reset(IAudioClient *iface)
1475 ACImpl *This = impl_from_IAudioClient(iface);
1477 TRACE("(%p)\n", This);
1479 EnterCriticalSection(&This->lock);
1482 LeaveCriticalSection(&This->lock);
1483 return AUDCLNT_E_NOT_INITIALIZED;
1487 LeaveCriticalSection(&This->lock);
1488 return AUDCLNT_E_NOT_STOPPED;
1491 if(This->buf_state != NOT_LOCKED){
1492 LeaveCriticalSection(&This->lock);
1493 return AUDCLNT_E_BUFFER_OPERATION_PENDING;
1496 This->written_frames = 0;
1497 This->inbuf_frames = 0;
1498 This->held_frames = 0;
1500 if(ioctl(This->fd, SNDCTL_DSP_SKIP, NULL) < 0)
1501 WARN("SKIP failed: %d (%s)\n", errno, strerror(errno));
1503 LeaveCriticalSection(&This->lock);
1508 static HRESULT WINAPI AudioClient_SetEventHandle(IAudioClient *iface,
1511 ACImpl *This = impl_from_IAudioClient(iface);
1513 TRACE("(%p)->(%p)\n", This, event);
1516 return E_INVALIDARG;
1518 EnterCriticalSection(&This->lock);
1521 LeaveCriticalSection(&This->lock);
1522 return AUDCLNT_E_NOT_INITIALIZED;
1525 if(!(This->flags & AUDCLNT_STREAMFLAGS_EVENTCALLBACK)){
1526 LeaveCriticalSection(&This->lock);
1527 return AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED;
1530 This->event = event;
1532 LeaveCriticalSection(&This->lock);
1537 static HRESULT WINAPI AudioClient_GetService(IAudioClient *iface, REFIID riid,
1540 ACImpl *This = impl_from_IAudioClient(iface);
1542 TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppv);
1548 EnterCriticalSection(&This->lock);
1551 LeaveCriticalSection(&This->lock);
1552 return AUDCLNT_E_NOT_INITIALIZED;
1555 if(IsEqualIID(riid, &IID_IAudioRenderClient)){
1556 if(This->dataflow != eRender){
1557 LeaveCriticalSection(&This->lock);
1558 return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
1560 IAudioRenderClient_AddRef(&This->IAudioRenderClient_iface);
1561 *ppv = &This->IAudioRenderClient_iface;
1562 }else if(IsEqualIID(riid, &IID_IAudioCaptureClient)){
1563 if(This->dataflow != eCapture){
1564 LeaveCriticalSection(&This->lock);
1565 return AUDCLNT_E_WRONG_ENDPOINT_TYPE;
1567 IAudioCaptureClient_AddRef(&This->IAudioCaptureClient_iface);
1568 *ppv = &This->IAudioCaptureClient_iface;
1569 }else if(IsEqualIID(riid, &IID_IAudioClock)){
1570 IAudioClock_AddRef(&This->IAudioClock_iface);
1571 *ppv = &This->IAudioClock_iface;
1572 }else if(IsEqualIID(riid, &IID_IAudioStreamVolume)){
1573 IAudioStreamVolume_AddRef(&This->IAudioStreamVolume_iface);
1574 *ppv = &This->IAudioStreamVolume_iface;
1575 }else if(IsEqualIID(riid, &IID_IAudioSessionControl)){
1576 if(!This->session_wrapper){
1577 This->session_wrapper = AudioSessionWrapper_Create(This);
1578 if(!This->session_wrapper){
1579 LeaveCriticalSection(&This->lock);
1580 return E_OUTOFMEMORY;
1583 IAudioSessionControl2_AddRef(&This->session_wrapper->IAudioSessionControl2_iface);
1585 *ppv = &This->session_wrapper->IAudioSessionControl2_iface;
1586 }else if(IsEqualIID(riid, &IID_IChannelAudioVolume)){
1587 if(!This->session_wrapper){
1588 This->session_wrapper = AudioSessionWrapper_Create(This);
1589 if(!This->session_wrapper){
1590 LeaveCriticalSection(&This->lock);
1591 return E_OUTOFMEMORY;
1594 IChannelAudioVolume_AddRef(&This->session_wrapper->IChannelAudioVolume_iface);
1596 *ppv = &This->session_wrapper->IChannelAudioVolume_iface;
1597 }else if(IsEqualIID(riid, &IID_ISimpleAudioVolume)){
1598 if(!This->session_wrapper){
1599 This->session_wrapper = AudioSessionWrapper_Create(This);
1600 if(!This->session_wrapper){
1601 LeaveCriticalSection(&This->lock);
1602 return E_OUTOFMEMORY;
1605 ISimpleAudioVolume_AddRef(&This->session_wrapper->ISimpleAudioVolume_iface);
1607 *ppv = &This->session_wrapper->ISimpleAudioVolume_iface;
1611 LeaveCriticalSection(&This->lock);
1615 LeaveCriticalSection(&This->lock);
1617 FIXME("stub %s\n", debugstr_guid(riid));
1618 return E_NOINTERFACE;
1621 static const IAudioClientVtbl AudioClient_Vtbl =
1623 AudioClient_QueryInterface,
1625 AudioClient_Release,
1626 AudioClient_Initialize,
1627 AudioClient_GetBufferSize,
1628 AudioClient_GetStreamLatency,
1629 AudioClient_GetCurrentPadding,
1630 AudioClient_IsFormatSupported,
1631 AudioClient_GetMixFormat,
1632 AudioClient_GetDevicePeriod,
1636 AudioClient_SetEventHandle,
1637 AudioClient_GetService
1640 static HRESULT WINAPI AudioRenderClient_QueryInterface(
1641 IAudioRenderClient *iface, REFIID riid, void **ppv)
1643 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1649 if(IsEqualIID(riid, &IID_IUnknown) ||
1650 IsEqualIID(riid, &IID_IAudioRenderClient))
1653 IUnknown_AddRef((IUnknown*)*ppv);
1657 WARN("Unknown interface %s\n", debugstr_guid(riid));
1658 return E_NOINTERFACE;
1661 static ULONG WINAPI AudioRenderClient_AddRef(IAudioRenderClient *iface)
1663 ACImpl *This = impl_from_IAudioRenderClient(iface);
1664 return AudioClient_AddRef(&This->IAudioClient_iface);
1667 static ULONG WINAPI AudioRenderClient_Release(IAudioRenderClient *iface)
1669 ACImpl *This = impl_from_IAudioRenderClient(iface);
1670 return AudioClient_Release(&This->IAudioClient_iface);
1673 static HRESULT WINAPI AudioRenderClient_GetBuffer(IAudioRenderClient *iface,
1674 UINT32 frames, BYTE **data)
1676 ACImpl *This = impl_from_IAudioRenderClient(iface);
1677 UINT32 pad, write_pos;
1680 TRACE("(%p)->(%u, %p)\n", This, frames, data);
1685 EnterCriticalSection(&This->lock);
1687 if(This->buf_state != NOT_LOCKED){
1688 LeaveCriticalSection(&This->lock);
1689 return AUDCLNT_E_OUT_OF_ORDER;
1693 This->buf_state = LOCKED_NORMAL;
1694 LeaveCriticalSection(&This->lock);
1698 hr = IAudioClient_GetCurrentPadding(&This->IAudioClient_iface, &pad);
1700 LeaveCriticalSection(&This->lock);
1704 if(pad + frames > This->bufsize_frames){
1705 LeaveCriticalSection(&This->lock);
1706 return AUDCLNT_E_BUFFER_TOO_LARGE;
1710 (This->lcl_offs_frames + This->held_frames) % This->bufsize_frames;
1711 if(write_pos + frames > This->bufsize_frames){
1712 if(This->tmp_buffer_frames < frames){
1713 if(This->tmp_buffer)
1714 This->tmp_buffer = HeapReAlloc(GetProcessHeap(), 0,
1715 This->tmp_buffer, frames * This->fmt->nBlockAlign);
1717 This->tmp_buffer = HeapAlloc(GetProcessHeap(), 0,
1718 frames * This->fmt->nBlockAlign);
1719 if(!This->tmp_buffer){
1720 LeaveCriticalSection(&This->lock);
1721 return E_OUTOFMEMORY;
1723 This->tmp_buffer_frames = frames;
1725 *data = This->tmp_buffer;
1726 This->buf_state = LOCKED_WRAPPED;
1728 *data = This->local_buffer + write_pos * This->fmt->nBlockAlign;
1729 This->buf_state = LOCKED_NORMAL;
1732 LeaveCriticalSection(&This->lock);
1737 static void oss_wrap_buffer(ACImpl *This, BYTE *buffer, UINT32 written_frames)
1739 UINT32 write_offs_frames =
1740 (This->lcl_offs_frames + This->held_frames) % This->bufsize_frames;
1741 UINT32 write_offs_bytes = write_offs_frames * This->fmt->nBlockAlign;
1742 UINT32 chunk_frames = This->bufsize_frames - write_offs_frames;
1743 UINT32 chunk_bytes = chunk_frames * This->fmt->nBlockAlign;
1744 UINT32 written_bytes = written_frames * This->fmt->nBlockAlign;
1746 if(written_bytes <= chunk_bytes){
1747 memcpy(This->local_buffer + write_offs_bytes, buffer, written_bytes);
1749 memcpy(This->local_buffer + write_offs_bytes, buffer, chunk_bytes);
1750 memcpy(This->local_buffer, buffer + chunk_bytes,
1751 written_bytes - chunk_bytes);
1755 static HRESULT WINAPI AudioRenderClient_ReleaseBuffer(
1756 IAudioRenderClient *iface, UINT32 written_frames, DWORD flags)
1758 ACImpl *This = impl_from_IAudioRenderClient(iface);
1761 TRACE("(%p)->(%u, %x)\n", This, written_frames, flags);
1763 EnterCriticalSection(&This->lock);
1765 if(This->buf_state == NOT_LOCKED || !written_frames){
1766 This->buf_state = NOT_LOCKED;
1767 LeaveCriticalSection(&This->lock);
1768 return written_frames ? AUDCLNT_E_OUT_OF_ORDER : S_OK;
1771 if(This->buf_state == LOCKED_NORMAL)
1772 buffer = This->local_buffer + This->fmt->nBlockAlign *
1773 ((This->lcl_offs_frames + This->held_frames) % This->bufsize_frames);
1775 buffer = This->tmp_buffer;
1777 if(flags & AUDCLNT_BUFFERFLAGS_SILENT)
1778 oss_silence_buffer(This, buffer, written_frames);
1780 if(This->held_frames){
1781 if(This->buf_state == LOCKED_WRAPPED)
1782 oss_wrap_buffer(This, buffer, written_frames);
1784 This->held_frames += written_frames;
1789 if(This->session->mute)
1790 oss_silence_buffer(This, buffer, written_frames);
1792 w_bytes = write(This->fd, buffer,
1793 written_frames * This->fmt->nBlockAlign);
1795 if(errno != EAGAIN){
1796 This->buf_state = NOT_LOCKED;
1797 LeaveCriticalSection(&This->lock);
1798 ERR("write failed: %d (%s)\n", errno, strerror(errno));
1800 }else /* OSS buffer full */
1803 w_frames = w_bytes / This->fmt->nBlockAlign;
1804 This->inbuf_frames += w_frames;
1806 if(w_frames < written_frames){
1807 if(This->buf_state == LOCKED_WRAPPED)
1808 oss_wrap_buffer(This, This->tmp_buffer + w_bytes,
1809 written_frames - w_frames);
1811 This->lcl_offs_frames += w_frames;
1812 This->held_frames = written_frames - w_frames;
1816 This->written_frames += written_frames;
1817 This->buf_state = NOT_LOCKED;
1819 LeaveCriticalSection(&This->lock);
1824 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl = {
1825 AudioRenderClient_QueryInterface,
1826 AudioRenderClient_AddRef,
1827 AudioRenderClient_Release,
1828 AudioRenderClient_GetBuffer,
1829 AudioRenderClient_ReleaseBuffer
1832 static HRESULT WINAPI AudioCaptureClient_QueryInterface(
1833 IAudioCaptureClient *iface, REFIID riid, void **ppv)
1835 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1841 if(IsEqualIID(riid, &IID_IUnknown) ||
1842 IsEqualIID(riid, &IID_IAudioCaptureClient))
1845 IUnknown_AddRef((IUnknown*)*ppv);
1849 WARN("Unknown interface %s\n", debugstr_guid(riid));
1850 return E_NOINTERFACE;
1853 static ULONG WINAPI AudioCaptureClient_AddRef(IAudioCaptureClient *iface)
1855 ACImpl *This = impl_from_IAudioCaptureClient(iface);
1856 return IAudioClient_AddRef(&This->IAudioClient_iface);
1859 static ULONG WINAPI AudioCaptureClient_Release(IAudioCaptureClient *iface)
1861 ACImpl *This = impl_from_IAudioCaptureClient(iface);
1862 return IAudioClient_Release(&This->IAudioClient_iface);
1865 static HRESULT WINAPI AudioCaptureClient_GetBuffer(IAudioCaptureClient *iface,
1866 BYTE **data, UINT32 *frames, DWORD *flags, UINT64 *devpos,
1869 ACImpl *This = impl_from_IAudioCaptureClient(iface);
1872 TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This, data, frames, flags,
1875 if(!data || !frames || !flags)
1878 EnterCriticalSection(&This->lock);
1880 if(This->buf_state != NOT_LOCKED){
1881 LeaveCriticalSection(&This->lock);
1882 return AUDCLNT_E_OUT_OF_ORDER;
1885 hr = IAudioCaptureClient_GetNextPacketSize(iface, frames);
1887 LeaveCriticalSection(&This->lock);
1893 if(This->lcl_offs_frames + *frames > This->bufsize_frames){
1894 UINT32 chunk_bytes, offs_bytes, frames_bytes;
1895 if(This->tmp_buffer_frames < *frames){
1896 if(This->tmp_buffer)
1897 This->tmp_buffer = HeapReAlloc(GetProcessHeap(), 0,
1898 This->tmp_buffer, *frames * This->fmt->nBlockAlign);
1900 This->tmp_buffer = HeapAlloc(GetProcessHeap(), 0,
1901 *frames * This->fmt->nBlockAlign);
1902 if(!This->tmp_buffer){
1903 LeaveCriticalSection(&This->lock);
1904 return E_OUTOFMEMORY;
1906 This->tmp_buffer_frames = *frames;
1909 *data = This->tmp_buffer;
1910 chunk_bytes = (This->bufsize_frames - This->lcl_offs_frames) *
1911 This->fmt->nBlockAlign;
1912 offs_bytes = This->lcl_offs_frames * This->fmt->nBlockAlign;
1913 frames_bytes = *frames * This->fmt->nBlockAlign;
1914 memcpy(This->tmp_buffer, This->local_buffer + offs_bytes, chunk_bytes);
1915 memcpy(This->tmp_buffer, This->local_buffer,
1916 frames_bytes - chunk_bytes);
1918 *data = This->local_buffer +
1919 This->lcl_offs_frames * This->fmt->nBlockAlign;
1921 This->buf_state = LOCKED_NORMAL;
1923 if(devpos || qpcpos)
1924 IAudioClock_GetPosition(&This->IAudioClock_iface, devpos, qpcpos);
1926 LeaveCriticalSection(&This->lock);
1928 return *frames ? S_OK : AUDCLNT_S_BUFFER_EMPTY;
1931 static HRESULT WINAPI AudioCaptureClient_ReleaseBuffer(
1932 IAudioCaptureClient *iface, UINT32 done)
1934 ACImpl *This = impl_from_IAudioCaptureClient(iface);
1936 TRACE("(%p)->(%u)\n", This, done);
1938 EnterCriticalSection(&This->lock);
1940 if(This->buf_state == NOT_LOCKED){
1941 LeaveCriticalSection(&This->lock);
1942 return AUDCLNT_E_OUT_OF_ORDER;
1945 This->held_frames -= done;
1946 This->lcl_offs_frames += done;
1947 This->lcl_offs_frames %= This->bufsize_frames;
1949 This->buf_state = NOT_LOCKED;
1951 LeaveCriticalSection(&This->lock);
1956 static HRESULT WINAPI AudioCaptureClient_GetNextPacketSize(
1957 IAudioCaptureClient *iface, UINT32 *frames)
1959 ACImpl *This = impl_from_IAudioCaptureClient(iface);
1961 TRACE("(%p)->(%p)\n", This, frames);
1963 return AudioClient_GetCurrentPadding(&This->IAudioClient_iface, frames);
1966 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl =
1968 AudioCaptureClient_QueryInterface,
1969 AudioCaptureClient_AddRef,
1970 AudioCaptureClient_Release,
1971 AudioCaptureClient_GetBuffer,
1972 AudioCaptureClient_ReleaseBuffer,
1973 AudioCaptureClient_GetNextPacketSize
1976 static HRESULT WINAPI AudioClock_QueryInterface(IAudioClock *iface,
1977 REFIID riid, void **ppv)
1979 ACImpl *This = impl_from_IAudioClock(iface);
1981 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
1987 if(IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IAudioClock))
1989 else if(IsEqualIID(riid, &IID_IAudioClock2))
1990 *ppv = &This->IAudioClock2_iface;
1992 IUnknown_AddRef((IUnknown*)*ppv);
1996 WARN("Unknown interface %s\n", debugstr_guid(riid));
1997 return E_NOINTERFACE;
2000 static ULONG WINAPI AudioClock_AddRef(IAudioClock *iface)
2002 ACImpl *This = impl_from_IAudioClock(iface);
2003 return IAudioClient_AddRef(&This->IAudioClient_iface);
2006 static ULONG WINAPI AudioClock_Release(IAudioClock *iface)
2008 ACImpl *This = impl_from_IAudioClock(iface);
2009 return IAudioClient_Release(&This->IAudioClient_iface);
2012 static HRESULT WINAPI AudioClock_GetFrequency(IAudioClock *iface, UINT64 *freq)
2014 ACImpl *This = impl_from_IAudioClock(iface);
2016 TRACE("(%p)->(%p)\n", This, freq);
2018 *freq = This->fmt->nSamplesPerSec;
2023 static HRESULT WINAPI AudioClock_GetPosition(IAudioClock *iface, UINT64 *pos,
2026 ACImpl *This = impl_from_IAudioClock(iface);
2030 TRACE("(%p)->(%p, %p)\n", This, pos, qpctime);
2035 EnterCriticalSection(&This->lock);
2037 hr = IAudioClient_GetCurrentPadding(&This->IAudioClient_iface, &pad);
2039 LeaveCriticalSection(&This->lock);
2043 if(This->dataflow == eRender)
2044 *pos = This->written_frames - pad;
2045 else if(This->dataflow == eCapture)
2046 *pos = This->written_frames + pad;
2048 LeaveCriticalSection(&This->lock);
2051 LARGE_INTEGER stamp, freq;
2052 QueryPerformanceCounter(&stamp);
2053 QueryPerformanceFrequency(&freq);
2054 *qpctime = (stamp.QuadPart * (INT64)10000000) / freq.QuadPart;
2060 static HRESULT WINAPI AudioClock_GetCharacteristics(IAudioClock *iface,
2063 ACImpl *This = impl_from_IAudioClock(iface);
2065 TRACE("(%p)->(%p)\n", This, chars);
2070 *chars = AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ;
2075 static const IAudioClockVtbl AudioClock_Vtbl =
2077 AudioClock_QueryInterface,
2080 AudioClock_GetFrequency,
2081 AudioClock_GetPosition,
2082 AudioClock_GetCharacteristics
2085 static HRESULT WINAPI AudioClock2_QueryInterface(IAudioClock2 *iface,
2086 REFIID riid, void **ppv)
2088 ACImpl *This = impl_from_IAudioClock2(iface);
2089 return IAudioClock_QueryInterface(&This->IAudioClock_iface, riid, ppv);
2092 static ULONG WINAPI AudioClock2_AddRef(IAudioClock2 *iface)
2094 ACImpl *This = impl_from_IAudioClock2(iface);
2095 return IAudioClient_AddRef(&This->IAudioClient_iface);
2098 static ULONG WINAPI AudioClock2_Release(IAudioClock2 *iface)
2100 ACImpl *This = impl_from_IAudioClock2(iface);
2101 return IAudioClient_Release(&This->IAudioClient_iface);
2104 static HRESULT WINAPI AudioClock2_GetDevicePosition(IAudioClock2 *iface,
2105 UINT64 *pos, UINT64 *qpctime)
2107 ACImpl *This = impl_from_IAudioClock2(iface);
2109 FIXME("(%p)->(%p, %p)\n", This, pos, qpctime);
2114 static const IAudioClock2Vtbl AudioClock2_Vtbl =
2116 AudioClock2_QueryInterface,
2118 AudioClock2_Release,
2119 AudioClock2_GetDevicePosition
2122 static AudioSessionWrapper *AudioSessionWrapper_Create(ACImpl *client)
2124 AudioSessionWrapper *ret;
2126 ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
2127 sizeof(AudioSessionWrapper));
2131 ret->IAudioSessionControl2_iface.lpVtbl = &AudioSessionControl2_Vtbl;
2132 ret->ISimpleAudioVolume_iface.lpVtbl = &SimpleAudioVolume_Vtbl;
2133 ret->IChannelAudioVolume_iface.lpVtbl = &ChannelAudioVolume_Vtbl;
2137 ret->client = client;
2139 ret->session = client->session;
2140 AudioClient_AddRef(&client->IAudioClient_iface);
2146 static HRESULT WINAPI AudioSessionControl_QueryInterface(
2147 IAudioSessionControl2 *iface, REFIID riid, void **ppv)
2149 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2155 if(IsEqualIID(riid, &IID_IUnknown) ||
2156 IsEqualIID(riid, &IID_IAudioSessionControl) ||
2157 IsEqualIID(riid, &IID_IAudioSessionControl2))
2160 IUnknown_AddRef((IUnknown*)*ppv);
2164 WARN("Unknown interface %s\n", debugstr_guid(riid));
2165 return E_NOINTERFACE;
2168 static ULONG WINAPI AudioSessionControl_AddRef(IAudioSessionControl2 *iface)
2170 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2172 ref = InterlockedIncrement(&This->ref);
2173 TRACE("(%p) Refcount now %u\n", This, ref);
2177 static ULONG WINAPI AudioSessionControl_Release(IAudioSessionControl2 *iface)
2179 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2181 ref = InterlockedDecrement(&This->ref);
2182 TRACE("(%p) Refcount now %u\n", This, ref);
2185 EnterCriticalSection(&This->client->lock);
2186 This->client->session_wrapper = NULL;
2187 LeaveCriticalSection(&This->client->lock);
2188 AudioClient_Release(&This->client->IAudioClient_iface);
2190 HeapFree(GetProcessHeap(), 0, This);
2195 static HRESULT WINAPI AudioSessionControl_GetState(IAudioSessionControl2 *iface,
2196 AudioSessionState *state)
2198 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2201 TRACE("(%p)->(%p)\n", This, state);
2204 return NULL_PTR_ERR;
2206 EnterCriticalSection(&g_sessions_lock);
2208 if(list_empty(&This->session->clients)){
2209 *state = AudioSessionStateExpired;
2210 LeaveCriticalSection(&g_sessions_lock);
2214 LIST_FOR_EACH_ENTRY(client, &This->session->clients, ACImpl, entry){
2215 EnterCriticalSection(&client->lock);
2216 if(client->playing){
2217 *state = AudioSessionStateActive;
2218 LeaveCriticalSection(&client->lock);
2219 LeaveCriticalSection(&g_sessions_lock);
2222 LeaveCriticalSection(&client->lock);
2225 LeaveCriticalSection(&g_sessions_lock);
2227 *state = AudioSessionStateInactive;
2232 static HRESULT WINAPI AudioSessionControl_GetDisplayName(
2233 IAudioSessionControl2 *iface, WCHAR **name)
2235 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2237 FIXME("(%p)->(%p) - stub\n", This, name);
2242 static HRESULT WINAPI AudioSessionControl_SetDisplayName(
2243 IAudioSessionControl2 *iface, const WCHAR *name, const GUID *session)
2245 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2247 FIXME("(%p)->(%p, %s) - stub\n", This, name, debugstr_guid(session));
2252 static HRESULT WINAPI AudioSessionControl_GetIconPath(
2253 IAudioSessionControl2 *iface, WCHAR **path)
2255 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2257 FIXME("(%p)->(%p) - stub\n", This, path);
2262 static HRESULT WINAPI AudioSessionControl_SetIconPath(
2263 IAudioSessionControl2 *iface, const WCHAR *path, const GUID *session)
2265 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2267 FIXME("(%p)->(%p, %s) - stub\n", This, path, debugstr_guid(session));
2272 static HRESULT WINAPI AudioSessionControl_GetGroupingParam(
2273 IAudioSessionControl2 *iface, GUID *group)
2275 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2277 FIXME("(%p)->(%p) - stub\n", This, group);
2282 static HRESULT WINAPI AudioSessionControl_SetGroupingParam(
2283 IAudioSessionControl2 *iface, const GUID *group, const GUID *session)
2285 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2287 FIXME("(%p)->(%s, %s) - stub\n", This, debugstr_guid(group),
2288 debugstr_guid(session));
2293 static HRESULT WINAPI AudioSessionControl_RegisterAudioSessionNotification(
2294 IAudioSessionControl2 *iface, IAudioSessionEvents *events)
2296 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2298 FIXME("(%p)->(%p) - stub\n", This, events);
2303 static HRESULT WINAPI AudioSessionControl_UnregisterAudioSessionNotification(
2304 IAudioSessionControl2 *iface, IAudioSessionEvents *events)
2306 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2308 FIXME("(%p)->(%p) - stub\n", This, events);
2313 static HRESULT WINAPI AudioSessionControl_GetSessionIdentifier(
2314 IAudioSessionControl2 *iface, WCHAR **id)
2316 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2318 FIXME("(%p)->(%p) - stub\n", This, id);
2323 static HRESULT WINAPI AudioSessionControl_GetSessionInstanceIdentifier(
2324 IAudioSessionControl2 *iface, WCHAR **id)
2326 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2328 FIXME("(%p)->(%p) - stub\n", This, id);
2333 static HRESULT WINAPI AudioSessionControl_GetProcessId(
2334 IAudioSessionControl2 *iface, DWORD *pid)
2336 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2338 TRACE("(%p)->(%p)\n", This, pid);
2343 *pid = GetCurrentProcessId();
2348 static HRESULT WINAPI AudioSessionControl_IsSystemSoundsSession(
2349 IAudioSessionControl2 *iface)
2351 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2353 TRACE("(%p)\n", This);
2358 static HRESULT WINAPI AudioSessionControl_SetDuckingPreference(
2359 IAudioSessionControl2 *iface, BOOL optout)
2361 AudioSessionWrapper *This = impl_from_IAudioSessionControl2(iface);
2363 TRACE("(%p)->(%d)\n", This, optout);
2368 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl =
2370 AudioSessionControl_QueryInterface,
2371 AudioSessionControl_AddRef,
2372 AudioSessionControl_Release,
2373 AudioSessionControl_GetState,
2374 AudioSessionControl_GetDisplayName,
2375 AudioSessionControl_SetDisplayName,
2376 AudioSessionControl_GetIconPath,
2377 AudioSessionControl_SetIconPath,
2378 AudioSessionControl_GetGroupingParam,
2379 AudioSessionControl_SetGroupingParam,
2380 AudioSessionControl_RegisterAudioSessionNotification,
2381 AudioSessionControl_UnregisterAudioSessionNotification,
2382 AudioSessionControl_GetSessionIdentifier,
2383 AudioSessionControl_GetSessionInstanceIdentifier,
2384 AudioSessionControl_GetProcessId,
2385 AudioSessionControl_IsSystemSoundsSession,
2386 AudioSessionControl_SetDuckingPreference
2389 /* index == -1 means set all channels, otherwise sets only the given channel */
2390 static HRESULT oss_setvol(ACImpl *This, UINT32 index)
2397 if(index == (UINT32)-1){
2400 for(i = 0; i < This->fmt->nChannels; ++i){
2402 hr = oss_setvol(This, i);
2410 /* OSS doesn't support volume control past the first two channels */
2413 if(This->dataflow == eRender){
2414 setreq = SNDCTL_DSP_SETPLAYVOL;
2415 getreq = SNDCTL_DSP_GETPLAYVOL;
2416 }else if(This->dataflow == eCapture){
2417 setreq = SNDCTL_DSP_SETRECVOL;
2418 getreq = SNDCTL_DSP_GETRECVOL;
2420 return E_UNEXPECTED;
2422 if(ioctl(This->fd, getreq, &vol) < 0){
2424 /* device doesn't support this call */
2427 WARN("GET[REC|PLAY]VOL failed: %d (%s)\n", errno, strerror(errno));
2431 level = This->session->master_vol * This->session->channel_vols[index] *
2435 vol = l | (vol & 0xFF00);
2437 vol = (vol & 0xFF) | (l << 8);
2439 if(ioctl(This->fd, setreq, &vol) < 0){
2441 /* device doesn't support this call */
2444 WARN("SET[REC|PLAY]VOL failed: %d (%s)\n", errno, strerror(errno));
2451 static HRESULT oss_session_setvol(AudioSession *session, UINT32 index)
2456 LIST_FOR_EACH_ENTRY(client, &session->clients, ACImpl, entry){
2458 hr = oss_setvol(client, index);
2466 static HRESULT WINAPI SimpleAudioVolume_QueryInterface(
2467 ISimpleAudioVolume *iface, REFIID riid, void **ppv)
2469 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2475 if(IsEqualIID(riid, &IID_IUnknown) ||
2476 IsEqualIID(riid, &IID_ISimpleAudioVolume))
2479 IUnknown_AddRef((IUnknown*)*ppv);
2483 WARN("Unknown interface %s\n", debugstr_guid(riid));
2484 return E_NOINTERFACE;
2487 static ULONG WINAPI SimpleAudioVolume_AddRef(ISimpleAudioVolume *iface)
2489 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2490 return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
2493 static ULONG WINAPI SimpleAudioVolume_Release(ISimpleAudioVolume *iface)
2495 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2496 return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
2499 static HRESULT WINAPI SimpleAudioVolume_SetMasterVolume(
2500 ISimpleAudioVolume *iface, float level, const GUID *context)
2502 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2503 AudioSession *session = This->session;
2506 TRACE("(%p)->(%f, %s)\n", session, level, wine_dbgstr_guid(context));
2508 if(level < 0.f || level > 1.f)
2509 return E_INVALIDARG;
2512 FIXME("Notifications not supported yet\n");
2514 EnterCriticalSection(&session->lock);
2516 session->master_vol = level;
2518 ret = oss_session_setvol(session, -1);
2520 LeaveCriticalSection(&session->lock);
2525 static HRESULT WINAPI SimpleAudioVolume_GetMasterVolume(
2526 ISimpleAudioVolume *iface, float *level)
2528 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2529 AudioSession *session = This->session;
2531 TRACE("(%p)->(%p)\n", session, level);
2534 return NULL_PTR_ERR;
2536 *level = session->master_vol;
2541 static HRESULT WINAPI SimpleAudioVolume_SetMute(ISimpleAudioVolume *iface,
2542 BOOL mute, const GUID *context)
2544 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2545 AudioSession *session = This->session;
2547 TRACE("(%p)->(%u, %p)\n", session, mute, context);
2549 EnterCriticalSection(&session->lock);
2551 if(!mute && session->mute){
2554 session->mute = mute;
2556 LIST_FOR_EACH_ENTRY(client, &session->clients, ACImpl, entry){
2557 EnterCriticalSection(&client->lock);
2558 if(ioctl(client->fd, SNDCTL_DSP_SKIP) < 0)
2559 WARN("Error calling DSP_SKIP: %d (%s)\n", errno,
2561 oss_write_data(client);
2562 LeaveCriticalSection(&client->lock);
2565 session->mute = mute;
2567 LeaveCriticalSection(&session->lock);
2572 static HRESULT WINAPI SimpleAudioVolume_GetMute(ISimpleAudioVolume *iface,
2575 AudioSessionWrapper *This = impl_from_ISimpleAudioVolume(iface);
2576 AudioSession *session = This->session;
2578 TRACE("(%p)->(%p)\n", session, mute);
2581 return NULL_PTR_ERR;
2583 *mute = This->session->mute;
2588 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl =
2590 SimpleAudioVolume_QueryInterface,
2591 SimpleAudioVolume_AddRef,
2592 SimpleAudioVolume_Release,
2593 SimpleAudioVolume_SetMasterVolume,
2594 SimpleAudioVolume_GetMasterVolume,
2595 SimpleAudioVolume_SetMute,
2596 SimpleAudioVolume_GetMute
2599 static HRESULT WINAPI AudioStreamVolume_QueryInterface(
2600 IAudioStreamVolume *iface, REFIID riid, void **ppv)
2602 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2608 if(IsEqualIID(riid, &IID_IUnknown) ||
2609 IsEqualIID(riid, &IID_IAudioStreamVolume))
2612 IUnknown_AddRef((IUnknown*)*ppv);
2616 WARN("Unknown interface %s\n", debugstr_guid(riid));
2617 return E_NOINTERFACE;
2620 static ULONG WINAPI AudioStreamVolume_AddRef(IAudioStreamVolume *iface)
2622 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2623 return IAudioClient_AddRef(&This->IAudioClient_iface);
2626 static ULONG WINAPI AudioStreamVolume_Release(IAudioStreamVolume *iface)
2628 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2629 return IAudioClient_Release(&This->IAudioClient_iface);
2632 static HRESULT WINAPI AudioStreamVolume_GetChannelCount(
2633 IAudioStreamVolume *iface, UINT32 *out)
2635 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2637 TRACE("(%p)->(%p)\n", This, out);
2642 *out = This->fmt->nChannels;
2647 static HRESULT WINAPI AudioStreamVolume_SetChannelVolume(
2648 IAudioStreamVolume *iface, UINT32 index, float level)
2650 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2653 TRACE("(%p)->(%d, %f)\n", This, index, level);
2655 if(level < 0.f || level > 1.f)
2656 return E_INVALIDARG;
2658 if(index >= This->fmt->nChannels)
2659 return E_INVALIDARG;
2661 EnterCriticalSection(&This->lock);
2663 This->vols[index] = level;
2665 ret = oss_setvol(This, index);
2667 LeaveCriticalSection(&This->lock);
2672 static HRESULT WINAPI AudioStreamVolume_GetChannelVolume(
2673 IAudioStreamVolume *iface, UINT32 index, float *level)
2675 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2677 TRACE("(%p)->(%d, %p)\n", This, index, level);
2682 if(index >= This->fmt->nChannels)
2683 return E_INVALIDARG;
2685 *level = This->vols[index];
2690 static HRESULT WINAPI AudioStreamVolume_SetAllVolumes(
2691 IAudioStreamVolume *iface, UINT32 count, const float *levels)
2693 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2697 TRACE("(%p)->(%d, %p)\n", This, count, levels);
2702 if(count != This->fmt->nChannels)
2703 return E_INVALIDARG;
2705 EnterCriticalSection(&This->lock);
2707 for(i = 0; i < count; ++i)
2708 This->vols[i] = levels[i];
2710 ret = oss_setvol(This, -1);
2712 LeaveCriticalSection(&This->lock);
2717 static HRESULT WINAPI AudioStreamVolume_GetAllVolumes(
2718 IAudioStreamVolume *iface, UINT32 count, float *levels)
2720 ACImpl *This = impl_from_IAudioStreamVolume(iface);
2723 TRACE("(%p)->(%d, %p)\n", This, count, levels);
2728 if(count != This->fmt->nChannels)
2729 return E_INVALIDARG;
2731 EnterCriticalSection(&This->lock);
2733 for(i = 0; i < count; ++i)
2734 levels[i] = This->vols[i];
2736 LeaveCriticalSection(&This->lock);
2741 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl =
2743 AudioStreamVolume_QueryInterface,
2744 AudioStreamVolume_AddRef,
2745 AudioStreamVolume_Release,
2746 AudioStreamVolume_GetChannelCount,
2747 AudioStreamVolume_SetChannelVolume,
2748 AudioStreamVolume_GetChannelVolume,
2749 AudioStreamVolume_SetAllVolumes,
2750 AudioStreamVolume_GetAllVolumes
2753 static HRESULT WINAPI ChannelAudioVolume_QueryInterface(
2754 IChannelAudioVolume *iface, REFIID riid, void **ppv)
2756 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2762 if(IsEqualIID(riid, &IID_IUnknown) ||
2763 IsEqualIID(riid, &IID_IChannelAudioVolume))
2766 IUnknown_AddRef((IUnknown*)*ppv);
2770 WARN("Unknown interface %s\n", debugstr_guid(riid));
2771 return E_NOINTERFACE;
2774 static ULONG WINAPI ChannelAudioVolume_AddRef(IChannelAudioVolume *iface)
2776 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2777 return AudioSessionControl_AddRef(&This->IAudioSessionControl2_iface);
2780 static ULONG WINAPI ChannelAudioVolume_Release(IChannelAudioVolume *iface)
2782 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2783 return AudioSessionControl_Release(&This->IAudioSessionControl2_iface);
2786 static HRESULT WINAPI ChannelAudioVolume_GetChannelCount(
2787 IChannelAudioVolume *iface, UINT32 *out)
2789 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2790 AudioSession *session = This->session;
2792 TRACE("(%p)->(%p)\n", session, out);
2795 return NULL_PTR_ERR;
2797 *out = session->channel_count;
2802 static HRESULT WINAPI ChannelAudioVolume_SetChannelVolume(
2803 IChannelAudioVolume *iface, UINT32 index, float level,
2804 const GUID *context)
2806 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2807 AudioSession *session = This->session;
2810 TRACE("(%p)->(%d, %f, %s)\n", session, index, level,
2811 wine_dbgstr_guid(context));
2813 if(level < 0.f || level > 1.f)
2814 return E_INVALIDARG;
2816 if(index >= session->channel_count)
2817 return E_INVALIDARG;
2820 FIXME("Notifications not supported yet\n");
2822 EnterCriticalSection(&session->lock);
2824 session->channel_vols[index] = level;
2826 ret = oss_session_setvol(session, index);
2828 LeaveCriticalSection(&session->lock);
2833 static HRESULT WINAPI ChannelAudioVolume_GetChannelVolume(
2834 IChannelAudioVolume *iface, UINT32 index, float *level)
2836 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2837 AudioSession *session = This->session;
2839 TRACE("(%p)->(%d, %p)\n", session, index, level);
2842 return NULL_PTR_ERR;
2844 if(index >= session->channel_count)
2845 return E_INVALIDARG;
2847 *level = session->channel_vols[index];
2852 static HRESULT WINAPI ChannelAudioVolume_SetAllVolumes(
2853 IChannelAudioVolume *iface, UINT32 count, const float *levels,
2854 const GUID *context)
2856 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2857 AudioSession *session = This->session;
2861 TRACE("(%p)->(%d, %p, %s)\n", session, count, levels,
2862 wine_dbgstr_guid(context));
2865 return NULL_PTR_ERR;
2867 if(count != session->channel_count)
2868 return E_INVALIDARG;
2871 FIXME("Notifications not supported yet\n");
2873 EnterCriticalSection(&session->lock);
2875 for(i = 0; i < count; ++i)
2876 session->channel_vols[i] = levels[i];
2878 ret = oss_session_setvol(session, -1);
2880 LeaveCriticalSection(&session->lock);
2885 static HRESULT WINAPI ChannelAudioVolume_GetAllVolumes(
2886 IChannelAudioVolume *iface, UINT32 count, float *levels)
2888 AudioSessionWrapper *This = impl_from_IChannelAudioVolume(iface);
2889 AudioSession *session = This->session;
2892 TRACE("(%p)->(%d, %p)\n", session, count, levels);
2895 return NULL_PTR_ERR;
2897 if(count != session->channel_count)
2898 return E_INVALIDARG;
2900 for(i = 0; i < count; ++i)
2901 levels[i] = session->channel_vols[i];
2906 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl =
2908 ChannelAudioVolume_QueryInterface,
2909 ChannelAudioVolume_AddRef,
2910 ChannelAudioVolume_Release,
2911 ChannelAudioVolume_GetChannelCount,
2912 ChannelAudioVolume_SetChannelVolume,
2913 ChannelAudioVolume_GetChannelVolume,
2914 ChannelAudioVolume_SetAllVolumes,
2915 ChannelAudioVolume_GetAllVolumes
2918 static HRESULT WINAPI AudioSessionManager_QueryInterface(IAudioSessionManager2 *iface,
2919 REFIID riid, void **ppv)
2921 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
2927 if(IsEqualIID(riid, &IID_IUnknown) ||
2928 IsEqualIID(riid, &IID_IAudioSessionManager) ||
2929 IsEqualIID(riid, &IID_IAudioSessionManager2))
2932 IUnknown_AddRef((IUnknown*)*ppv);
2936 WARN("Unknown interface %s\n", debugstr_guid(riid));
2937 return E_NOINTERFACE;
2940 static ULONG WINAPI AudioSessionManager_AddRef(IAudioSessionManager2 *iface)
2942 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2944 ref = InterlockedIncrement(&This->ref);
2945 TRACE("(%p) Refcount now %u\n", This, ref);
2949 static ULONG WINAPI AudioSessionManager_Release(IAudioSessionManager2 *iface)
2951 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2953 ref = InterlockedDecrement(&This->ref);
2954 TRACE("(%p) Refcount now %u\n", This, ref);
2956 HeapFree(GetProcessHeap(), 0, This);
2960 static HRESULT WINAPI AudioSessionManager_GetAudioSessionControl(
2961 IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
2962 IAudioSessionControl **out)
2964 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2965 AudioSession *session;
2966 AudioSessionWrapper *wrapper;
2969 TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
2972 hr = get_audio_session(session_guid, This->device, 0, &session);
2976 wrapper = AudioSessionWrapper_Create(NULL);
2978 return E_OUTOFMEMORY;
2980 wrapper->session = session;
2982 *out = (IAudioSessionControl*)&wrapper->IAudioSessionControl2_iface;
2987 static HRESULT WINAPI AudioSessionManager_GetSimpleAudioVolume(
2988 IAudioSessionManager2 *iface, const GUID *session_guid, DWORD flags,
2989 ISimpleAudioVolume **out)
2991 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
2992 AudioSession *session;
2993 AudioSessionWrapper *wrapper;
2996 TRACE("(%p)->(%s, %x, %p)\n", This, debugstr_guid(session_guid),
2999 hr = get_audio_session(session_guid, This->device, 0, &session);
3003 wrapper = AudioSessionWrapper_Create(NULL);
3005 return E_OUTOFMEMORY;
3007 wrapper->session = session;
3009 *out = &wrapper->ISimpleAudioVolume_iface;
3014 static HRESULT WINAPI AudioSessionManager_GetSessionEnumerator(
3015 IAudioSessionManager2 *iface, IAudioSessionEnumerator **out)
3017 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3018 FIXME("(%p)->(%p) - stub\n", This, out);
3022 static HRESULT WINAPI AudioSessionManager_RegisterSessionNotification(
3023 IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
3025 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3026 FIXME("(%p)->(%p) - stub\n", This, notification);
3030 static HRESULT WINAPI AudioSessionManager_UnregisterSessionNotification(
3031 IAudioSessionManager2 *iface, IAudioSessionNotification *notification)
3033 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3034 FIXME("(%p)->(%p) - stub\n", This, notification);
3038 static HRESULT WINAPI AudioSessionManager_RegisterDuckNotification(
3039 IAudioSessionManager2 *iface, const WCHAR *session_id,
3040 IAudioVolumeDuckNotification *notification)
3042 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3043 FIXME("(%p)->(%p) - stub\n", This, notification);
3047 static HRESULT WINAPI AudioSessionManager_UnregisterDuckNotification(
3048 IAudioSessionManager2 *iface,
3049 IAudioVolumeDuckNotification *notification)
3051 SessionMgr *This = impl_from_IAudioSessionManager2(iface);
3052 FIXME("(%p)->(%p) - stub\n", This, notification);
3056 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl =
3058 AudioSessionManager_QueryInterface,
3059 AudioSessionManager_AddRef,
3060 AudioSessionManager_Release,
3061 AudioSessionManager_GetAudioSessionControl,
3062 AudioSessionManager_GetSimpleAudioVolume,
3063 AudioSessionManager_GetSessionEnumerator,
3064 AudioSessionManager_RegisterSessionNotification,
3065 AudioSessionManager_UnregisterSessionNotification,
3066 AudioSessionManager_RegisterDuckNotification,
3067 AudioSessionManager_UnregisterDuckNotification
3070 HRESULT WINAPI AUDDRV_GetAudioSessionManager(IMMDevice *device,
3071 IAudioSessionManager2 **out)
3075 This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(SessionMgr));
3077 return E_OUTOFMEMORY;
3079 This->IAudioSessionManager2_iface.lpVtbl = &AudioSessionManager2_Vtbl;
3080 This->device = device;
3083 *out = &This->IAudioSessionManager2_iface;