dlls/mmdevapi/session.c

   1 /*
   2  * Copyright 2011-2012 Maarten Lankhorst
   3  * Copyright 2010-2011 Maarten Lankhorst for CodeWeavers
   4  * Copyright 2011 Andrew Eikum for CodeWeavers
   5  * Copyright 2022 Huw Davies
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #define COBJMACROS
  23
  24 #include <audiopolicy.h>
  25 #include <mmdeviceapi.h>
  26 #include <winternl.h>
  27
  28 #include <wine/debug.h>
  29 #include <wine/unixlib.h>
  30
  31 #include "mmdevapi_private.h"
  32
  33 #define NULL_PTR_ERR MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, RPC_X_NULL_REF_POINTER)
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(mmdevapi);
  36
  37 extern void sessions_lock(void) DECLSPEC_HIDDEN;
  38 extern void sessions_unlock(void) DECLSPEC_HIDDEN;
  39
  40 extern void set_stream_volumes(struct audio_client *This) DECLSPEC_HIDDEN;
  41
  42 static struct list sessions = LIST_INIT(sessions);
  43
  44 static inline struct audio_session_wrapper *impl_from_IAudioSessionControl2(IAudioSessionControl2 *iface)
  45 {
  46     return CONTAINING_RECORD(iface, struct audio_session_wrapper, IAudioSessionControl2_iface);
  47 }
  48
  49 static inline struct audio_session_wrapper *impl_from_IChannelAudioVolume(IChannelAudioVolume *iface)
  50 {
  51     return CONTAINING_RECORD(iface, struct audio_session_wrapper, IChannelAudioVolume_iface);
  52 }
  53
  54 static inline struct audio_session_wrapper *impl_from_ISimpleAudioVolume(ISimpleAudioVolume *iface)
  55 {
  56     return CONTAINING_RECORD(iface, struct audio_session_wrapper, ISimpleAudioVolume_iface);
  57 }
  58
  59 static HRESULT WINAPI control_QueryInterface(IAudioSessionControl2 *iface, REFIID riid, void **ppv)
  60 {
  61     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
  62
  63     if (!ppv)
  64         return E_POINTER;
  65
  66     if (IsEqualIID(riid, &IID_IUnknown) ||
  67         IsEqualIID(riid, &IID_IAudioSessionControl) ||
  68         IsEqualIID(riid, &IID_IAudioSessionControl2))
  69         *ppv = iface;
  70     else {
  71         *ppv = NULL;
  72         return E_NOINTERFACE;
  73     }
  74
  75     IUnknown_AddRef((IUnknown *)*ppv);
  76
  77     return S_OK;
  78 }
  79
  80 static ULONG WINAPI control_AddRef(IAudioSessionControl2 *iface)
  81 {
  82     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
  83     ULONG ref = InterlockedIncrement(&This->ref);
  84     TRACE("(%p) Refcount now %lu\n", This, ref);
  85     return ref;
  86 }
  87
  88 static ULONG WINAPI control_Release(IAudioSessionControl2 *iface)
  89 {
  90     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
  91     ULONG ref = InterlockedDecrement(&This->ref);
  92     TRACE("(%p) Refcount now %lu\n", This, ref);
  93
  94     if (!ref) {
  95         if (This->client) {
  96             sessions_lock();
  97             This->client->session_wrapper = NULL;
  98             sessions_unlock();
  99             IAudioClient3_Release(&This->client->IAudioClient3_iface);
 100         }
 101
 102         free(This);
 103     }
 104
 105     return ref;
 106 }
 107
 108 static HRESULT WINAPI control_GetState(IAudioSessionControl2 *iface, AudioSessionState *state)
 109 {
 110     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 111     struct is_started_params params;
 112     struct audio_client *client;
 113
 114     TRACE("(%p)->(%p)\n", This, state);
 115
 116     if (!state)
 117         return NULL_PTR_ERR;
 118
 119     sessions_lock();
 120
 121     if (list_empty(&This->session->clients)) {
 122         *state = AudioSessionStateExpired;
 123         sessions_unlock();
 124         return S_OK;
 125     }
 126
 127     LIST_FOR_EACH_ENTRY(client, &This->session->clients, struct audio_client, entry) {
 128         params.stream = client->stream;
 129         wine_unix_call(is_started, &params);
 130         if (params.result == S_OK) {
 131             *state = AudioSessionStateActive;
 132             sessions_unlock();
 133             return S_OK;
 134         }
 135     }
 136
 137     sessions_unlock();
 138
 139     *state = AudioSessionStateInactive;
 140
 141     return S_OK;
 142 }
 143
 144 static HRESULT WINAPI control_GetDisplayName(IAudioSessionControl2 *iface, WCHAR **name)
 145 {
 146     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 147     FIXME("(%p)->(%p) - stub\n", This, name);
 148     return E_NOTIMPL;
 149 }
 150
 151 static HRESULT WINAPI control_SetDisplayName(IAudioSessionControl2 *iface, const WCHAR *name,
 152                                          const GUID *session)
 153 {
 154     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 155     FIXME("(%p)->(%p, %s) - stub\n", This, name, debugstr_guid(session));
 156     return E_NOTIMPL;
 157 }
 158
 159 static HRESULT WINAPI control_GetIconPath(IAudioSessionControl2 *iface, WCHAR **path)
 160 {
 161     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 162     FIXME("(%p)->(%p) - stub\n", This, path);
 163     return E_NOTIMPL;
 164 }
 165
 166 static HRESULT WINAPI control_SetIconPath(IAudioSessionControl2 *iface, const WCHAR *path,
 167                                       const GUID *session)
 168 {
 169     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 170     FIXME("(%p)->(%s, %s) - stub\n", This, debugstr_w(path), debugstr_guid(session));
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT WINAPI control_GetGroupingParam(IAudioSessionControl2 *iface, GUID *group)
 175 {
 176     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 177     FIXME("(%p)->(%p) - stub\n", This, group);
 178     return E_NOTIMPL;
 179 }
 180
 181 static HRESULT WINAPI control_SetGroupingParam(IAudioSessionControl2 *iface, const GUID *group,
 182                                            const GUID *session)
 183 {
 184     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 185     FIXME("(%p)->(%s, %s) - stub\n", This, debugstr_guid(group), debugstr_guid(session));
 186     return E_NOTIMPL;
 187 }
 188
 189 static HRESULT WINAPI control_RegisterAudioSessionNotification(IAudioSessionControl2 *iface,
 190                                                            IAudioSessionEvents *events)
 191 {
 192     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 193     FIXME("(%p)->(%p) - stub\n", This, events);
 194     return S_OK;
 195 }
 196
 197 static HRESULT WINAPI control_UnregisterAudioSessionNotification(IAudioSessionControl2 *iface,
 198                                                              IAudioSessionEvents *events)
 199 {
 200     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 201     FIXME("(%p)->(%p) - stub\n", This, events);
 202     return S_OK;
 203 }
 204
 205 static HRESULT WINAPI control_GetSessionIdentifier(IAudioSessionControl2 *iface, WCHAR **id)
 206 {
 207     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 208     FIXME("(%p)->(%p) - stub\n", This, id);
 209     return E_NOTIMPL;
 210 }
 211
 212 static HRESULT WINAPI control_GetSessionInstanceIdentifier(IAudioSessionControl2 *iface, WCHAR **id)
 213 {
 214     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 215     FIXME("(%p)->(%p) - stub\n", This, id);
 216     return E_NOTIMPL;
 217 }
 218
 219 static HRESULT WINAPI control_GetProcessId(IAudioSessionControl2 *iface, DWORD *pid)
 220 {
 221     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 222
 223     TRACE("(%p)->(%p)\n", This, pid);
 224
 225     if (!pid)
 226         return E_POINTER;
 227
 228     *pid = GetCurrentProcessId();
 229
 230     return S_OK;
 231 }
 232
 233 static HRESULT WINAPI control_IsSystemSoundsSession(IAudioSessionControl2 *iface)
 234 {
 235     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 236     TRACE("(%p)\n", This);
 237     return S_FALSE;
 238 }
 239
 240 static HRESULT WINAPI control_SetDuckingPreference(IAudioSessionControl2 *iface, BOOL optout)
 241 {
 242     struct audio_session_wrapper *This = impl_from_IAudioSessionControl2(iface);
 243     TRACE("(%p)->(%d)\n", This, optout);
 244     return S_OK;
 245 }
 246
 247 static const IAudioSessionControl2Vtbl AudioSessionControl2_Vtbl =
 248 {
 249     control_QueryInterface,
 250     control_AddRef,
 251     control_Release,
 252     control_GetState,
 253     control_GetDisplayName,
 254     control_SetDisplayName,
 255     control_GetIconPath,
 256     control_SetIconPath,
 257     control_GetGroupingParam,
 258     control_SetGroupingParam,
 259     control_RegisterAudioSessionNotification,
 260     control_UnregisterAudioSessionNotification,
 261     control_GetSessionIdentifier,
 262     control_GetSessionInstanceIdentifier,
 263     control_GetProcessId,
 264     control_IsSystemSoundsSession,
 265     control_SetDuckingPreference
 266 };
 267
 268 static HRESULT WINAPI channelvolume_QueryInterface(IChannelAudioVolume *iface, REFIID riid,
 269                                                    void **ppv)
 270 {
 271     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 272
 273     if (!ppv)
 274         return E_POINTER;
 275
 276     if (IsEqualIID(riid, &IID_IUnknown) ||
 277         IsEqualIID(riid, &IID_IChannelAudioVolume))
 278         *ppv = iface;
 279     else {
 280         *ppv = NULL;
 281         return E_NOINTERFACE;
 282     }
 283
 284     IUnknown_AddRef((IUnknown *)*ppv);
 285
 286     return S_OK;
 287 }
 288
 289 static ULONG WINAPI channelvolume_AddRef(IChannelAudioVolume *iface)
 290 {
 291     struct audio_session_wrapper *This = impl_from_IChannelAudioVolume(iface);
 292     return IAudioSessionControl2_AddRef(&This->IAudioSessionControl2_iface);
 293 }
 294
 295 static ULONG WINAPI channelvolume_Release(IChannelAudioVolume *iface)
 296 {
 297     struct audio_session_wrapper *This = impl_from_IChannelAudioVolume(iface);
 298     return IAudioSessionControl2_Release(&This->IAudioSessionControl2_iface);
 299 }
 300
 301 static HRESULT WINAPI channelvolume_GetChannelCount(IChannelAudioVolume *iface, UINT32 *out)
 302 {
 303     struct audio_session_wrapper *This = impl_from_IChannelAudioVolume(iface);
 304     struct audio_session *session = This->session;
 305
 306     TRACE("(%p)->(%p)\n", session, out);
 307
 308     if (!out)
 309         return NULL_PTR_ERR;
 310
 311     *out = session->channel_count;
 312
 313     return S_OK;
 314 }
 315
 316 static HRESULT WINAPI channelvolume_SetChannelVolume(IChannelAudioVolume *iface, UINT32 index,
 317                                                      float level, const GUID *context)
 318 {
 319     struct audio_session_wrapper *This = impl_from_IChannelAudioVolume(iface);
 320     struct audio_session *session = This->session;
 321     struct audio_client *client;
 322
 323     TRACE("(%p)->(%d, %f, %s)\n", session, index, level, wine_dbgstr_guid(context));
 324
 325     if (level < 0.f || level > 1.f)
 326         return E_INVALIDARG;
 327
 328     if (index >= session->channel_count)
 329         return E_INVALIDARG;
 330
 331     if (context)
 332         FIXME("Notifications not supported yet\n");
 333
 334     sessions_lock();
 335
 336     session->channel_vols[index] = level;
 337
 338     LIST_FOR_EACH_ENTRY(client, &session->clients, struct audio_client, entry)
 339         set_stream_volumes(client);
 340
 341     sessions_unlock();
 342
 343     return S_OK;
 344 }
 345
 346 static HRESULT WINAPI channelvolume_GetChannelVolume(IChannelAudioVolume *iface, UINT32 index,
 347                                                      float *level)
 348 {
 349     struct audio_session_wrapper *This = impl_from_IChannelAudioVolume(iface);
 350     struct audio_session *session = This->session;
 351
 352     TRACE("(%p)->(%d, %p)\n", session, index, level);
 353
 354     if (!level)
 355         return NULL_PTR_ERR;
 356
 357     if (index >= session->channel_count)
 358         return E_INVALIDARG;
 359
 360     *level = session->channel_vols[index];
 361
 362     return S_OK;
 363 }
 364
 365 static HRESULT WINAPI channelvolume_SetAllVolumes(IChannelAudioVolume *iface, UINT32 count,
 366                                                   const float *levels, const GUID *context)
 367 {
 368     struct audio_session_wrapper *This = impl_from_IChannelAudioVolume(iface);
 369     struct audio_session *session = This->session;
 370     struct audio_client *client;
 371     unsigned int i;
 372
 373     TRACE("(%p)->(%d, %p, %s)\n", session, count, levels, wine_dbgstr_guid(context));
 374
 375     if (!levels)
 376         return NULL_PTR_ERR;
 377
 378     if (count != session->channel_count)
 379         return E_INVALIDARG;
 380
 381     if (context)
 382         FIXME("Notifications not supported yet\n");
 383
 384     sessions_lock();
 385
 386     for (i = 0; i < count; ++i)
 387         session->channel_vols[i] = levels[i];
 388
 389     LIST_FOR_EACH_ENTRY(client, &session->clients, struct audio_client, entry)
 390         set_stream_volumes(client);
 391
 392     sessions_unlock();
 393
 394     return S_OK;
 395 }
 396
 397 static HRESULT WINAPI channelvolume_GetAllVolumes(IChannelAudioVolume *iface, UINT32 count,
 398                                                   float *levels)
 399 {
 400     struct audio_session_wrapper *This = impl_from_IChannelAudioVolume(iface);
 401     struct audio_session *session = This->session;
 402     unsigned int i;
 403
 404     TRACE("(%p)->(%d, %p)\n", session, count, levels);
 405
 406     if (!levels)
 407         return NULL_PTR_ERR;
 408
 409     if (count != session->channel_count)
 410         return E_INVALIDARG;
 411
 412     for (i = 0; i < count; ++i)
 413         levels[i] = session->channel_vols[i];
 414
 415     return S_OK;
 416 }
 417
 418 static const IChannelAudioVolumeVtbl ChannelAudioVolume_Vtbl =
 419 {
 420     channelvolume_QueryInterface,
 421     channelvolume_AddRef,
 422     channelvolume_Release,
 423     channelvolume_GetChannelCount,
 424     channelvolume_SetChannelVolume,
 425     channelvolume_GetChannelVolume,
 426     channelvolume_SetAllVolumes,
 427     channelvolume_GetAllVolumes
 428 };
 429
 430 static HRESULT WINAPI simplevolume_QueryInterface(ISimpleAudioVolume *iface, REFIID riid,
 431                                                   void **ppv)
 432 {
 433     TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 434
 435     if (!ppv)
 436         return E_POINTER;
 437
 438     if (IsEqualIID(riid, &IID_IUnknown) ||
 439         IsEqualIID(riid, &IID_ISimpleAudioVolume))
 440         *ppv = iface;
 441     else {
 442         *ppv = NULL;
 443         return E_NOINTERFACE;
 444     }
 445
 446     IUnknown_AddRef((IUnknown *)*ppv);
 447
 448     return S_OK;
 449 }
 450
 451 static ULONG WINAPI simplevolume_AddRef(ISimpleAudioVolume *iface)
 452 {
 453     struct audio_session_wrapper *This = impl_from_ISimpleAudioVolume(iface);
 454     return IAudioSessionControl2_AddRef(&This->IAudioSessionControl2_iface);
 455 }
 456
 457 static ULONG WINAPI simplevolume_Release(ISimpleAudioVolume *iface)
 458 {
 459     struct audio_session_wrapper *This = impl_from_ISimpleAudioVolume(iface);
 460     return IAudioSessionControl2_Release(&This->IAudioSessionControl2_iface);
 461 }
 462
 463 static HRESULT WINAPI simplevolume_SetMasterVolume(ISimpleAudioVolume *iface, float level,
 464                                                   const GUID *context)
 465 {
 466     struct audio_session_wrapper *This = impl_from_ISimpleAudioVolume(iface);
 467     struct audio_session *session = This->session;
 468     struct audio_client *client;
 469
 470     TRACE("(%p)->(%f, %s)\n", session, level, wine_dbgstr_guid(context));
 471
 472     if (level < 0.f || level > 1.f)
 473         return E_INVALIDARG;
 474
 475     if (context)
 476         FIXME("Notifications not supported yet\n");
 477
 478     sessions_lock();
 479
 480     session->master_vol = level;
 481
 482     LIST_FOR_EACH_ENTRY(client, &session->clients, struct audio_client, entry)
 483         set_stream_volumes(client);
 484
 485     sessions_unlock();
 486
 487     return S_OK;
 488 }
 489
 490 static HRESULT WINAPI simplevolume_GetMasterVolume(ISimpleAudioVolume *iface, float *level)
 491 {
 492     struct audio_session_wrapper *This = impl_from_ISimpleAudioVolume(iface);
 493     struct audio_session *session = This->session;
 494
 495     TRACE("(%p)->(%p)\n", session, level);
 496
 497     if (!level)
 498         return NULL_PTR_ERR;
 499
 500     *level = session->master_vol;
 501
 502     return S_OK;
 503 }
 504
 505 static HRESULT WINAPI simplevolume_SetMute(ISimpleAudioVolume *iface, BOOL mute,
 506                                            const GUID *context)
 507 {
 508     struct audio_session_wrapper *This = impl_from_ISimpleAudioVolume(iface);
 509     struct audio_session *session = This->session;
 510     struct audio_client *client;
 511
 512     TRACE("(%p)->(%u, %s)\n", session, mute, debugstr_guid(context));
 513
 514     if (context)
 515         FIXME("Notifications not supported yet\n");
 516
 517     sessions_lock();
 518
 519     session->mute = mute;
 520
 521     LIST_FOR_EACH_ENTRY(client, &session->clients, struct audio_client, entry)
 522         set_stream_volumes(client);
 523
 524     sessions_unlock();
 525
 526     return S_OK;
 527 }
 528
 529 static HRESULT WINAPI simplevolume_GetMute(ISimpleAudioVolume *iface, BOOL *mute)
 530 {
 531     struct audio_session_wrapper *This = impl_from_ISimpleAudioVolume(iface);
 532     struct audio_session *session = This->session;
 533
 534     TRACE("(%p)->(%p)\n", session, mute);
 535
 536     if (!mute)
 537         return NULL_PTR_ERR;
 538
 539     *mute = session->mute;
 540
 541     return S_OK;
 542 }
 543
 544 static const ISimpleAudioVolumeVtbl SimpleAudioVolume_Vtbl =
 545 {
 546     simplevolume_QueryInterface,
 547     simplevolume_AddRef,
 548     simplevolume_Release,
 549     simplevolume_SetMasterVolume,
 550     simplevolume_GetMasterVolume,
 551     simplevolume_SetMute,
 552     simplevolume_GetMute
 553 };
 554
 555 static void session_init_vols(struct audio_session *session, UINT channels)
 556 {
 557     if (session->channel_count < channels) {
 558         UINT i;
 559
 560         session->channel_vols = realloc(session->channel_vols, sizeof(float) * channels);
 561         if (!session->channel_vols)
 562             return;
 563
 564         for (i = session->channel_count; i < channels; i++)
 565             session->channel_vols[i] = 1.f;
 566
 567         session->channel_count = channels;
 568     }
 569 }
 570
 571 static struct audio_session *session_create(const GUID *guid, IMMDevice *device, UINT channels)
 572 {
 573     struct audio_session *ret = calloc(1, sizeof(struct audio_session));
 574     if (!ret)
 575         return NULL;
 576
 577     memcpy(&ret->guid, guid, sizeof(GUID));
 578
 579     ret->device = device;
 580
 581     list_init(&ret->clients);
 582
 583     list_add_head(&sessions, &ret->entry);
 584
 585     session_init_vols(ret, channels);
 586
 587     ret->master_vol = 1.f;
 588
 589     return ret;
 590 }
 591
 592 struct audio_session_wrapper *session_wrapper_create(struct audio_client *client)
 593 {
 594     struct audio_session_wrapper *ret;
 595
 596     ret = calloc(1, sizeof(struct audio_session_wrapper));
 597     if (!ret)
 598         return NULL;
 599
 600     ret->IAudioSessionControl2_iface.lpVtbl = &AudioSessionControl2_Vtbl;
 601     ret->IChannelAudioVolume_iface.lpVtbl   = &ChannelAudioVolume_Vtbl;
 602     ret->ISimpleAudioVolume_iface.lpVtbl    = &SimpleAudioVolume_Vtbl;
 603
 604     ret->ref    = 1;
 605     ret->client = client;
 606
 607     if (client) {
 608         ret->session = client->session;
 609         IAudioClient3_AddRef(&client->IAudioClient3_iface);
 610     }
 611
 612     return ret;
 613 }
 614
 615 /* If channels == 0, then this will return or create a session with
 616  * matching dataflow and GUID. Otherwise, channels must also match. */
 617 HRESULT get_audio_session(const GUID *guid, IMMDevice *device, UINT channels,
 618                           struct audio_session **out)
 619 {
 620     struct audio_session *session;
 621
 622     TRACE("(%s, %p, %u, %p)\n", debugstr_guid(guid), device, channels, out);
 623
 624     if (!guid || IsEqualGUID(guid, &GUID_NULL)) {
 625         *out = session_create(&GUID_NULL, device, channels);
 626         if (!*out)
 627             return E_OUTOFMEMORY;
 628
 629         return S_OK;
 630     }
 631
 632     *out = NULL;
 633     LIST_FOR_EACH_ENTRY(session, &sessions, struct audio_session, entry) {
 634         if (session->device == device && IsEqualGUID(guid, &session->guid)) {
 635             session_init_vols(session, channels);
 636             *out = session;
 637             break;
 638         }
 639     }
 640
 641     if (!*out) {
 642         *out = session_create(guid, device, channels);
 643         if (!*out)
 644             return E_OUTOFMEMORY;
 645     }
 646
 647     return S_OK;
 648 }
 649
 650 HRESULT get_audio_session_wrapper(const GUID *guid, IMMDevice *device,
 651                                   struct audio_session_wrapper **out)
 652 {
 653     struct audio_session *session;
 654
 655     const HRESULT hr = get_audio_session(guid, device, 0, &session);
 656     if (FAILED(hr))
 657         return hr;
 658
 659     *out = session_wrapper_create(NULL);
 660     if (!*out)
 661         return E_OUTOFMEMORY;
 662
 663     (*out)->session = session;
 664
 665     return S_OK;
 666 }