2 * Copyright 2011-2012 Maarten Lankhorst
3 * Copyright 2010-2011 Maarten Lankhorst for CodeWeavers
4 * Copyright 2011 Andrew Eikum for CodeWeavers
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 * Pulseaudio driver support.. hell froze over
23 #define NONAMELESSUNION
34 #include <pulse/pulseaudio.h>
40 #include "wine/debug.h"
41 #include "wine/unicode.h"
42 #include "wine/list.h"
52 #include "mmdeviceapi.h"
53 #include "audioclient.h"
54 #include "endpointvolume.h"
55 #include "audiopolicy.h"
57 #include "wine/list.h"
59 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
61 WINE_DEFAULT_DEBUG_CHANNEL(pulse
);
62 WINE_DECLARE_DEBUG_CHANNEL(winediag
);
64 static const REFERENCE_TIME MinimumPeriod
= 30000;
65 static const REFERENCE_TIME DefaultPeriod
= 100000;
67 static pa_context
*pulse_ctx
;
68 static pa_mainloop
*pulse_ml
;
70 static HANDLE pulse_thread
;
71 static pthread_mutex_t pulse_lock
= PTHREAD_MUTEX_INITIALIZER
;
72 static pthread_cond_t pulse_cond
= PTHREAD_COND_INITIALIZER
;
73 static struct list g_sessions
= LIST_INIT(g_sessions
);
75 /* Mixer format + period times */
76 static WAVEFORMATEXTENSIBLE pulse_fmt
[2];
77 static REFERENCE_TIME pulse_min_period
[2], pulse_def_period
[2];
79 static DWORD pulse_stream_volume
;
81 const WCHAR pulse_keyW
[] = {'S','o','f','t','w','a','r','e','\\',
82 'W','i','n','e','\\','P','u','l','s','e',0};
83 const WCHAR pulse_streamW
[] = { 'S','t','r','e','a','m','V','o','l',0 };
85 static HANDLE warn_once
;
87 BOOL WINAPI
DllMain(HINSTANCE dll
, DWORD reason
, void *reserved
)
89 if (reason
== DLL_PROCESS_ATTACH
) {
91 if (RegOpenKeyW(HKEY_CURRENT_USER
, pulse_keyW
, &key
) == ERROR_SUCCESS
) {
92 DWORD size
= sizeof(pulse_stream_volume
);
93 RegQueryValueExW(key
, pulse_streamW
, 0, NULL
,
94 (BYTE
*)&pulse_stream_volume
, &size
);
97 DisableThreadLibraryCalls(dll
);
98 } else if (reason
== DLL_PROCESS_DETACH
) {
100 pa_context_disconnect(pulse_ctx
);
101 pa_context_unref(pulse_ctx
);
104 pa_mainloop_quit(pulse_ml
, 0);
106 CloseHandle(pulse_thread
);
108 CloseHandle(warn_once
);
113 typedef struct ACImpl ACImpl
;
115 typedef struct _AudioSession
{
122 UINT32 channel_count
;
129 typedef struct _AudioSessionWrapper
{
130 IAudioSessionControl2 IAudioSessionControl2_iface
;
131 IChannelAudioVolume IChannelAudioVolume_iface
;
132 ISimpleAudioVolume ISimpleAudioVolume_iface
;
137 AudioSession
*session
;
138 } AudioSessionWrapper
;
140 typedef struct _ACPacket
{
148 IAudioClient IAudioClient_iface
;
149 IAudioRenderClient IAudioRenderClient_iface
;
150 IAudioCaptureClient IAudioCaptureClient_iface
;
151 IAudioClock IAudioClock_iface
;
152 IAudioClock2 IAudioClock2_iface
;
153 IAudioStreamVolume IAudioStreamVolume_iface
;
156 float vol
[PA_CHANNELS_MAX
];
161 AUDCLNT_SHAREMODE share
;
164 UINT32 bufsize_frames
, bufsize_bytes
, locked
, capture_period
, pad
, started
, peek_ofs
;
165 void *locked_ptr
, *tmp_buffer
;
171 INT64 clock_lastpos
, clock_written
;
173 AudioSession
*session
;
174 AudioSessionWrapper
*session_wrapper
;
175 struct list packet_free_head
;
176 struct list packet_filled_head
;
179 static const WCHAR defaultW
[] = {'P','u','l','s','e','a','u','d','i','o',0};
181 static const IAudioClientVtbl AudioClient_Vtbl
;
182 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl
;
183 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl
;
184 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl
;
185 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl
;
186 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl
;
187 static const IAudioClockVtbl AudioClock_Vtbl
;
188 static const IAudioClock2Vtbl AudioClock2_Vtbl
;
189 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl
;
191 static AudioSessionWrapper
*AudioSessionWrapper_Create(ACImpl
*client
);
193 static inline ACImpl
*impl_from_IAudioClient(IAudioClient
*iface
)
195 return CONTAINING_RECORD(iface
, ACImpl
, IAudioClient_iface
);
198 static inline ACImpl
*impl_from_IAudioRenderClient(IAudioRenderClient
*iface
)
200 return CONTAINING_RECORD(iface
, ACImpl
, IAudioRenderClient_iface
);
203 static inline ACImpl
*impl_from_IAudioCaptureClient(IAudioCaptureClient
*iface
)
205 return CONTAINING_RECORD(iface
, ACImpl
, IAudioCaptureClient_iface
);
208 static inline AudioSessionWrapper
*impl_from_IAudioSessionControl2(IAudioSessionControl2
*iface
)
210 return CONTAINING_RECORD(iface
, AudioSessionWrapper
, IAudioSessionControl2_iface
);
213 static inline AudioSessionWrapper
*impl_from_ISimpleAudioVolume(ISimpleAudioVolume
*iface
)
215 return CONTAINING_RECORD(iface
, AudioSessionWrapper
, ISimpleAudioVolume_iface
);
218 static inline AudioSessionWrapper
*impl_from_IChannelAudioVolume(IChannelAudioVolume
*iface
)
220 return CONTAINING_RECORD(iface
, AudioSessionWrapper
, IChannelAudioVolume_iface
);
223 static inline ACImpl
*impl_from_IAudioClock(IAudioClock
*iface
)
225 return CONTAINING_RECORD(iface
, ACImpl
, IAudioClock_iface
);
228 static inline ACImpl
*impl_from_IAudioClock2(IAudioClock2
*iface
)
230 return CONTAINING_RECORD(iface
, ACImpl
, IAudioClock2_iface
);
233 static inline ACImpl
*impl_from_IAudioStreamVolume(IAudioStreamVolume
*iface
)
235 return CONTAINING_RECORD(iface
, ACImpl
, IAudioStreamVolume_iface
);
238 /* Following pulseaudio design here, mainloop has the lock taken whenever
239 * it is handling something for pulse, and the lock is required whenever
240 * doing any pa_* call that can affect the state in any way
242 * pa_cond_wait is used when waiting on results, because the mainloop needs
243 * the same lock taken to affect the state
245 * This is basically the same as the pa_threaded_mainloop implementation,
246 * but that cannot be used because it uses pthread_create directly
248 * pa_threaded_mainloop_(un)lock -> pthread_mutex_(un)lock
249 * pa_threaded_mainloop_signal -> pthread_cond_signal
250 * pa_threaded_mainloop_wait -> pthread_cond_wait
253 static int pulse_poll_func(struct pollfd
*ufds
, unsigned long nfds
, int timeout
, void *userdata
) {
255 pthread_mutex_unlock(&pulse_lock
);
256 r
= poll(ufds
, nfds
, timeout
);
257 pthread_mutex_lock(&pulse_lock
);
261 static DWORD CALLBACK
pulse_mainloop_thread(void *tmp
) {
263 pulse_ml
= pa_mainloop_new();
264 pa_mainloop_set_poll_func(pulse_ml
, pulse_poll_func
, NULL
);
265 pthread_mutex_lock(&pulse_lock
);
266 pthread_cond_signal(&pulse_cond
);
267 pa_mainloop_run(pulse_ml
, &ret
);
268 pthread_mutex_unlock(&pulse_lock
);
269 pa_mainloop_free(pulse_ml
);
270 CloseHandle(pulse_thread
);
274 static void pulse_contextcallback(pa_context
*c
, void *userdata
);
275 static void pulse_stream_state(pa_stream
*s
, void *user
);
277 static const enum pa_channel_position pulse_pos_from_wfx
[] = {
278 PA_CHANNEL_POSITION_FRONT_LEFT
,
279 PA_CHANNEL_POSITION_FRONT_RIGHT
,
280 PA_CHANNEL_POSITION_FRONT_CENTER
,
281 PA_CHANNEL_POSITION_LFE
,
282 PA_CHANNEL_POSITION_REAR_LEFT
,
283 PA_CHANNEL_POSITION_REAR_RIGHT
,
284 PA_CHANNEL_POSITION_FRONT_LEFT_OF_CENTER
,
285 PA_CHANNEL_POSITION_FRONT_RIGHT_OF_CENTER
,
286 PA_CHANNEL_POSITION_REAR_CENTER
,
287 PA_CHANNEL_POSITION_SIDE_LEFT
,
288 PA_CHANNEL_POSITION_SIDE_RIGHT
,
289 PA_CHANNEL_POSITION_TOP_CENTER
,
290 PA_CHANNEL_POSITION_TOP_FRONT_LEFT
,
291 PA_CHANNEL_POSITION_TOP_FRONT_CENTER
,
292 PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
,
293 PA_CHANNEL_POSITION_TOP_REAR_LEFT
,
294 PA_CHANNEL_POSITION_TOP_REAR_CENTER
,
295 PA_CHANNEL_POSITION_TOP_REAR_RIGHT
298 static void pulse_probe_settings(int render
, WAVEFORMATEXTENSIBLE
*fmt
) {
299 WAVEFORMATEX
*wfx
= &fmt
->Format
;
305 unsigned int length
= 0;
307 pa_channel_map_init_auto(&map
, 2, PA_CHANNEL_MAP_ALSA
);
309 ss
.format
= PA_SAMPLE_FLOAT32LE
;
310 ss
.channels
= map
.channels
;
314 attr
.minreq
= attr
.fragsize
= pa_frame_size(&ss
);
317 stream
= pa_stream_new(pulse_ctx
, "format test stream", &ss
, &map
);
319 pa_stream_set_state_callback(stream
, pulse_stream_state
, NULL
);
323 ret
= pa_stream_connect_playback(stream
, NULL
, &attr
,
324 PA_STREAM_START_CORKED
|PA_STREAM_FIX_RATE
|PA_STREAM_FIX_CHANNELS
|PA_STREAM_EARLY_REQUESTS
, NULL
, NULL
);
326 ret
= pa_stream_connect_record(stream
, NULL
, &attr
, PA_STREAM_START_CORKED
|PA_STREAM_FIX_RATE
|PA_STREAM_FIX_CHANNELS
|PA_STREAM_EARLY_REQUESTS
);
328 while (pa_stream_get_state(stream
) == PA_STREAM_CREATING
)
329 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
330 if (pa_stream_get_state(stream
) == PA_STREAM_READY
) {
331 ss
= *pa_stream_get_sample_spec(stream
);
332 map
= *pa_stream_get_channel_map(stream
);
334 length
= pa_stream_get_buffer_attr(stream
)->minreq
;
336 length
= pa_stream_get_buffer_attr(stream
)->fragsize
;
337 pa_stream_disconnect(stream
);
338 while (pa_stream_get_state(stream
) == PA_STREAM_READY
)
339 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
343 pa_stream_unref(stream
);
345 pulse_def_period
[!render
] = pulse_min_period
[!render
] = pa_bytes_to_usec(10 * length
, &ss
);
347 pulse_min_period
[!render
] = MinimumPeriod
;
348 if (pulse_def_period
[!render
] <= DefaultPeriod
)
349 pulse_def_period
[!render
] = DefaultPeriod
;
351 wfx
->wFormatTag
= WAVE_FORMAT_EXTENSIBLE
;
352 wfx
->cbSize
= sizeof(WAVEFORMATEXTENSIBLE
) - sizeof(WAVEFORMATEX
);
353 wfx
->nChannels
= ss
.channels
;
354 wfx
->wBitsPerSample
= 8 * pa_sample_size_of_format(ss
.format
);
355 wfx
->nSamplesPerSec
= ss
.rate
;
356 wfx
->nBlockAlign
= pa_frame_size(&ss
);
357 wfx
->nAvgBytesPerSec
= wfx
->nSamplesPerSec
* wfx
->nBlockAlign
;
358 if (ss
.format
!= PA_SAMPLE_S24_32LE
)
359 fmt
->Samples
.wValidBitsPerSample
= wfx
->wBitsPerSample
;
361 fmt
->Samples
.wValidBitsPerSample
= 24;
362 if (ss
.format
== PA_SAMPLE_FLOAT32LE
)
363 fmt
->SubFormat
= KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
;
365 fmt
->SubFormat
= KSDATAFORMAT_SUBTYPE_PCM
;
367 fmt
->dwChannelMask
= 0;
368 for (i
= 0; i
< map
.channels
; ++i
)
369 switch (map
.map
[i
]) {
370 default: FIXME("Unhandled channel %s\n", pa_channel_position_to_string(map
.map
[i
])); break;
371 case PA_CHANNEL_POSITION_FRONT_LEFT
: fmt
->dwChannelMask
|= SPEAKER_FRONT_LEFT
; break;
372 case PA_CHANNEL_POSITION_MONO
:
373 case PA_CHANNEL_POSITION_FRONT_CENTER
: fmt
->dwChannelMask
|= SPEAKER_FRONT_CENTER
; break;
374 case PA_CHANNEL_POSITION_FRONT_RIGHT
: fmt
->dwChannelMask
|= SPEAKER_FRONT_RIGHT
; break;
375 case PA_CHANNEL_POSITION_REAR_LEFT
: fmt
->dwChannelMask
|= SPEAKER_BACK_LEFT
; break;
376 case PA_CHANNEL_POSITION_REAR_CENTER
: fmt
->dwChannelMask
|= SPEAKER_BACK_CENTER
; break;
377 case PA_CHANNEL_POSITION_REAR_RIGHT
: fmt
->dwChannelMask
|= SPEAKER_BACK_RIGHT
; break;
378 case PA_CHANNEL_POSITION_LFE
: fmt
->dwChannelMask
|= SPEAKER_LOW_FREQUENCY
; break;
379 case PA_CHANNEL_POSITION_SIDE_LEFT
: fmt
->dwChannelMask
|= SPEAKER_SIDE_LEFT
; break;
380 case PA_CHANNEL_POSITION_SIDE_RIGHT
: fmt
->dwChannelMask
|= SPEAKER_SIDE_RIGHT
; break;
381 case PA_CHANNEL_POSITION_TOP_CENTER
: fmt
->dwChannelMask
|= SPEAKER_TOP_CENTER
; break;
382 case PA_CHANNEL_POSITION_TOP_FRONT_LEFT
: fmt
->dwChannelMask
|= SPEAKER_TOP_FRONT_LEFT
; break;
383 case PA_CHANNEL_POSITION_TOP_FRONT_CENTER
: fmt
->dwChannelMask
|= SPEAKER_TOP_FRONT_CENTER
; break;
384 case PA_CHANNEL_POSITION_TOP_FRONT_RIGHT
: fmt
->dwChannelMask
|= SPEAKER_TOP_FRONT_RIGHT
; break;
385 case PA_CHANNEL_POSITION_TOP_REAR_LEFT
: fmt
->dwChannelMask
|= SPEAKER_TOP_BACK_LEFT
; break;
386 case PA_CHANNEL_POSITION_TOP_REAR_CENTER
: fmt
->dwChannelMask
|= SPEAKER_TOP_BACK_CENTER
; break;
387 case PA_CHANNEL_POSITION_TOP_REAR_RIGHT
: fmt
->dwChannelMask
|= SPEAKER_TOP_BACK_RIGHT
; break;
391 static HRESULT
pulse_connect(void)
394 WCHAR path
[PATH_MAX
], *name
;
399 if (!(pulse_thread
= CreateThread(NULL
, 0, pulse_mainloop_thread
, NULL
, 0, NULL
)))
401 ERR("Failed to create mainloop thread.");
404 SetThreadPriority(pulse_thread
, THREAD_PRIORITY_TIME_CRITICAL
);
405 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
408 if (pulse_ctx
&& PA_CONTEXT_IS_GOOD(pa_context_get_state(pulse_ctx
)))
411 pa_context_unref(pulse_ctx
);
413 GetModuleFileNameW(NULL
, path
, sizeof(path
)/sizeof(*path
));
414 name
= strrchrW(path
, '\\');
419 len
= WideCharToMultiByte(CP_UNIXCP
, 0, name
, -1, NULL
, 0, NULL
, NULL
);
420 str
= pa_xmalloc(len
);
421 WideCharToMultiByte(CP_UNIXCP
, 0, name
, -1, str
, len
, NULL
, NULL
);
422 TRACE("Name: %s\n", str
);
423 pulse_ctx
= pa_context_new(pa_mainloop_get_api(pulse_ml
), str
);
426 ERR("Failed to create context\n");
430 pa_context_set_state_callback(pulse_ctx
, pulse_contextcallback
, NULL
);
432 TRACE("libpulse protocol version: %u. API Version %u\n", pa_context_get_protocol_version(pulse_ctx
), PA_API_VERSION
);
433 if (pa_context_connect(pulse_ctx
, NULL
, 0, NULL
) < 0)
436 /* Wait for connection */
437 while (pthread_cond_wait(&pulse_cond
, &pulse_lock
)) {
438 pa_context_state_t state
= pa_context_get_state(pulse_ctx
);
440 if (state
== PA_CONTEXT_FAILED
|| state
== PA_CONTEXT_TERMINATED
)
443 if (state
== PA_CONTEXT_READY
)
447 TRACE("Connected to server %s with protocol version: %i.\n",
448 pa_context_get_server(pulse_ctx
),
449 pa_context_get_server_protocol_version(pulse_ctx
));
450 pulse_probe_settings(1, &pulse_fmt
[0]);
451 pulse_probe_settings(0, &pulse_fmt
[1]);
455 pa_context_unref(pulse_ctx
);
460 static void pulse_contextcallback(pa_context
*c
, void *userdata
) {
461 switch (pa_context_get_state(c
)) {
463 FIXME("Unhandled state: %i\n", pa_context_get_state(c
));
464 case PA_CONTEXT_CONNECTING
:
465 case PA_CONTEXT_UNCONNECTED
:
466 case PA_CONTEXT_AUTHORIZING
:
467 case PA_CONTEXT_SETTING_NAME
:
468 case PA_CONTEXT_TERMINATED
:
469 TRACE("State change to %i\n", pa_context_get_state(c
));
472 case PA_CONTEXT_READY
:
476 case PA_CONTEXT_FAILED
:
477 ERR("Context failed: %s\n", pa_strerror(pa_context_errno(c
)));
480 pthread_cond_signal(&pulse_cond
);
483 static HRESULT
pulse_stream_valid(ACImpl
*This
) {
485 return AUDCLNT_E_NOT_INITIALIZED
;
486 if (!This
->stream
|| pa_stream_get_state(This
->stream
) != PA_STREAM_READY
)
487 return AUDCLNT_E_DEVICE_INVALIDATED
;
491 static void dump_attr(const pa_buffer_attr
*attr
) {
492 TRACE("maxlength: %u\n", attr
->maxlength
);
493 TRACE("minreq: %u\n", attr
->minreq
);
494 TRACE("fragsize: %u\n", attr
->fragsize
);
495 TRACE("tlength: %u\n", attr
->tlength
);
496 TRACE("prebuf: %u\n", attr
->prebuf
);
499 static void pulse_op_cb(pa_stream
*s
, int success
, void *user
) {
500 TRACE("Success: %i\n", success
);
501 *(int*)user
= success
;
502 pthread_cond_signal(&pulse_cond
);
505 static void pulse_ctx_op_cb(pa_context
*c
, int success
, void *user
) {
506 TRACE("Success: %i\n", success
);
507 *(int*)user
= success
;
508 pthread_cond_signal(&pulse_cond
);
511 static void pulse_attr_update(pa_stream
*s
, void *user
) {
512 const pa_buffer_attr
*attr
= pa_stream_get_buffer_attr(s
);
513 TRACE("New attributes or device moved:\n");
517 static void pulse_wr_callback(pa_stream
*s
, size_t bytes
, void *userdata
)
519 ACImpl
*This
= userdata
;
520 UINT32 oldpad
= This
->pad
;
522 if (bytes
< This
->bufsize_bytes
)
523 This
->pad
= This
->bufsize_bytes
- bytes
;
527 assert(oldpad
>= This
->pad
);
529 This
->clock_written
+= oldpad
- This
->pad
;
530 TRACE("New pad: %zu (-%zu)\n", This
->pad
/ pa_frame_size(&This
->ss
), (oldpad
- This
->pad
) / pa_frame_size(&This
->ss
));
533 SetEvent(This
->event
);
536 static void pulse_underflow_callback(pa_stream
*s
, void *userdata
)
541 /* Latency is periodically updated even when nothing is played,
542 * because of PA_STREAM_AUTO_TIMING_UPDATE so use it as timer
544 * Perfect for passing all tests :)
546 static void pulse_latency_callback(pa_stream
*s
, void *userdata
)
548 ACImpl
*This
= userdata
;
549 if (!This
->pad
&& This
->event
)
550 SetEvent(This
->event
);
553 static void pulse_started_callback(pa_stream
*s
, void *userdata
)
555 ACImpl
*This
= userdata
;
557 TRACE("(Re)started playing\n");
559 SetEvent(This
->event
);
562 static void pulse_rd_loop(ACImpl
*This
, size_t bytes
)
564 while (bytes
>= This
->capture_period
) {
566 LARGE_INTEGER stamp
, freq
;
568 size_t src_len
, copy
, rem
= This
->capture_period
;
569 if (!(p
= (ACPacket
*)list_head(&This
->packet_free_head
))) {
570 p
= (ACPacket
*)list_head(&This
->packet_filled_head
);
572 next
= (ACPacket
*)p
->entry
.next
;
575 p
= (ACPacket
*)list_tail(&This
->packet_filled_head
);
576 assert(This
->pad
== This
->bufsize_bytes
);
578 assert(This
->pad
< This
->bufsize_bytes
);
579 This
->pad
+= This
->capture_period
;
580 assert(This
->pad
<= This
->bufsize_bytes
);
582 QueryPerformanceCounter(&stamp
);
583 QueryPerformanceFrequency(&freq
);
584 p
->qpcpos
= (stamp
.QuadPart
* (INT64
)10000000) / freq
.QuadPart
;
586 list_remove(&p
->entry
);
587 list_add_tail(&This
->packet_filled_head
, &p
->entry
);
591 pa_stream_peek(This
->stream
, (const void**)&src
, &src_len
);
593 assert(This
->peek_ofs
< src_len
);
594 src
+= This
->peek_ofs
;
595 src_len
-= This
->peek_ofs
;
596 assert(src_len
<= bytes
);
601 memcpy(dst
, src
, rem
);
609 pa_stream_drop(This
->stream
);
611 This
->peek_ofs
+= copy
;
613 bytes
-= This
->capture_period
;
617 static void pulse_rd_drop(ACImpl
*This
, size_t bytes
)
619 while (bytes
>= This
->capture_period
) {
620 size_t src_len
, copy
, rem
= This
->capture_period
;
623 pa_stream_peek(This
->stream
, &src
, &src_len
);
625 assert(This
->peek_ofs
< src_len
);
626 src_len
-= This
->peek_ofs
;
627 assert(src_len
<= bytes
);
638 pa_stream_drop(This
->stream
);
640 This
->peek_ofs
+= copy
;
646 static void pulse_rd_callback(pa_stream
*s
, size_t bytes
, void *userdata
)
648 ACImpl
*This
= userdata
;
650 TRACE("Readable total: %zu, fragsize: %u\n", bytes
, pa_stream_get_buffer_attr(s
)->fragsize
);
651 assert(bytes
>= This
->peek_ofs
);
652 bytes
-= This
->peek_ofs
;
653 if (bytes
< This
->capture_period
)
657 pulse_rd_loop(This
, bytes
);
659 pulse_rd_drop(This
, bytes
);
662 SetEvent(This
->event
);
665 static void pulse_stream_state(pa_stream
*s
, void *user
)
667 pa_stream_state_t state
= pa_stream_get_state(s
);
668 TRACE("Stream state changed to %i\n", state
);
669 pthread_cond_signal(&pulse_cond
);
672 static HRESULT
pulse_stream_connect(ACImpl
*This
, UINT32 period_bytes
) {
678 pa_stream_disconnect(This
->stream
);
679 while (pa_stream_get_state(This
->stream
) == PA_STREAM_READY
)
680 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
681 pa_stream_unref(This
->stream
);
683 ret
= InterlockedIncrement(&number
);
684 sprintf(buffer
, "audio stream #%i", ret
);
685 This
->stream
= pa_stream_new(pulse_ctx
, buffer
, &This
->ss
, &This
->map
);
686 pa_stream_set_state_callback(This
->stream
, pulse_stream_state
, This
);
687 pa_stream_set_buffer_attr_callback(This
->stream
, pulse_attr_update
, This
);
688 pa_stream_set_moved_callback(This
->stream
, pulse_attr_update
, This
);
690 /* Pulseaudio will fill in correct values */
691 attr
.minreq
= attr
.fragsize
= period_bytes
;
692 attr
.maxlength
= attr
.tlength
= This
->bufsize_bytes
;
693 attr
.prebuf
= pa_frame_size(&This
->ss
);
695 if (This
->dataflow
== eRender
)
696 ret
= pa_stream_connect_playback(This
->stream
, NULL
, &attr
,
697 PA_STREAM_START_CORKED
|PA_STREAM_START_UNMUTED
|PA_STREAM_AUTO_TIMING_UPDATE
|PA_STREAM_INTERPOLATE_TIMING
|PA_STREAM_EARLY_REQUESTS
, NULL
, NULL
);
699 ret
= pa_stream_connect_record(This
->stream
, NULL
, &attr
,
700 PA_STREAM_START_CORKED
|PA_STREAM_START_UNMUTED
|PA_STREAM_AUTO_TIMING_UPDATE
|PA_STREAM_INTERPOLATE_TIMING
|PA_STREAM_EARLY_REQUESTS
);
702 WARN("Returns %i\n", ret
);
703 return AUDCLNT_E_ENDPOINT_CREATE_FAILED
;
705 while (pa_stream_get_state(This
->stream
) == PA_STREAM_CREATING
)
706 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
707 if (pa_stream_get_state(This
->stream
) != PA_STREAM_READY
)
708 return AUDCLNT_E_ENDPOINT_CREATE_FAILED
;
710 if (This
->dataflow
== eRender
) {
711 pa_stream_set_write_callback(This
->stream
, pulse_wr_callback
, This
);
712 pa_stream_set_underflow_callback(This
->stream
, pulse_underflow_callback
, This
);
713 pa_stream_set_started_callback(This
->stream
, pulse_started_callback
, This
);
715 pa_stream_set_read_callback(This
->stream
, pulse_rd_callback
, This
);
719 HRESULT WINAPI
AUDDRV_GetEndpointIDs(EDataFlow flow
, WCHAR
***ids
, void ***keys
,
720 UINT
*num
, UINT
*def_index
)
723 TRACE("%d %p %p %p\n", flow
, ids
, num
, def_index
);
725 pthread_mutex_lock(&pulse_lock
);
726 hr
= pulse_connect();
727 pthread_mutex_unlock(&pulse_lock
);
733 *ids
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
*));
735 return E_OUTOFMEMORY
;
737 (*ids
)[0] = HeapAlloc(GetProcessHeap(), 0, sizeof(defaultW
));
739 HeapFree(GetProcessHeap(), 0, *ids
);
740 return E_OUTOFMEMORY
;
743 lstrcpyW((*ids
)[0], defaultW
);
745 *keys
= HeapAlloc(GetProcessHeap(), 0, sizeof(void *));
751 int WINAPI
AUDDRV_GetPriority(void)
754 if (getenv("WINENOPULSE")) {
755 FIXME_(winediag
)("winepulse has been temporarily disabled through the environment\n");
758 pthread_mutex_lock(&pulse_lock
);
759 hr
= pulse_connect();
760 pthread_mutex_unlock(&pulse_lock
);
761 return SUCCEEDED(hr
) ? 3 : 0;
764 HRESULT WINAPI
AUDDRV_GetAudioEndpoint(void *key
, IMMDevice
*dev
,
765 EDataFlow dataflow
, IAudioClient
**out
)
771 /* Give one visible warning per session
772 * Sadly wine has chosen not to accept the winepulse patch, so support ourselves
774 if (!warn_once
&& (warn_once
= CreateEventA(0, 0, 0, "__winepulse_warn_event")) && GetLastError() != ERROR_ALREADY_EXISTS
) {
775 FIXME_(winediag
)("Winepulse is not officially supported by the wine project\n");
776 FIXME_(winediag
)("For sound related feedback and support, please visit http://ubuntuforums.org/showthread.php?t=1960599\n");
778 WARN_(winediag
)("Winepulse is not officially supported by the wine project\n");
779 WARN_(winediag
)("For sound related feedback and support, please visit http://ubuntuforums.org/showthread.php?t=1960599\n");
782 TRACE("%s %p %p\n", debugstr_guid(guid
), dev
, out
);
783 if (dataflow
!= eRender
&& dataflow
!= eCapture
)
787 pthread_mutex_lock(&pulse_lock
);
788 hr
= pulse_connect();
789 pthread_mutex_unlock(&pulse_lock
);
793 This
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*This
));
795 return E_OUTOFMEMORY
;
797 This
->IAudioClient_iface
.lpVtbl
= &AudioClient_Vtbl
;
798 This
->IAudioRenderClient_iface
.lpVtbl
= &AudioRenderClient_Vtbl
;
799 This
->IAudioCaptureClient_iface
.lpVtbl
= &AudioCaptureClient_Vtbl
;
800 This
->IAudioClock_iface
.lpVtbl
= &AudioClock_Vtbl
;
801 This
->IAudioClock2_iface
.lpVtbl
= &AudioClock2_Vtbl
;
802 This
->IAudioStreamVolume_iface
.lpVtbl
= &AudioStreamVolume_Vtbl
;
803 This
->dataflow
= dataflow
;
805 for (i
= 0; i
< PA_CHANNELS_MAX
; ++i
)
807 IMMDevice_AddRef(This
->parent
);
809 *out
= &This
->IAudioClient_iface
;
810 IAudioClient_AddRef(&This
->IAudioClient_iface
);
815 static HRESULT WINAPI
AudioClient_QueryInterface(IAudioClient
*iface
,
816 REFIID riid
, void **ppv
)
818 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
823 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IAudioClient
))
826 IUnknown_AddRef((IUnknown
*)*ppv
);
829 WARN("Unknown interface %s\n", debugstr_guid(riid
));
830 return E_NOINTERFACE
;
833 static ULONG WINAPI
AudioClient_AddRef(IAudioClient
*iface
)
835 ACImpl
*This
= impl_from_IAudioClient(iface
);
837 ref
= InterlockedIncrement(&This
->ref
);
838 TRACE("(%p) Refcount now %u\n", This
, ref
);
842 static ULONG WINAPI
AudioClient_Release(IAudioClient
*iface
)
844 ACImpl
*This
= impl_from_IAudioClient(iface
);
846 ref
= InterlockedDecrement(&This
->ref
);
847 TRACE("(%p) Refcount now %u\n", This
, ref
);
850 pthread_mutex_lock(&pulse_lock
);
851 if (PA_STREAM_IS_GOOD(pa_stream_get_state(This
->stream
))) {
852 pa_stream_disconnect(This
->stream
);
853 while (PA_STREAM_IS_GOOD(pa_stream_get_state(This
->stream
)))
854 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
856 pa_stream_unref(This
->stream
);
858 list_remove(&This
->entry
);
859 pthread_mutex_unlock(&pulse_lock
);
861 IMMDevice_Release(This
->parent
);
862 HeapFree(GetProcessHeap(), 0, This
->tmp_buffer
);
863 HeapFree(GetProcessHeap(), 0, This
);
868 static void dump_fmt(const WAVEFORMATEX
*fmt
)
870 TRACE("wFormatTag: 0x%x (", fmt
->wFormatTag
);
871 switch(fmt
->wFormatTag
) {
872 case WAVE_FORMAT_PCM
:
873 TRACE("WAVE_FORMAT_PCM");
875 case WAVE_FORMAT_IEEE_FLOAT
:
876 TRACE("WAVE_FORMAT_IEEE_FLOAT");
878 case WAVE_FORMAT_EXTENSIBLE
:
879 TRACE("WAVE_FORMAT_EXTENSIBLE");
887 TRACE("nChannels: %u\n", fmt
->nChannels
);
888 TRACE("nSamplesPerSec: %u\n", fmt
->nSamplesPerSec
);
889 TRACE("nAvgBytesPerSec: %u\n", fmt
->nAvgBytesPerSec
);
890 TRACE("nBlockAlign: %u\n", fmt
->nBlockAlign
);
891 TRACE("wBitsPerSample: %u\n", fmt
->wBitsPerSample
);
892 TRACE("cbSize: %u\n", fmt
->cbSize
);
894 if (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
) {
895 WAVEFORMATEXTENSIBLE
*fmtex
= (void*)fmt
;
896 TRACE("dwChannelMask: %08x\n", fmtex
->dwChannelMask
);
897 TRACE("Samples: %04x\n", fmtex
->Samples
.wReserved
);
898 TRACE("SubFormat: %s\n", wine_dbgstr_guid(&fmtex
->SubFormat
));
902 static WAVEFORMATEX
*clone_format(const WAVEFORMATEX
*fmt
)
907 if (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
)
908 size
= sizeof(WAVEFORMATEXTENSIBLE
);
910 size
= sizeof(WAVEFORMATEX
);
912 ret
= CoTaskMemAlloc(size
);
916 memcpy(ret
, fmt
, size
);
918 ret
->cbSize
= size
- sizeof(WAVEFORMATEX
);
923 static DWORD
get_channel_mask(unsigned int channels
)
929 return SPEAKER_FRONT_CENTER
;
931 return SPEAKER_FRONT_LEFT
| SPEAKER_FRONT_RIGHT
;
933 return SPEAKER_FRONT_LEFT
| SPEAKER_FRONT_RIGHT
|
934 SPEAKER_LOW_FREQUENCY
;
936 return SPEAKER_FRONT_LEFT
| SPEAKER_FRONT_RIGHT
| SPEAKER_BACK_LEFT
|
939 return SPEAKER_FRONT_LEFT
| SPEAKER_FRONT_RIGHT
| SPEAKER_BACK_LEFT
|
940 SPEAKER_BACK_RIGHT
| SPEAKER_LOW_FREQUENCY
;
942 return SPEAKER_FRONT_LEFT
| SPEAKER_FRONT_RIGHT
| SPEAKER_BACK_LEFT
|
943 SPEAKER_BACK_RIGHT
| SPEAKER_LOW_FREQUENCY
| SPEAKER_FRONT_CENTER
;
945 return SPEAKER_FRONT_LEFT
| SPEAKER_FRONT_RIGHT
| SPEAKER_BACK_LEFT
|
946 SPEAKER_BACK_RIGHT
| SPEAKER_LOW_FREQUENCY
| SPEAKER_FRONT_CENTER
|
949 return SPEAKER_FRONT_LEFT
| SPEAKER_FRONT_RIGHT
| SPEAKER_BACK_LEFT
|
950 SPEAKER_BACK_RIGHT
| SPEAKER_LOW_FREQUENCY
| SPEAKER_FRONT_CENTER
|
951 SPEAKER_SIDE_LEFT
| SPEAKER_SIDE_RIGHT
;
953 FIXME("Unknown speaker configuration: %u\n", channels
);
957 static void session_init_vols(AudioSession
*session
, UINT channels
)
959 if (session
->channel_count
< channels
) {
962 if (session
->channel_vols
)
963 session
->channel_vols
= HeapReAlloc(GetProcessHeap(), 0,
964 session
->channel_vols
, sizeof(float) * channels
);
966 session
->channel_vols
= HeapAlloc(GetProcessHeap(), 0,
967 sizeof(float) * channels
);
968 if (!session
->channel_vols
)
971 for(i
= session
->channel_count
; i
< channels
; ++i
)
972 session
->channel_vols
[i
] = 1.f
;
974 session
->channel_count
= channels
;
978 static AudioSession
*create_session(const GUID
*guid
, IMMDevice
*device
,
983 ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(AudioSession
));
987 memcpy(&ret
->guid
, guid
, sizeof(GUID
));
989 ret
->device
= device
;
991 list_init(&ret
->clients
);
993 list_add_head(&g_sessions
, &ret
->entry
);
995 session_init_vols(ret
, num_channels
);
997 ret
->master_vol
= 1.f
;
1002 /* if channels == 0, then this will return or create a session with
1003 * matching dataflow and GUID. otherwise, channels must also match */
1004 static HRESULT
get_audio_session(const GUID
*sessionguid
,
1005 IMMDevice
*device
, UINT channels
, AudioSession
**out
)
1007 AudioSession
*session
;
1009 if (!sessionguid
|| IsEqualGUID(sessionguid
, &GUID_NULL
)) {
1010 *out
= create_session(&GUID_NULL
, device
, channels
);
1012 return E_OUTOFMEMORY
;
1018 LIST_FOR_EACH_ENTRY(session
, &g_sessions
, AudioSession
, entry
) {
1019 if (session
->device
== device
&&
1020 IsEqualGUID(sessionguid
, &session
->guid
)) {
1021 session_init_vols(session
, channels
);
1028 *out
= create_session(sessionguid
, device
, channels
);
1030 return E_OUTOFMEMORY
;
1036 static HRESULT
pulse_spec_from_waveformat(ACImpl
*This
, const WAVEFORMATEX
*fmt
)
1038 pa_channel_map_init(&This
->map
);
1039 This
->ss
.rate
= fmt
->nSamplesPerSec
;
1040 This
->ss
.format
= PA_SAMPLE_INVALID
;
1041 switch(fmt
->wFormatTag
) {
1042 case WAVE_FORMAT_IEEE_FLOAT
:
1043 if (!fmt
->nChannels
|| fmt
->nChannels
> 2 || fmt
->wBitsPerSample
!= 32)
1045 This
->ss
.format
= PA_SAMPLE_FLOAT32LE
;
1046 pa_channel_map_init_auto(&This
->map
, fmt
->nChannels
, PA_CHANNEL_MAP_ALSA
);
1048 case WAVE_FORMAT_PCM
:
1049 if (!fmt
->nChannels
|| fmt
->nChannels
> 2)
1051 if (fmt
->wBitsPerSample
== 8)
1052 This
->ss
.format
= PA_SAMPLE_U8
;
1053 else if (fmt
->wBitsPerSample
== 16)
1054 This
->ss
.format
= PA_SAMPLE_S16LE
;
1056 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1057 pa_channel_map_init_auto(&This
->map
, fmt
->nChannels
, PA_CHANNEL_MAP_ALSA
);
1059 case WAVE_FORMAT_EXTENSIBLE
: {
1060 WAVEFORMATEXTENSIBLE
*wfe
= (WAVEFORMATEXTENSIBLE
*)fmt
;
1061 DWORD mask
= wfe
->dwChannelMask
;
1063 if (fmt
->cbSize
!= (sizeof(*wfe
) - sizeof(*fmt
)) && fmt
->cbSize
!= sizeof(*wfe
))
1065 if (IsEqualGUID(&wfe
->SubFormat
, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT
) &&
1066 (!wfe
->Samples
.wValidBitsPerSample
|| wfe
->Samples
.wValidBitsPerSample
== 32) &&
1067 fmt
->wBitsPerSample
== 32)
1068 This
->ss
.format
= PA_SAMPLE_FLOAT32LE
;
1069 else if (IsEqualGUID(&wfe
->SubFormat
, &KSDATAFORMAT_SUBTYPE_PCM
)) {
1070 DWORD valid
= wfe
->Samples
.wValidBitsPerSample
;
1072 valid
= fmt
->wBitsPerSample
;
1073 if (!valid
|| valid
> fmt
->wBitsPerSample
)
1075 switch (fmt
->wBitsPerSample
) {
1078 This
->ss
.format
= PA_SAMPLE_U8
;
1082 This
->ss
.format
= PA_SAMPLE_S16LE
;
1086 This
->ss
.format
= PA_SAMPLE_S24LE
;
1090 This
->ss
.format
= PA_SAMPLE_S24_32LE
;
1091 else if (valid
== 32)
1092 This
->ss
.format
= PA_SAMPLE_S32LE
;
1095 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1098 This
->map
.channels
= fmt
->nChannels
;
1099 if (!mask
|| mask
== SPEAKER_ALL
)
1100 mask
= get_channel_mask(fmt
->nChannels
);
1101 else if (mask
== ~0U && fmt
->nChannels
== 1)
1102 mask
= SPEAKER_FRONT_CENTER
;
1103 for (j
= 0; j
< sizeof(pulse_pos_from_wfx
)/sizeof(*pulse_pos_from_wfx
) && i
< fmt
->nChannels
; ++j
) {
1104 if (mask
& (1 << j
))
1105 This
->map
.map
[i
++] = pulse_pos_from_wfx
[j
];
1108 /* Special case for mono since pulse appears to map it differently */
1109 if (mask
== SPEAKER_FRONT_CENTER
)
1110 This
->map
.map
[0] = PA_CHANNEL_POSITION_MONO
;
1112 if (i
< fmt
->nChannels
|| (mask
& SPEAKER_RESERVED
)) {
1113 This
->map
.channels
= 0;
1114 ERR("Invalid channel mask: %i/%i and %x(%x)\n", i
, fmt
->nChannels
, mask
, wfe
->dwChannelMask
);
1119 case WAVE_FORMAT_ALAW
:
1120 case WAVE_FORMAT_MULAW
:
1121 if (fmt
->wBitsPerSample
!= 8) {
1122 FIXME("Unsupported bpp %u for LAW\n", fmt
->wBitsPerSample
);
1123 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1125 if (fmt
->nChannels
!= 1 && fmt
->nChannels
!= 2) {
1126 FIXME("Unsupported channels %u for LAW\n", fmt
->nChannels
);
1127 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1129 This
->ss
.format
= fmt
->wFormatTag
== WAVE_FORMAT_MULAW
? PA_SAMPLE_ULAW
: PA_SAMPLE_ALAW
;
1130 pa_channel_map_init_auto(&This
->map
, fmt
->nChannels
, PA_CHANNEL_MAP_ALSA
);
1133 WARN("Unhandled tag %x\n", fmt
->wFormatTag
);
1134 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1136 This
->ss
.channels
= This
->map
.channels
;
1137 if (!pa_channel_map_valid(&This
->map
) || This
->ss
.format
== PA_SAMPLE_INVALID
) {
1138 ERR("Invalid format! Channel spec valid: %i, format: %i\n", pa_channel_map_valid(&This
->map
), This
->ss
.format
);
1140 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1145 static HRESULT WINAPI
AudioClient_Initialize(IAudioClient
*iface
,
1146 AUDCLNT_SHAREMODE mode
, DWORD flags
, REFERENCE_TIME duration
,
1147 REFERENCE_TIME period
, const WAVEFORMATEX
*fmt
,
1148 const GUID
*sessionguid
)
1150 ACImpl
*This
= impl_from_IAudioClient(iface
);
1154 TRACE("(%p)->(%x, %x, %s, %s, %p, %s)\n", This
, mode
, flags
,
1155 wine_dbgstr_longlong(duration
), wine_dbgstr_longlong(period
), fmt
, debugstr_guid(sessionguid
));
1160 if (mode
!= AUDCLNT_SHAREMODE_SHARED
&& mode
!= AUDCLNT_SHAREMODE_EXCLUSIVE
)
1161 return AUDCLNT_E_NOT_INITIALIZED
;
1162 if (mode
== AUDCLNT_SHAREMODE_EXCLUSIVE
)
1163 return AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
;
1165 if (flags
& ~(AUDCLNT_STREAMFLAGS_CROSSPROCESS
|
1166 AUDCLNT_STREAMFLAGS_LOOPBACK
|
1167 AUDCLNT_STREAMFLAGS_EVENTCALLBACK
|
1168 AUDCLNT_STREAMFLAGS_NOPERSIST
|
1169 AUDCLNT_STREAMFLAGS_RATEADJUST
|
1170 AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED
|
1171 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE
|
1172 AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED
)) {
1173 TRACE("Unknown flags: %08x\n", flags
);
1174 return E_INVALIDARG
;
1177 pthread_mutex_lock(&pulse_lock
);
1179 pthread_mutex_unlock(&pulse_lock
);
1180 return AUDCLNT_E_ALREADY_INITIALIZED
;
1183 hr
= pulse_spec_from_waveformat(This
, fmt
);
1187 if (mode
== AUDCLNT_SHAREMODE_SHARED
) {
1188 REFERENCE_TIME def
= pulse_def_period
[This
->dataflow
== eCapture
];
1189 REFERENCE_TIME min
= pulse_min_period
[This
->dataflow
== eCapture
];
1191 /* Switch to low latency mode if below 2 default periods,
1192 * which is 20 ms by default, this will increase the amount
1193 * of interrupts but allows very low latency. In dsound I
1194 * managed to get a total latency of ~8ms, which is well below
1197 if (duration
< 2 * def
)
1201 if (duration
< 2 * period
)
1202 duration
= 2 * period
;
1204 /* Uh oh, really low latency requested.. */
1205 if (duration
<= 2 * period
)
1208 period_bytes
= pa_frame_size(&This
->ss
) * MulDiv(period
, This
->ss
.rate
, 10000000);
1210 if (duration
< 20000000)
1211 This
->bufsize_frames
= ceil((duration
/ 10000000.) * fmt
->nSamplesPerSec
);
1213 This
->bufsize_frames
= 2 * fmt
->nSamplesPerSec
;
1214 This
->bufsize_bytes
= This
->bufsize_frames
* pa_frame_size(&This
->ss
);
1217 This
->flags
= flags
;
1218 hr
= pulse_stream_connect(This
, period_bytes
);
1219 if (SUCCEEDED(hr
)) {
1221 const pa_buffer_attr
*attr
= pa_stream_get_buffer_attr(This
->stream
);
1222 /* Update frames according to new size */
1224 if (This
->dataflow
== eRender
)
1225 This
->bufsize_bytes
= attr
->tlength
;
1227 This
->capture_period
= period_bytes
= attr
->fragsize
;
1228 if ((unalign
= This
->bufsize_bytes
% period_bytes
))
1229 This
->bufsize_bytes
+= period_bytes
- unalign
;
1231 This
->bufsize_frames
= This
->bufsize_bytes
/ pa_frame_size(&This
->ss
);
1233 if (SUCCEEDED(hr
)) {
1234 UINT32 i
, capture_packets
= This
->capture_period
? This
->bufsize_bytes
/ This
->capture_period
: 0;
1235 This
->tmp_buffer
= HeapAlloc(GetProcessHeap(), 0, This
->bufsize_bytes
+ capture_packets
* sizeof(ACPacket
));
1236 if (!This
->tmp_buffer
)
1239 ACPacket
*cur_packet
= (ACPacket
*)((char*)This
->tmp_buffer
+ This
->bufsize_bytes
);
1240 BYTE
*data
= This
->tmp_buffer
;
1241 memset(This
->tmp_buffer
, This
->ss
.format
== PA_SAMPLE_U8
? 0x80 : 0, This
->bufsize_bytes
);
1242 list_init(&This
->packet_free_head
);
1243 list_init(&This
->packet_filled_head
);
1244 for (i
= 0; i
< capture_packets
; ++i
, ++cur_packet
) {
1245 list_add_tail(&This
->packet_free_head
, &cur_packet
->entry
);
1246 cur_packet
->data
= data
;
1247 data
+= This
->capture_period
;
1249 assert(!This
->capture_period
|| This
->bufsize_bytes
== This
->capture_period
* capture_packets
);
1250 assert(!capture_packets
|| data
- This
->bufsize_bytes
== This
->tmp_buffer
);
1254 hr
= get_audio_session(sessionguid
, This
->parent
, fmt
->nChannels
, &This
->session
);
1256 list_add_tail(&This
->session
->clients
, &This
->entry
);
1260 HeapFree(GetProcessHeap(), 0, This
->tmp_buffer
);
1261 This
->tmp_buffer
= NULL
;
1263 pa_stream_disconnect(This
->stream
);
1264 pa_stream_unref(This
->stream
);
1265 This
->stream
= NULL
;
1268 pthread_mutex_unlock(&pulse_lock
);
1272 static HRESULT WINAPI
AudioClient_GetBufferSize(IAudioClient
*iface
,
1275 ACImpl
*This
= impl_from_IAudioClient(iface
);
1278 TRACE("(%p)->(%p)\n", This
, out
);
1283 pthread_mutex_lock(&pulse_lock
);
1284 hr
= pulse_stream_valid(This
);
1286 *out
= This
->bufsize_frames
;
1287 pthread_mutex_unlock(&pulse_lock
);
1292 static HRESULT WINAPI
AudioClient_GetStreamLatency(IAudioClient
*iface
,
1293 REFERENCE_TIME
*latency
)
1295 ACImpl
*This
= impl_from_IAudioClient(iface
);
1296 const pa_buffer_attr
*attr
;
1300 TRACE("(%p)->(%p)\n", This
, latency
);
1305 pthread_mutex_lock(&pulse_lock
);
1306 hr
= pulse_stream_valid(This
);
1308 pthread_mutex_unlock(&pulse_lock
);
1311 attr
= pa_stream_get_buffer_attr(This
->stream
);
1312 if (This
->dataflow
== eRender
)
1313 lat
= attr
->minreq
/ pa_frame_size(&This
->ss
);
1315 lat
= attr
->fragsize
/ pa_frame_size(&This
->ss
);
1316 *latency
= 10000000;
1318 *latency
/= This
->ss
.rate
;
1319 pthread_mutex_unlock(&pulse_lock
);
1320 TRACE("Latency: %u ms\n", (DWORD
)(*latency
/ 10000));
1324 static void ACImpl_GetRenderPad(ACImpl
*This
, UINT32
*out
)
1326 *out
= This
->pad
/ pa_frame_size(&This
->ss
);
1329 static void ACImpl_GetCapturePad(ACImpl
*This
, UINT32
*out
)
1331 ACPacket
*packet
= This
->locked_ptr
;
1332 if (!packet
&& !list_empty(&This
->packet_filled_head
)) {
1333 packet
= (ACPacket
*)list_head(&This
->packet_filled_head
);
1334 This
->locked_ptr
= packet
;
1335 list_remove(&packet
->entry
);
1338 *out
= This
->pad
/ pa_frame_size(&This
->ss
);
1341 static HRESULT WINAPI
AudioClient_GetCurrentPadding(IAudioClient
*iface
,
1344 ACImpl
*This
= impl_from_IAudioClient(iface
);
1347 TRACE("(%p)->(%p)\n", This
, out
);
1352 pthread_mutex_lock(&pulse_lock
);
1353 hr
= pulse_stream_valid(This
);
1355 pthread_mutex_unlock(&pulse_lock
);
1359 if (This
->dataflow
== eRender
)
1360 ACImpl_GetRenderPad(This
, out
);
1362 ACImpl_GetCapturePad(This
, out
);
1363 pthread_mutex_unlock(&pulse_lock
);
1365 TRACE("%p Pad: %u ms (%u)\n", This
, MulDiv(*out
, 1000, This
->ss
.rate
), *out
);
1369 static HRESULT WINAPI
AudioClient_IsFormatSupported(IAudioClient
*iface
,
1370 AUDCLNT_SHAREMODE mode
, const WAVEFORMATEX
*fmt
,
1373 ACImpl
*This
= impl_from_IAudioClient(iface
);
1375 WAVEFORMATEX
*closest
= NULL
;
1377 TRACE("(%p)->(%x, %p, %p)\n", This
, mode
, fmt
, out
);
1379 if (!fmt
|| (mode
== AUDCLNT_SHAREMODE_SHARED
&& !out
))
1384 if (mode
!= AUDCLNT_SHAREMODE_SHARED
&& mode
!= AUDCLNT_SHAREMODE_EXCLUSIVE
)
1385 return E_INVALIDARG
;
1386 if (mode
== AUDCLNT_SHAREMODE_EXCLUSIVE
)
1387 return This
->dataflow
== eCapture
? AUDCLNT_E_UNSUPPORTED_FORMAT
: AUDCLNT_E_EXCLUSIVE_MODE_NOT_ALLOWED
;
1388 switch (fmt
->wFormatTag
) {
1389 case WAVE_FORMAT_EXTENSIBLE
:
1390 if (fmt
->cbSize
< sizeof(WAVEFORMATEXTENSIBLE
) - sizeof(WAVEFORMATEX
))
1391 return E_INVALIDARG
;
1394 case WAVE_FORMAT_ALAW
:
1395 case WAVE_FORMAT_MULAW
:
1396 case WAVE_FORMAT_IEEE_FLOAT
:
1397 case WAVE_FORMAT_PCM
:
1402 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1404 if (fmt
->nChannels
== 0)
1405 return AUDCLNT_E_UNSUPPORTED_FORMAT
;
1406 closest
= clone_format(fmt
);
1410 return E_OUTOFMEMORY
;
1413 if (fmt
->wFormatTag
== WAVE_FORMAT_EXTENSIBLE
) {
1414 UINT32 mask
= 0, i
, channels
= 0;
1415 WAVEFORMATEXTENSIBLE
*ext
= (WAVEFORMATEXTENSIBLE
*)closest
;
1417 if ((fmt
->nChannels
> 1 && ext
->dwChannelMask
== SPEAKER_ALL
) ||
1418 (fmt
->nChannels
== 1 && ext
->dwChannelMask
== ~0U)) {
1419 mask
= ext
->dwChannelMask
;
1420 channels
= fmt
->nChannels
;
1421 } else if (ext
->dwChannelMask
) {
1422 for (i
= 1; !(i
& SPEAKER_RESERVED
); i
<<= 1) {
1423 if (i
& ext
->dwChannelMask
) {
1428 if (channels
< fmt
->nChannels
)
1429 mask
= get_channel_mask(fmt
->nChannels
);
1431 mask
= ext
->dwChannelMask
;
1432 if (ext
->dwChannelMask
!= mask
) {
1433 ext
->dwChannelMask
= mask
;
1438 if (hr
== S_OK
|| !out
) {
1439 CoTaskMemFree(closest
);
1442 } else if (closest
) {
1443 closest
->nBlockAlign
=
1444 closest
->nChannels
* closest
->wBitsPerSample
/ 8;
1445 closest
->nAvgBytesPerSec
=
1446 closest
->nBlockAlign
* closest
->nSamplesPerSec
;
1450 TRACE("returning: %08x %p\n", hr
, out
? *out
: NULL
);
1454 static HRESULT WINAPI
AudioClient_GetMixFormat(IAudioClient
*iface
,
1455 WAVEFORMATEX
**pwfx
)
1457 ACImpl
*This
= impl_from_IAudioClient(iface
);
1458 WAVEFORMATEXTENSIBLE
*fmt
= &pulse_fmt
[This
->dataflow
== eCapture
];
1460 TRACE("(%p)->(%p)\n", This
, pwfx
);
1465 *pwfx
= clone_format(&fmt
->Format
);
1467 return E_OUTOFMEMORY
;
1472 static HRESULT WINAPI
AudioClient_GetDevicePeriod(IAudioClient
*iface
,
1473 REFERENCE_TIME
*defperiod
, REFERENCE_TIME
*minperiod
)
1475 ACImpl
*This
= impl_from_IAudioClient(iface
);
1477 TRACE("(%p)->(%p, %p)\n", This
, defperiod
, minperiod
);
1479 if (!defperiod
&& !minperiod
)
1483 *defperiod
= pulse_def_period
[This
->dataflow
== eCapture
];
1485 *minperiod
= pulse_min_period
[This
->dataflow
== eCapture
];
1490 static HRESULT WINAPI
AudioClient_Start(IAudioClient
*iface
)
1492 ACImpl
*This
= impl_from_IAudioClient(iface
);
1497 TRACE("(%p)\n", This
);
1499 pthread_mutex_lock(&pulse_lock
);
1500 hr
= pulse_stream_valid(This
);
1502 pthread_mutex_unlock(&pulse_lock
);
1506 if ((This
->flags
& AUDCLNT_STREAMFLAGS_EVENTCALLBACK
) && !This
->event
) {
1507 pthread_mutex_unlock(&pulse_lock
);
1508 return AUDCLNT_E_EVENTHANDLE_NOT_SET
;
1511 if (This
->started
) {
1512 pthread_mutex_unlock(&pulse_lock
);
1513 return AUDCLNT_E_NOT_STOPPED
;
1516 if (pa_stream_is_corked(This
->stream
)) {
1517 o
= pa_stream_cork(This
->stream
, 0, pulse_op_cb
, &success
);
1519 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1520 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
1521 pa_operation_unref(o
);
1527 if (SUCCEEDED(hr
)) {
1528 This
->started
= TRUE
;
1529 if (This
->dataflow
== eRender
&& This
->event
)
1530 pa_stream_set_latency_update_callback(This
->stream
, pulse_latency_callback
, This
);
1532 pthread_mutex_unlock(&pulse_lock
);
1536 static HRESULT WINAPI
AudioClient_Stop(IAudioClient
*iface
)
1538 ACImpl
*This
= impl_from_IAudioClient(iface
);
1543 TRACE("(%p)\n", This
);
1545 pthread_mutex_lock(&pulse_lock
);
1546 hr
= pulse_stream_valid(This
);
1548 pthread_mutex_unlock(&pulse_lock
);
1552 if (!This
->started
) {
1553 pthread_mutex_unlock(&pulse_lock
);
1557 if (This
->dataflow
== eRender
) {
1558 o
= pa_stream_cork(This
->stream
, 1, pulse_op_cb
, &success
);
1560 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1561 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
1562 pa_operation_unref(o
);
1568 if (SUCCEEDED(hr
)) {
1569 This
->started
= FALSE
;
1571 pthread_mutex_unlock(&pulse_lock
);
1575 static HRESULT WINAPI
AudioClient_Reset(IAudioClient
*iface
)
1577 ACImpl
*This
= impl_from_IAudioClient(iface
);
1580 TRACE("(%p)\n", This
);
1582 pthread_mutex_lock(&pulse_lock
);
1583 hr
= pulse_stream_valid(This
);
1585 pthread_mutex_unlock(&pulse_lock
);
1589 if (This
->started
) {
1590 pthread_mutex_unlock(&pulse_lock
);
1591 return AUDCLNT_E_NOT_STOPPED
;
1595 pthread_mutex_unlock(&pulse_lock
);
1596 return AUDCLNT_E_BUFFER_OPERATION_PENDING
;
1599 if (This
->dataflow
== eRender
) {
1600 /* If there is still data in the render buffer it needs to be removed from the server */
1603 pa_operation
*o
= pa_stream_flush(This
->stream
, pulse_op_cb
, &success
);
1605 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
1606 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
1607 pa_operation_unref(o
);
1610 if (success
|| !This
->pad
)
1611 This
->clock_lastpos
= This
->clock_written
= This
->pad
= 0;
1614 This
->clock_written
+= This
->pad
;
1617 if ((p
= This
->locked_ptr
)) {
1618 This
->locked_ptr
= NULL
;
1619 list_add_tail(&This
->packet_free_head
, &p
->entry
);
1621 list_move_tail(&This
->packet_free_head
, &This
->packet_filled_head
);
1623 pthread_mutex_unlock(&pulse_lock
);
1628 static HRESULT WINAPI
AudioClient_SetEventHandle(IAudioClient
*iface
,
1631 ACImpl
*This
= impl_from_IAudioClient(iface
);
1634 TRACE("(%p)->(%p)\n", This
, event
);
1637 return E_INVALIDARG
;
1639 pthread_mutex_lock(&pulse_lock
);
1640 hr
= pulse_stream_valid(This
);
1642 pthread_mutex_unlock(&pulse_lock
);
1646 if (!(This
->flags
& AUDCLNT_STREAMFLAGS_EVENTCALLBACK
))
1647 hr
= AUDCLNT_E_EVENTHANDLE_NOT_EXPECTED
;
1648 else if (This
->event
)
1649 hr
= HRESULT_FROM_WIN32(ERROR_INVALID_NAME
);
1651 This
->event
= event
;
1652 pthread_mutex_unlock(&pulse_lock
);
1656 static HRESULT WINAPI
AudioClient_GetService(IAudioClient
*iface
, REFIID riid
,
1659 ACImpl
*This
= impl_from_IAudioClient(iface
);
1662 TRACE("(%p)->(%s, %p)\n", This
, debugstr_guid(riid
), ppv
);
1668 pthread_mutex_lock(&pulse_lock
);
1669 hr
= pulse_stream_valid(This
);
1670 pthread_mutex_unlock(&pulse_lock
);
1674 if (IsEqualIID(riid
, &IID_IAudioRenderClient
)) {
1675 if (This
->dataflow
!= eRender
)
1676 return AUDCLNT_E_WRONG_ENDPOINT_TYPE
;
1677 *ppv
= &This
->IAudioRenderClient_iface
;
1678 } else if (IsEqualIID(riid
, &IID_IAudioCaptureClient
)) {
1679 if (This
->dataflow
!= eCapture
)
1680 return AUDCLNT_E_WRONG_ENDPOINT_TYPE
;
1681 *ppv
= &This
->IAudioCaptureClient_iface
;
1682 } else if (IsEqualIID(riid
, &IID_IAudioClock
)) {
1683 *ppv
= &This
->IAudioClock_iface
;
1684 } else if (IsEqualIID(riid
, &IID_IAudioStreamVolume
)) {
1685 *ppv
= &This
->IAudioStreamVolume_iface
;
1686 } else if (IsEqualIID(riid
, &IID_IAudioSessionControl
) ||
1687 IsEqualIID(riid
, &IID_IChannelAudioVolume
) ||
1688 IsEqualIID(riid
, &IID_ISimpleAudioVolume
)) {
1689 if (!This
->session_wrapper
) {
1690 This
->session_wrapper
= AudioSessionWrapper_Create(This
);
1691 if (!This
->session_wrapper
)
1692 return E_OUTOFMEMORY
;
1694 if (IsEqualIID(riid
, &IID_IAudioSessionControl
))
1695 *ppv
= &This
->session_wrapper
->IAudioSessionControl2_iface
;
1696 else if (IsEqualIID(riid
, &IID_IChannelAudioVolume
))
1697 *ppv
= &This
->session_wrapper
->IChannelAudioVolume_iface
;
1698 else if (IsEqualIID(riid
, &IID_ISimpleAudioVolume
))
1699 *ppv
= &This
->session_wrapper
->ISimpleAudioVolume_iface
;
1703 IUnknown_AddRef((IUnknown
*)*ppv
);
1707 FIXME("stub %s\n", debugstr_guid(riid
));
1708 return E_NOINTERFACE
;
1711 static const IAudioClientVtbl AudioClient_Vtbl
=
1713 AudioClient_QueryInterface
,
1715 AudioClient_Release
,
1716 AudioClient_Initialize
,
1717 AudioClient_GetBufferSize
,
1718 AudioClient_GetStreamLatency
,
1719 AudioClient_GetCurrentPadding
,
1720 AudioClient_IsFormatSupported
,
1721 AudioClient_GetMixFormat
,
1722 AudioClient_GetDevicePeriod
,
1726 AudioClient_SetEventHandle
,
1727 AudioClient_GetService
1730 static HRESULT WINAPI
AudioRenderClient_QueryInterface(
1731 IAudioRenderClient
*iface
, REFIID riid
, void **ppv
)
1733 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
1739 if (IsEqualIID(riid
, &IID_IUnknown
) ||
1740 IsEqualIID(riid
, &IID_IAudioRenderClient
))
1743 IUnknown_AddRef((IUnknown
*)*ppv
);
1747 WARN("Unknown interface %s\n", debugstr_guid(riid
));
1748 return E_NOINTERFACE
;
1751 static ULONG WINAPI
AudioRenderClient_AddRef(IAudioRenderClient
*iface
)
1753 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1754 return AudioClient_AddRef(&This
->IAudioClient_iface
);
1757 static ULONG WINAPI
AudioRenderClient_Release(IAudioRenderClient
*iface
)
1759 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1760 return AudioClient_Release(&This
->IAudioClient_iface
);
1763 static HRESULT WINAPI
AudioRenderClient_GetBuffer(IAudioRenderClient
*iface
,
1764 UINT32 frames
, BYTE
**data
)
1766 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1767 size_t avail
, req
, bytes
= frames
* pa_frame_size(&This
->ss
);
1772 TRACE("(%p)->(%u, %p)\n", This
, frames
, data
);
1778 pthread_mutex_lock(&pulse_lock
);
1779 hr
= pulse_stream_valid(This
);
1780 if (FAILED(hr
) || This
->locked
) {
1781 pthread_mutex_unlock(&pulse_lock
);
1782 return FAILED(hr
) ? hr
: AUDCLNT_E_OUT_OF_ORDER
;
1785 pthread_mutex_unlock(&pulse_lock
);
1789 ACImpl_GetRenderPad(This
, &pad
);
1790 avail
= This
->bufsize_frames
- pad
;
1791 if (avail
< frames
|| bytes
> This
->bufsize_bytes
) {
1792 pthread_mutex_unlock(&pulse_lock
);
1793 WARN("Wanted to write %u, but only %zu available\n", frames
, avail
);
1794 return AUDCLNT_E_BUFFER_TOO_LARGE
;
1797 This
->locked
= frames
;
1799 ret
= pa_stream_begin_write(This
->stream
, &This
->locked_ptr
, &req
);
1800 if (ret
< 0 || req
< bytes
) {
1801 FIXME("%p Not using pulse locked data: %i %zu/%u %u/%u\n", This
, ret
, req
/pa_frame_size(&This
->ss
), frames
, pad
, This
->bufsize_frames
);
1803 pa_stream_cancel_write(This
->stream
);
1804 *data
= This
->tmp_buffer
;
1805 This
->locked_ptr
= NULL
;
1807 *data
= This
->locked_ptr
;
1808 pthread_mutex_unlock(&pulse_lock
);
1812 static HRESULT WINAPI
AudioRenderClient_ReleaseBuffer(
1813 IAudioRenderClient
*iface
, UINT32 written_frames
, DWORD flags
)
1815 ACImpl
*This
= impl_from_IAudioRenderClient(iface
);
1816 UINT32 written_bytes
= written_frames
* pa_frame_size(&This
->ss
);
1819 TRACE("(%p)->(%u, %x)\n", This
, written_frames
, flags
);
1821 pthread_mutex_lock(&pulse_lock
);
1822 if (!This
->locked
|| !written_frames
) {
1823 if (This
->locked_ptr
)
1824 pa_stream_cancel_write(This
->stream
);
1826 This
->locked_ptr
= NULL
;
1827 pthread_mutex_unlock(&pulse_lock
);
1828 return written_frames
? AUDCLNT_E_OUT_OF_ORDER
: S_OK
;
1831 if (This
->locked
< written_frames
) {
1832 pthread_mutex_unlock(&pulse_lock
);
1833 return AUDCLNT_E_INVALID_SIZE
;
1836 if (flags
& AUDCLNT_BUFFERFLAGS_SILENT
) {
1837 if (This
->ss
.format
== PA_SAMPLE_U8
)
1838 memset(This
->tmp_buffer
, 128, written_bytes
);
1840 memset(This
->tmp_buffer
, 0, written_bytes
);
1844 if (This
->locked_ptr
)
1845 pa_stream_write(This
->stream
, This
->locked_ptr
, written_bytes
, NULL
, 0, PA_SEEK_RELATIVE
);
1847 pa_stream_write(This
->stream
, This
->tmp_buffer
, written_bytes
, NULL
, 0, PA_SEEK_RELATIVE
);
1848 This
->pad
+= written_bytes
;
1849 This
->locked_ptr
= NULL
;
1850 TRACE("Released %u, pad %zu\n", written_frames
, This
->pad
/ pa_frame_size(&This
->ss
));
1851 assert(This
->pad
<= This
->bufsize_bytes
);
1853 period
= pa_stream_get_buffer_attr(This
->stream
)->minreq
;
1854 /* Require a minimum of 3 periods filled, if possible */
1855 if (This
->event
&& This
->pad
+ period
<= This
->bufsize_bytes
&& This
->pad
< period
* 3)
1856 SetEvent(This
->event
);
1857 pthread_mutex_unlock(&pulse_lock
);
1861 static const IAudioRenderClientVtbl AudioRenderClient_Vtbl
= {
1862 AudioRenderClient_QueryInterface
,
1863 AudioRenderClient_AddRef
,
1864 AudioRenderClient_Release
,
1865 AudioRenderClient_GetBuffer
,
1866 AudioRenderClient_ReleaseBuffer
1869 static HRESULT WINAPI
AudioCaptureClient_QueryInterface(
1870 IAudioCaptureClient
*iface
, REFIID riid
, void **ppv
)
1872 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
1878 if (IsEqualIID(riid
, &IID_IUnknown
) ||
1879 IsEqualIID(riid
, &IID_IAudioCaptureClient
))
1882 IUnknown_AddRef((IUnknown
*)*ppv
);
1886 WARN("Unknown interface %s\n", debugstr_guid(riid
));
1887 return E_NOINTERFACE
;
1890 static ULONG WINAPI
AudioCaptureClient_AddRef(IAudioCaptureClient
*iface
)
1892 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
1893 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
1896 static ULONG WINAPI
AudioCaptureClient_Release(IAudioCaptureClient
*iface
)
1898 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
1899 return IAudioClient_Release(&This
->IAudioClient_iface
);
1902 static HRESULT WINAPI
AudioCaptureClient_GetBuffer(IAudioCaptureClient
*iface
,
1903 BYTE
**data
, UINT32
*frames
, DWORD
*flags
, UINT64
*devpos
,
1906 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
1910 TRACE("(%p)->(%p, %p, %p, %p, %p)\n", This
, data
, frames
, flags
,
1913 if (!data
|| !frames
|| !flags
)
1916 pthread_mutex_lock(&pulse_lock
);
1917 hr
= pulse_stream_valid(This
);
1918 if (FAILED(hr
) || This
->locked
) {
1919 pthread_mutex_unlock(&pulse_lock
);
1920 return FAILED(hr
) ? hr
: AUDCLNT_E_OUT_OF_ORDER
;
1923 ACImpl_GetCapturePad(This
, NULL
);
1924 if ((packet
= This
->locked_ptr
)) {
1925 *frames
= This
->capture_period
/ pa_frame_size(&This
->ss
);
1927 if (packet
->discont
)
1928 *flags
|= AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY
;
1930 if (packet
->discont
)
1931 *devpos
= (This
->clock_written
+ This
->capture_period
) / pa_frame_size(&This
->ss
);
1933 *devpos
= This
->clock_written
/ pa_frame_size(&This
->ss
);
1936 *qpcpos
= packet
->qpcpos
;
1937 *data
= packet
->data
;
1941 This
->locked
= *frames
;
1942 pthread_mutex_unlock(&pulse_lock
);
1943 return *frames
? S_OK
: AUDCLNT_S_BUFFER_EMPTY
;
1946 static HRESULT WINAPI
AudioCaptureClient_ReleaseBuffer(
1947 IAudioCaptureClient
*iface
, UINT32 done
)
1949 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
1951 TRACE("(%p)->(%u)\n", This
, done
);
1953 pthread_mutex_lock(&pulse_lock
);
1954 if (!This
->locked
&& done
) {
1955 pthread_mutex_unlock(&pulse_lock
);
1956 return AUDCLNT_E_OUT_OF_ORDER
;
1958 if (done
&& This
->locked
!= done
) {
1959 pthread_mutex_unlock(&pulse_lock
);
1960 return AUDCLNT_E_INVALID_SIZE
;
1963 ACPacket
*packet
= This
->locked_ptr
;
1964 This
->locked_ptr
= NULL
;
1965 This
->pad
-= This
->capture_period
;
1966 if (packet
->discont
)
1967 This
->clock_written
+= 2 * This
->capture_period
;
1969 This
->clock_written
+= This
->capture_period
;
1970 list_add_tail(&This
->packet_free_head
, &packet
->entry
);
1973 pthread_mutex_unlock(&pulse_lock
);
1977 static HRESULT WINAPI
AudioCaptureClient_GetNextPacketSize(
1978 IAudioCaptureClient
*iface
, UINT32
*frames
)
1980 ACImpl
*This
= impl_from_IAudioCaptureClient(iface
);
1983 TRACE("(%p)->(%p)\n", This
, frames
);
1987 pthread_mutex_lock(&pulse_lock
);
1988 ACImpl_GetCapturePad(This
, NULL
);
1989 p
= This
->locked_ptr
;
1991 *frames
= This
->capture_period
/ pa_frame_size(&This
->ss
);
1994 pthread_mutex_unlock(&pulse_lock
);
1998 static const IAudioCaptureClientVtbl AudioCaptureClient_Vtbl
=
2000 AudioCaptureClient_QueryInterface
,
2001 AudioCaptureClient_AddRef
,
2002 AudioCaptureClient_Release
,
2003 AudioCaptureClient_GetBuffer
,
2004 AudioCaptureClient_ReleaseBuffer
,
2005 AudioCaptureClient_GetNextPacketSize
2008 static HRESULT WINAPI
AudioClock_QueryInterface(IAudioClock
*iface
,
2009 REFIID riid
, void **ppv
)
2011 ACImpl
*This
= impl_from_IAudioClock(iface
);
2013 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2019 if (IsEqualIID(riid
, &IID_IUnknown
) || IsEqualIID(riid
, &IID_IAudioClock
))
2021 else if (IsEqualIID(riid
, &IID_IAudioClock2
))
2022 *ppv
= &This
->IAudioClock2_iface
;
2024 IUnknown_AddRef((IUnknown
*)*ppv
);
2028 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2029 return E_NOINTERFACE
;
2032 static ULONG WINAPI
AudioClock_AddRef(IAudioClock
*iface
)
2034 ACImpl
*This
= impl_from_IAudioClock(iface
);
2035 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2038 static ULONG WINAPI
AudioClock_Release(IAudioClock
*iface
)
2040 ACImpl
*This
= impl_from_IAudioClock(iface
);
2041 return IAudioClient_Release(&This
->IAudioClient_iface
);
2044 static HRESULT WINAPI
AudioClock_GetFrequency(IAudioClock
*iface
, UINT64
*freq
)
2046 ACImpl
*This
= impl_from_IAudioClock(iface
);
2049 TRACE("(%p)->(%p)\n", This
, freq
);
2051 pthread_mutex_lock(&pulse_lock
);
2052 hr
= pulse_stream_valid(This
);
2054 *freq
= This
->ss
.rate
* pa_frame_size(&This
->ss
);
2055 pthread_mutex_unlock(&pulse_lock
);
2059 static HRESULT WINAPI
AudioClock_GetPosition(IAudioClock
*iface
, UINT64
*pos
,
2062 ACImpl
*This
= impl_from_IAudioClock(iface
);
2065 TRACE("(%p)->(%p, %p)\n", This
, pos
, qpctime
);
2070 pthread_mutex_lock(&pulse_lock
);
2071 hr
= pulse_stream_valid(This
);
2073 pthread_mutex_unlock(&pulse_lock
);
2077 *pos
= This
->clock_written
;
2079 /* Make time never go backwards */
2080 if (*pos
< This
->clock_lastpos
)
2081 *pos
= This
->clock_lastpos
;
2083 This
->clock_lastpos
= *pos
;
2084 pthread_mutex_unlock(&pulse_lock
);
2086 TRACE("%p Position: %u\n", This
, (unsigned)*pos
);
2089 LARGE_INTEGER stamp
, freq
;
2090 QueryPerformanceCounter(&stamp
);
2091 QueryPerformanceFrequency(&freq
);
2092 *qpctime
= (stamp
.QuadPart
* (INT64
)10000000) / freq
.QuadPart
;
2098 static HRESULT WINAPI
AudioClock_GetCharacteristics(IAudioClock
*iface
,
2101 ACImpl
*This
= impl_from_IAudioClock(iface
);
2103 TRACE("(%p)->(%p)\n", This
, chars
);
2108 *chars
= AUDIOCLOCK_CHARACTERISTIC_FIXED_FREQ
;
2113 static const IAudioClockVtbl AudioClock_Vtbl
=
2115 AudioClock_QueryInterface
,
2118 AudioClock_GetFrequency
,
2119 AudioClock_GetPosition
,
2120 AudioClock_GetCharacteristics
2123 static HRESULT WINAPI
AudioClock2_QueryInterface(IAudioClock2
*iface
,
2124 REFIID riid
, void **ppv
)
2126 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2127 return IAudioClock_QueryInterface(&This
->IAudioClock_iface
, riid
, ppv
);
2130 static ULONG WINAPI
AudioClock2_AddRef(IAudioClock2
*iface
)
2132 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2133 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2136 static ULONG WINAPI
AudioClock2_Release(IAudioClock2
*iface
)
2138 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2139 return IAudioClient_Release(&This
->IAudioClient_iface
);
2142 static HRESULT WINAPI
AudioClock2_GetDevicePosition(IAudioClock2
*iface
,
2143 UINT64
*pos
, UINT64
*qpctime
)
2145 ACImpl
*This
= impl_from_IAudioClock2(iface
);
2146 HRESULT hr
= AudioClock_GetPosition(&This
->IAudioClock_iface
, pos
, qpctime
);
2148 *pos
/= pa_frame_size(&This
->ss
);
2152 static const IAudioClock2Vtbl AudioClock2_Vtbl
=
2154 AudioClock2_QueryInterface
,
2156 AudioClock2_Release
,
2157 AudioClock2_GetDevicePosition
2160 static HRESULT WINAPI
AudioStreamVolume_QueryInterface(
2161 IAudioStreamVolume
*iface
, REFIID riid
, void **ppv
)
2163 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2169 if (IsEqualIID(riid
, &IID_IUnknown
) ||
2170 IsEqualIID(riid
, &IID_IAudioStreamVolume
))
2173 IUnknown_AddRef((IUnknown
*)*ppv
);
2177 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2178 return E_NOINTERFACE
;
2181 static ULONG WINAPI
AudioStreamVolume_AddRef(IAudioStreamVolume
*iface
)
2183 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2184 return IAudioClient_AddRef(&This
->IAudioClient_iface
);
2187 static ULONG WINAPI
AudioStreamVolume_Release(IAudioStreamVolume
*iface
)
2189 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2190 return IAudioClient_Release(&This
->IAudioClient_iface
);
2193 static HRESULT WINAPI
AudioStreamVolume_GetChannelCount(
2194 IAudioStreamVolume
*iface
, UINT32
*out
)
2196 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2198 TRACE("(%p)->(%p)\n", This
, out
);
2203 *out
= This
->ss
.channels
;
2208 struct pulse_info_cb_data
{
2213 static void pulse_sink_input_info_cb(pa_context
*c
, const pa_sink_input_info
*info
, int eol
, void *data
)
2215 struct pulse_info_cb_data
*d
= data
;
2219 for (i
= 0; i
< d
->n
; ++i
)
2220 d
->levels
[i
] = (float)info
->volume
.values
[i
] / (float)PA_VOLUME_NORM
;
2221 pthread_cond_signal(&pulse_cond
);
2224 static void pulse_source_info_cb(pa_context
*c
, const pa_source_info
*info
, int eol
, void *data
)
2226 struct pulse_info_cb_data
*d
= data
;
2230 for (i
= 0; i
< d
->n
; ++i
)
2231 d
->levels
[i
] = (float)info
->volume
.values
[i
] / (float)PA_VOLUME_NORM
;
2232 pthread_cond_signal(&pulse_cond
);
2235 static HRESULT WINAPI
AudioStreamVolume_SetAllVolumes(
2236 IAudioStreamVolume
*iface
, UINT32 count
, const float *levels
)
2238 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2244 TRACE("(%p)->(%d, %p)\n", This
, count
, levels
);
2249 if (count
!= This
->ss
.channels
)
2250 return E_INVALIDARG
;
2252 pthread_mutex_lock(&pulse_lock
);
2253 hr
= pulse_stream_valid(This
);
2257 if (pulse_stream_volume
) {
2258 cv
.channels
= count
;
2259 for (i
= 0; i
< cv
.channels
; ++i
)
2260 cv
.values
[i
] = levels
[i
] * (float)PA_VOLUME_NORM
;
2261 if (This
->dataflow
== eRender
)
2262 o
= pa_context_set_sink_input_volume(pulse_ctx
, pa_stream_get_index(This
->stream
), &cv
, pulse_ctx_op_cb
, &success
);
2264 o
= pa_context_set_source_volume_by_index(pulse_ctx
, pa_stream_get_device_index(This
->stream
), &cv
, pulse_ctx_op_cb
, &success
);
2266 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
2267 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
2268 pa_operation_unref(o
);
2271 hr
= AUDCLNT_E_BUFFER_ERROR
;
2274 for (i
= 0; i
< count
; ++i
)
2275 This
->vol
[i
] = levels
[i
];
2279 pthread_mutex_unlock(&pulse_lock
);
2283 static HRESULT WINAPI
AudioStreamVolume_GetAllVolumes(
2284 IAudioStreamVolume
*iface
, UINT32 count
, float *levels
)
2286 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2289 struct pulse_info_cb_data info
;
2291 TRACE("(%p)->(%d, %p)\n", This
, count
, levels
);
2296 if (count
!= This
->ss
.channels
)
2297 return E_INVALIDARG
;
2299 pthread_mutex_lock(&pulse_lock
);
2300 hr
= pulse_stream_valid(This
);
2304 if (pulse_stream_volume
) {
2306 info
.levels
= levels
;
2307 if (This
->dataflow
== eRender
)
2308 o
= pa_context_get_sink_input_info(pulse_ctx
, pa_stream_get_index(This
->stream
), pulse_sink_input_info_cb
, &info
);
2310 o
= pa_context_get_source_info_by_index(pulse_ctx
, pa_stream_get_device_index(This
->stream
), pulse_source_info_cb
, &info
);
2312 while(pa_operation_get_state(o
) == PA_OPERATION_RUNNING
)
2313 pthread_cond_wait(&pulse_cond
, &pulse_lock
);
2314 pa_operation_unref(o
);
2316 hr
= AUDCLNT_E_BUFFER_ERROR
;
2319 for (i
= 0; i
< count
; ++i
)
2320 levels
[i
] = This
->vol
[i
];
2324 pthread_mutex_unlock(&pulse_lock
);
2328 static HRESULT WINAPI
AudioStreamVolume_SetChannelVolume(
2329 IAudioStreamVolume
*iface
, UINT32 index
, float level
)
2331 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2333 float volumes
[PA_CHANNELS_MAX
];
2335 TRACE("(%p)->(%d, %f)\n", This
, index
, level
);
2337 if (level
< 0.f
|| level
> 1.f
)
2338 return E_INVALIDARG
;
2340 if (index
>= This
->ss
.channels
)
2341 return E_INVALIDARG
;
2343 hr
= AudioStreamVolume_GetAllVolumes(iface
, This
->ss
.channels
, volumes
);
2344 volumes
[index
] = level
;
2346 hr
= AudioStreamVolume_SetAllVolumes(iface
, This
->ss
.channels
, volumes
);
2350 static HRESULT WINAPI
AudioStreamVolume_GetChannelVolume(
2351 IAudioStreamVolume
*iface
, UINT32 index
, float *level
)
2353 ACImpl
*This
= impl_from_IAudioStreamVolume(iface
);
2354 float volumes
[PA_CHANNELS_MAX
];
2357 TRACE("(%p)->(%d, %p)\n", This
, index
, level
);
2362 if (index
>= This
->ss
.channels
)
2363 return E_INVALIDARG
;
2365 hr
= AudioStreamVolume_GetAllVolumes(iface
, This
->ss
.channels
, volumes
);
2367 *level
= volumes
[index
];
2371 static const IAudioStreamVolumeVtbl AudioStreamVolume_Vtbl
=
2373 AudioStreamVolume_QueryInterface
,
2374 AudioStreamVolume_AddRef
,
2375 AudioStreamVolume_Release
,
2376 AudioStreamVolume_GetChannelCount
,
2377 AudioStreamVolume_SetChannelVolume
,
2378 AudioStreamVolume_GetChannelVolume
,
2379 AudioStreamVolume_SetAllVolumes
,
2380 AudioStreamVolume_GetAllVolumes
2383 static AudioSessionWrapper
*AudioSessionWrapper_Create(ACImpl
*client
)
2385 AudioSessionWrapper
*ret
;
2387 ret
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
,
2388 sizeof(AudioSessionWrapper
));
2392 ret
->IAudioSessionControl2_iface
.lpVtbl
= &AudioSessionControl2_Vtbl
;
2393 ret
->ISimpleAudioVolume_iface
.lpVtbl
= &SimpleAudioVolume_Vtbl
;
2394 ret
->IChannelAudioVolume_iface
.lpVtbl
= &ChannelAudioVolume_Vtbl
;
2398 ret
->client
= client
;
2400 ret
->session
= client
->session
;
2401 AudioClient_AddRef(&client
->IAudioClient_iface
);
2407 static HRESULT WINAPI
AudioSessionControl_QueryInterface(
2408 IAudioSessionControl2
*iface
, REFIID riid
, void **ppv
)
2410 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2416 if (IsEqualIID(riid
, &IID_IUnknown
) ||
2417 IsEqualIID(riid
, &IID_IAudioSessionControl
) ||
2418 IsEqualIID(riid
, &IID_IAudioSessionControl2
))
2421 IUnknown_AddRef((IUnknown
*)*ppv
);
2425 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2426 return E_NOINTERFACE
;
2429 static ULONG WINAPI
AudioSessionControl_AddRef(IAudioSessionControl2
*iface
)
2431 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2433 ref
= InterlockedIncrement(&This
->ref
);
2434 TRACE("(%p) Refcount now %u\n", This
, ref
);
2438 static ULONG WINAPI
AudioSessionControl_Release(IAudioSessionControl2
*iface
)
2440 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2442 ref
= InterlockedDecrement(&This
->ref
);
2443 TRACE("(%p) Refcount now %u\n", This
, ref
);
2446 This
->client
->session_wrapper
= NULL
;
2447 AudioClient_Release(&This
->client
->IAudioClient_iface
);
2449 HeapFree(GetProcessHeap(), 0, This
);
2454 static HRESULT WINAPI
AudioSessionControl_GetState(IAudioSessionControl2
*iface
,
2455 AudioSessionState
*state
)
2457 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2460 TRACE("(%p)->(%p)\n", This
, state
);
2463 return NULL_PTR_ERR
;
2465 pthread_mutex_lock(&pulse_lock
);
2466 if (list_empty(&This
->session
->clients
)) {
2467 *state
= AudioSessionStateExpired
;
2470 LIST_FOR_EACH_ENTRY(client
, &This
->session
->clients
, ACImpl
, entry
) {
2471 if (client
->started
) {
2472 *state
= AudioSessionStateActive
;
2476 *state
= AudioSessionStateInactive
;
2479 pthread_mutex_unlock(&pulse_lock
);
2483 static HRESULT WINAPI
AudioSessionControl_GetDisplayName(
2484 IAudioSessionControl2
*iface
, WCHAR
**name
)
2486 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2488 FIXME("(%p)->(%p) - stub\n", This
, name
);
2493 static HRESULT WINAPI
AudioSessionControl_SetDisplayName(
2494 IAudioSessionControl2
*iface
, const WCHAR
*name
, const GUID
*session
)
2496 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2498 FIXME("(%p)->(%p, %s) - stub\n", This
, name
, debugstr_guid(session
));
2503 static HRESULT WINAPI
AudioSessionControl_GetIconPath(
2504 IAudioSessionControl2
*iface
, WCHAR
**path
)
2506 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2508 FIXME("(%p)->(%p) - stub\n", This
, path
);
2513 static HRESULT WINAPI
AudioSessionControl_SetIconPath(
2514 IAudioSessionControl2
*iface
, const WCHAR
*path
, const GUID
*session
)
2516 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2518 FIXME("(%p)->(%p, %s) - stub\n", This
, path
, debugstr_guid(session
));
2523 static HRESULT WINAPI
AudioSessionControl_GetGroupingParam(
2524 IAudioSessionControl2
*iface
, GUID
*group
)
2526 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2528 FIXME("(%p)->(%p) - stub\n", This
, group
);
2533 static HRESULT WINAPI
AudioSessionControl_SetGroupingParam(
2534 IAudioSessionControl2
*iface
, const GUID
*group
, const GUID
*session
)
2536 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2538 FIXME("(%p)->(%s, %s) - stub\n", This
, debugstr_guid(group
),
2539 debugstr_guid(session
));
2544 static HRESULT WINAPI
AudioSessionControl_RegisterAudioSessionNotification(
2545 IAudioSessionControl2
*iface
, IAudioSessionEvents
*events
)
2547 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2549 FIXME("(%p)->(%p) - stub\n", This
, events
);
2554 static HRESULT WINAPI
AudioSessionControl_UnregisterAudioSessionNotification(
2555 IAudioSessionControl2
*iface
, IAudioSessionEvents
*events
)
2557 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2559 FIXME("(%p)->(%p) - stub\n", This
, events
);
2564 static HRESULT WINAPI
AudioSessionControl_GetSessionIdentifier(
2565 IAudioSessionControl2
*iface
, WCHAR
**id
)
2567 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2569 FIXME("(%p)->(%p) - stub\n", This
, id
);
2574 static HRESULT WINAPI
AudioSessionControl_GetSessionInstanceIdentifier(
2575 IAudioSessionControl2
*iface
, WCHAR
**id
)
2577 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2579 FIXME("(%p)->(%p) - stub\n", This
, id
);
2584 static HRESULT WINAPI
AudioSessionControl_GetProcessId(
2585 IAudioSessionControl2
*iface
, DWORD
*pid
)
2587 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2589 TRACE("(%p)->(%p)\n", This
, pid
);
2594 *pid
= GetCurrentProcessId();
2599 static HRESULT WINAPI
AudioSessionControl_IsSystemSoundsSession(
2600 IAudioSessionControl2
*iface
)
2602 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2604 TRACE("(%p)\n", This
);
2609 static HRESULT WINAPI
AudioSessionControl_SetDuckingPreference(
2610 IAudioSessionControl2
*iface
, BOOL optout
)
2612 AudioSessionWrapper
*This
= impl_from_IAudioSessionControl2(iface
);
2614 TRACE("(%p)->(%d)\n", This
, optout
);
2619 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl
=
2621 AudioSessionControl_QueryInterface
,
2622 AudioSessionControl_AddRef
,
2623 AudioSessionControl_Release
,
2624 AudioSessionControl_GetState
,
2625 AudioSessionControl_GetDisplayName
,
2626 AudioSessionControl_SetDisplayName
,
2627 AudioSessionControl_GetIconPath
,
2628 AudioSessionControl_SetIconPath
,
2629 AudioSessionControl_GetGroupingParam
,
2630 AudioSessionControl_SetGroupingParam
,
2631 AudioSessionControl_RegisterAudioSessionNotification
,
2632 AudioSessionControl_UnregisterAudioSessionNotification
,
2633 AudioSessionControl_GetSessionIdentifier
,
2634 AudioSessionControl_GetSessionInstanceIdentifier
,
2635 AudioSessionControl_GetProcessId
,
2636 AudioSessionControl_IsSystemSoundsSession
,
2637 AudioSessionControl_SetDuckingPreference
2640 typedef struct _SessionMgr
{
2641 IAudioSessionManager2 IAudioSessionManager2_iface
;
2648 static HRESULT WINAPI
AudioSessionManager_QueryInterface(IAudioSessionManager2
*iface
,
2649 REFIID riid
, void **ppv
)
2651 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2657 if (IsEqualIID(riid
, &IID_IUnknown
) ||
2658 IsEqualIID(riid
, &IID_IAudioSessionManager
) ||
2659 IsEqualIID(riid
, &IID_IAudioSessionManager2
))
2662 IUnknown_AddRef((IUnknown
*)*ppv
);
2666 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2667 return E_NOINTERFACE
;
2670 static inline SessionMgr
*impl_from_IAudioSessionManager2(IAudioSessionManager2
*iface
)
2672 return CONTAINING_RECORD(iface
, SessionMgr
, IAudioSessionManager2_iface
);
2675 static ULONG WINAPI
AudioSessionManager_AddRef(IAudioSessionManager2
*iface
)
2677 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
2679 ref
= InterlockedIncrement(&This
->ref
);
2680 TRACE("(%p) Refcount now %u\n", This
, ref
);
2684 static ULONG WINAPI
AudioSessionManager_Release(IAudioSessionManager2
*iface
)
2686 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
2688 ref
= InterlockedDecrement(&This
->ref
);
2689 TRACE("(%p) Refcount now %u\n", This
, ref
);
2691 HeapFree(GetProcessHeap(), 0, This
);
2695 static HRESULT WINAPI
AudioSessionManager_GetAudioSessionControl(
2696 IAudioSessionManager2
*iface
, const GUID
*session_guid
, DWORD flags
,
2697 IAudioSessionControl
**out
)
2699 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
2700 AudioSession
*session
;
2701 AudioSessionWrapper
*wrapper
;
2704 TRACE("(%p)->(%s, %x, %p)\n", This
, debugstr_guid(session_guid
),
2707 hr
= get_audio_session(session_guid
, This
->device
, 0, &session
);
2711 wrapper
= AudioSessionWrapper_Create(NULL
);
2713 return E_OUTOFMEMORY
;
2715 wrapper
->session
= session
;
2717 *out
= (IAudioSessionControl
*)&wrapper
->IAudioSessionControl2_iface
;
2722 static HRESULT WINAPI
AudioSessionManager_GetSimpleAudioVolume(
2723 IAudioSessionManager2
*iface
, const GUID
*session_guid
, DWORD flags
,
2724 ISimpleAudioVolume
**out
)
2726 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
2727 AudioSession
*session
;
2728 AudioSessionWrapper
*wrapper
;
2731 TRACE("(%p)->(%s, %x, %p)\n", This
, debugstr_guid(session_guid
),
2734 hr
= get_audio_session(session_guid
, This
->device
, 0, &session
);
2738 wrapper
= AudioSessionWrapper_Create(NULL
);
2740 return E_OUTOFMEMORY
;
2742 wrapper
->session
= session
;
2744 *out
= &wrapper
->ISimpleAudioVolume_iface
;
2749 static HRESULT WINAPI
AudioSessionManager_GetSessionEnumerator(
2750 IAudioSessionManager2
*iface
, IAudioSessionEnumerator
**out
)
2752 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
2753 FIXME("(%p)->(%p) - stub\n", This
, out
);
2757 static HRESULT WINAPI
AudioSessionManager_RegisterSessionNotification(
2758 IAudioSessionManager2
*iface
, IAudioSessionNotification
*notification
)
2760 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
2761 FIXME("(%p)->(%p) - stub\n", This
, notification
);
2765 static HRESULT WINAPI
AudioSessionManager_UnregisterSessionNotification(
2766 IAudioSessionManager2
*iface
, IAudioSessionNotification
*notification
)
2768 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
2769 FIXME("(%p)->(%p) - stub\n", This
, notification
);
2773 static HRESULT WINAPI
AudioSessionManager_RegisterDuckNotification(
2774 IAudioSessionManager2
*iface
, const WCHAR
*session_id
,
2775 IAudioVolumeDuckNotification
*notification
)
2777 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
2778 FIXME("(%p)->(%p) - stub\n", This
, notification
);
2782 static HRESULT WINAPI
AudioSessionManager_UnregisterDuckNotification(
2783 IAudioSessionManager2
*iface
,
2784 IAudioVolumeDuckNotification
*notification
)
2786 SessionMgr
*This
= impl_from_IAudioSessionManager2(iface
);
2787 FIXME("(%p)->(%p) - stub\n", This
, notification
);
2791 static const IAudioSessionManager2Vtbl AudioSessionManager2_Vtbl
=
2793 AudioSessionManager_QueryInterface
,
2794 AudioSessionManager_AddRef
,
2795 AudioSessionManager_Release
,
2796 AudioSessionManager_GetAudioSessionControl
,
2797 AudioSessionManager_GetSimpleAudioVolume
,
2798 AudioSessionManager_GetSessionEnumerator
,
2799 AudioSessionManager_RegisterSessionNotification
,
2800 AudioSessionManager_UnregisterSessionNotification
,
2801 AudioSessionManager_RegisterDuckNotification
,
2802 AudioSessionManager_UnregisterDuckNotification
2805 static HRESULT WINAPI
SimpleAudioVolume_QueryInterface(
2806 ISimpleAudioVolume
*iface
, REFIID riid
, void **ppv
)
2808 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2814 if (IsEqualIID(riid
, &IID_IUnknown
) ||
2815 IsEqualIID(riid
, &IID_ISimpleAudioVolume
))
2818 IUnknown_AddRef((IUnknown
*)*ppv
);
2822 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2823 return E_NOINTERFACE
;
2826 static ULONG WINAPI
SimpleAudioVolume_AddRef(ISimpleAudioVolume
*iface
)
2828 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2829 return AudioSessionControl_AddRef(&This
->IAudioSessionControl2_iface
);
2832 static ULONG WINAPI
SimpleAudioVolume_Release(ISimpleAudioVolume
*iface
)
2834 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2835 return AudioSessionControl_Release(&This
->IAudioSessionControl2_iface
);
2838 static HRESULT WINAPI
SimpleAudioVolume_SetMasterVolume(
2839 ISimpleAudioVolume
*iface
, float level
, const GUID
*context
)
2841 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2842 AudioSession
*session
= This
->session
;
2844 TRACE("(%p)->(%f, %s)\n", session
, level
, wine_dbgstr_guid(context
));
2846 if (level
< 0.f
|| level
> 1.f
)
2847 return E_INVALIDARG
;
2850 FIXME("Notifications not supported yet\n");
2852 TRACE("Pulseaudio does not support session volume control\n");
2854 pthread_mutex_lock(&pulse_lock
);
2855 session
->master_vol
= level
;
2856 pthread_mutex_unlock(&pulse_lock
);
2861 static HRESULT WINAPI
SimpleAudioVolume_GetMasterVolume(
2862 ISimpleAudioVolume
*iface
, float *level
)
2864 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2865 AudioSession
*session
= This
->session
;
2867 TRACE("(%p)->(%p)\n", session
, level
);
2870 return NULL_PTR_ERR
;
2872 *level
= session
->master_vol
;
2877 static HRESULT WINAPI
SimpleAudioVolume_SetMute(ISimpleAudioVolume
*iface
,
2878 BOOL mute
, const GUID
*context
)
2880 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2881 AudioSession
*session
= This
->session
;
2883 TRACE("(%p)->(%u, %p)\n", session
, mute
, context
);
2886 FIXME("Notifications not supported yet\n");
2888 session
->mute
= mute
;
2893 static HRESULT WINAPI
SimpleAudioVolume_GetMute(ISimpleAudioVolume
*iface
,
2896 AudioSessionWrapper
*This
= impl_from_ISimpleAudioVolume(iface
);
2897 AudioSession
*session
= This
->session
;
2899 TRACE("(%p)->(%p)\n", session
, mute
);
2902 return NULL_PTR_ERR
;
2904 *mute
= session
->mute
;
2909 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl
=
2911 SimpleAudioVolume_QueryInterface
,
2912 SimpleAudioVolume_AddRef
,
2913 SimpleAudioVolume_Release
,
2914 SimpleAudioVolume_SetMasterVolume
,
2915 SimpleAudioVolume_GetMasterVolume
,
2916 SimpleAudioVolume_SetMute
,
2917 SimpleAudioVolume_GetMute
2920 static HRESULT WINAPI
ChannelAudioVolume_QueryInterface(
2921 IChannelAudioVolume
*iface
, REFIID riid
, void **ppv
)
2923 TRACE("(%p)->(%s, %p)\n", iface
, debugstr_guid(riid
), ppv
);
2929 if (IsEqualIID(riid
, &IID_IUnknown
) ||
2930 IsEqualIID(riid
, &IID_IChannelAudioVolume
))
2933 IUnknown_AddRef((IUnknown
*)*ppv
);
2937 WARN("Unknown interface %s\n", debugstr_guid(riid
));
2938 return E_NOINTERFACE
;
2941 static ULONG WINAPI
ChannelAudioVolume_AddRef(IChannelAudioVolume
*iface
)
2943 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2944 return AudioSessionControl_AddRef(&This
->IAudioSessionControl2_iface
);
2947 static ULONG WINAPI
ChannelAudioVolume_Release(IChannelAudioVolume
*iface
)
2949 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2950 return AudioSessionControl_Release(&This
->IAudioSessionControl2_iface
);
2953 static HRESULT WINAPI
ChannelAudioVolume_GetChannelCount(
2954 IChannelAudioVolume
*iface
, UINT32
*out
)
2956 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2957 AudioSession
*session
= This
->session
;
2959 TRACE("(%p)->(%p)\n", session
, out
);
2962 return NULL_PTR_ERR
;
2964 *out
= session
->channel_count
;
2969 static HRESULT WINAPI
ChannelAudioVolume_SetChannelVolume(
2970 IChannelAudioVolume
*iface
, UINT32 index
, float level
,
2971 const GUID
*context
)
2973 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
2974 AudioSession
*session
= This
->session
;
2976 TRACE("(%p)->(%d, %f, %s)\n", session
, index
, level
,
2977 wine_dbgstr_guid(context
));
2979 if (level
< 0.f
|| level
> 1.f
)
2980 return E_INVALIDARG
;
2982 if (index
>= session
->channel_count
)
2983 return E_INVALIDARG
;
2986 FIXME("Notifications not supported yet\n");
2988 TRACE("Pulseaudio does not support session volume control\n");
2990 pthread_mutex_lock(&pulse_lock
);
2991 session
->channel_vols
[index
] = level
;
2992 pthread_mutex_unlock(&pulse_lock
);
2997 static HRESULT WINAPI
ChannelAudioVolume_GetChannelVolume(
2998 IChannelAudioVolume
*iface
, UINT32 index
, float *level
)
3000 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3001 AudioSession
*session
= This
->session
;
3003 TRACE("(%p)->(%d, %p)\n", session
, index
, level
);
3006 return NULL_PTR_ERR
;
3008 if (index
>= session
->channel_count
)
3009 return E_INVALIDARG
;
3011 *level
= session
->channel_vols
[index
];
3016 static HRESULT WINAPI
ChannelAudioVolume_SetAllVolumes(
3017 IChannelAudioVolume
*iface
, UINT32 count
, const float *levels
,
3018 const GUID
*context
)
3020 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3021 AudioSession
*session
= This
->session
;
3024 TRACE("(%p)->(%d, %p, %s)\n", session
, count
, levels
,
3025 wine_dbgstr_guid(context
));
3028 return NULL_PTR_ERR
;
3030 if (count
!= session
->channel_count
)
3031 return E_INVALIDARG
;
3034 FIXME("Notifications not supported yet\n");
3036 TRACE("Pulseaudio does not support session volume control\n");
3038 pthread_mutex_lock(&pulse_lock
);
3039 for(i
= 0; i
< count
; ++i
)
3040 session
->channel_vols
[i
] = levels
[i
];
3041 pthread_mutex_unlock(&pulse_lock
);
3045 static HRESULT WINAPI
ChannelAudioVolume_GetAllVolumes(
3046 IChannelAudioVolume
*iface
, UINT32 count
, float *levels
)
3048 AudioSessionWrapper
*This
= impl_from_IChannelAudioVolume(iface
);
3049 AudioSession
*session
= This
->session
;
3052 TRACE("(%p)->(%d, %p)\n", session
, count
, levels
);
3055 return NULL_PTR_ERR
;
3057 if (count
!= session
->channel_count
)
3058 return E_INVALIDARG
;
3060 for(i
= 0; i
< count
; ++i
)
3061 levels
[i
] = session
->channel_vols
[i
];
3066 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl
=
3068 ChannelAudioVolume_QueryInterface
,
3069 ChannelAudioVolume_AddRef
,
3070 ChannelAudioVolume_Release
,
3071 ChannelAudioVolume_GetChannelCount
,
3072 ChannelAudioVolume_SetChannelVolume
,
3073 ChannelAudioVolume_GetChannelVolume
,
3074 ChannelAudioVolume_SetAllVolumes
,
3075 ChannelAudioVolume_GetAllVolumes
3078 HRESULT WINAPI
AUDDRV_GetAudioSessionManager(IMMDevice
*device
,
3079 IAudioSessionManager2
**out
)
3081 SessionMgr
*This
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(SessionMgr
));
3084 return E_OUTOFMEMORY
;
3085 This
->IAudioSessionManager2_iface
.lpVtbl
= &AudioSessionManager2_Vtbl
;
3086 This
->device
= device
;
3088 *out
= &This
->IAudioSessionManager2_iface
;