dlls/wineoss.drv/dsrender.c

   1 /*
   2  * Sample Wine Driver for Open Sound System (featured in Linux and FreeBSD)
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  *           1999 Eric Pouech (async playing in waveOut/waveIn)
   6  *           2000 Eric Pouech (loops in waveOut)
   7  *           2002 Eric Pouech (full duplex)
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "config.h"
  25 #include "wine/port.h"
  26
  27 #include <stdlib.h>
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #ifdef HAVE_UNISTD_H
  32 # include <unistd.h>
  33 #endif
  34 #include <errno.h>
  35 #include <fcntl.h>
  36 #ifdef HAVE_SYS_IOCTL_H
  37 # include <sys/ioctl.h>
  38 #endif
  39 #ifdef HAVE_SYS_MMAN_H
  40 # include <sys/mman.h>
  41 #endif
  42 #ifdef HAVE_POLL_H
  43 #include <poll.h>
  44 #endif
  45 #ifdef HAVE_SYS_POLL_H
  46 # include <sys/poll.h>
  47 #endif
  48 #ifdef HAVE_SYS_ERRNO_H
  49 #include <sys/errno.h>
  50 #endif
  51 #include <sys/soundcard.h>
  52
  53 #include "windef.h"
  54 #include "winbase.h"
  55 #include "wingdi.h"
  56 #include "winuser.h"
  57 #include "winerror.h"
  58 #include "mmddk.h"
  59 #include "mmreg.h"
  60 #include "dsound.h"
  61 #include "dsdriver.h"
  62 #include "wine/debug.h"
  63
  64 #include "audio.h"
  65
  66 WINE_DEFAULT_DEBUG_CHANNEL(wave);
  67
  68 /*======================================================================*
  69  *                  Low level DSOUND definitions                        *
  70  *======================================================================*/
  71
  72 typedef struct IDsDriverPropertySetImpl IDsDriverPropertySetImpl;
  73 typedef struct IDsDriverNotifyImpl IDsDriverNotifyImpl;
  74 typedef struct IDsDriverImpl IDsDriverImpl;
  75 typedef struct IDsDriverBufferImpl IDsDriverBufferImpl;
  76
  77 struct IDsDriverPropertySetImpl
  78 {
  79     /* IUnknown fields */
  80     const IDsDriverPropertySetVtbl *lpVtbl;
  81     LONG                        ref;
  82
  83     IDsDriverBufferImpl*        buffer;
  84 };
  85
  86 struct IDsDriverNotifyImpl
  87 {
  88     /* IUnknown fields */
  89     const IDsDriverNotifyVtbl  *lpVtbl;
  90     LONG                        ref;
  91
  92     /* IDsDriverNotifyImpl fields */
  93     LPDSBPOSITIONNOTIFY         notifies;
  94     int                         nrofnotifies;
  95
  96     IDsDriverBufferImpl*        buffer;
  97 };
  98
  99 struct IDsDriverImpl
 100 {
 101     /* IUnknown fields */
 102     const IDsDriverVtbl        *lpVtbl;
 103     LONG                        ref;
 104
 105     /* IDsDriverImpl fields */
 106     UINT                        wDevID;
 107     IDsDriverBufferImpl*        primary;
 108
 109     int                         nrofsecondaries;
 110     IDsDriverBufferImpl**       secondaries;
 111 };
 112
 113 struct IDsDriverBufferImpl
 114 {
 115     /* IUnknown fields */
 116     const IDsDriverBufferVtbl  *lpVtbl;
 117     LONG                        ref;
 118
 119     /* IDsDriverBufferImpl fields */
 120     IDsDriverImpl*              drv;
 121     DWORD                       buflen;
 122     WAVEFORMATPCMEX             wfex;
 123     LPBYTE                      mapping;
 124     DWORD                       maplen;
 125     int                         fd;
 126     DWORD                       dwFlags;
 127
 128     /* IDsDriverNotifyImpl fields */
 129     IDsDriverNotifyImpl*        notify;
 130     int                         notify_index;
 131
 132     /* IDsDriverPropertySetImpl fields */
 133     IDsDriverPropertySetImpl*   property_set;
 134 };
 135
 136 static HRESULT IDsDriverPropertySetImpl_Create(
 137     IDsDriverBufferImpl * dsdb,
 138     IDsDriverPropertySetImpl **pdsdps);
 139
 140 static HRESULT IDsDriverNotifyImpl_Create(
 141     IDsDriverBufferImpl * dsdb,
 142     IDsDriverNotifyImpl **pdsdn);
 143
 144 /*======================================================================*
 145  *                  Low level DSOUND property set implementation        *
 146  *======================================================================*/
 147
 148 static HRESULT WINAPI IDsDriverPropertySetImpl_QueryInterface(
 149     PIDSDRIVERPROPERTYSET iface,
 150     REFIID riid,
 151     LPVOID *ppobj)
 152 {
 153     IDsDriverPropertySetImpl *This = (IDsDriverPropertySetImpl *)iface;
 154     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 155
 156     if ( IsEqualGUID(riid, &IID_IUnknown) ||
 157          IsEqualGUID(riid, &IID_IDsDriverPropertySet) ) {
 158         IDsDriverPropertySet_AddRef(iface);
 159         *ppobj = This;
 160         return DS_OK;
 161     }
 162
 163     FIXME( "Unknown IID %s\n", debugstr_guid( riid ) );
 164
 165     *ppobj = 0;
 166     return E_NOINTERFACE;
 167 }
 168
 169 static ULONG WINAPI IDsDriverPropertySetImpl_AddRef(PIDSDRIVERPROPERTYSET iface)
 170 {
 171     IDsDriverPropertySetImpl *This = (IDsDriverPropertySetImpl *)iface;
 172     ULONG refCount = InterlockedIncrement(&This->ref);
 173
 174     TRACE("(%p) ref was %d\n", This, refCount - 1);
 175
 176     return refCount;
 177 }
 178
 179 static ULONG WINAPI IDsDriverPropertySetImpl_Release(PIDSDRIVERPROPERTYSET iface)
 180 {
 181     IDsDriverPropertySetImpl *This = (IDsDriverPropertySetImpl *)iface;
 182     ULONG refCount = InterlockedDecrement(&This->ref);
 183
 184     TRACE("(%p) ref was %d\n", This, refCount + 1);
 185
 186     if (!refCount) {
 187         IDsDriverBuffer_Release((PIDSDRIVERBUFFER)This->buffer);
 188         HeapFree(GetProcessHeap(),0,This);
 189         TRACE("(%p) released\n",This);
 190     }
 191     return refCount;
 192 }
 193
 194 static HRESULT WINAPI IDsDriverPropertySetImpl_Get(
 195     PIDSDRIVERPROPERTYSET iface,
 196     PDSPROPERTY pDsProperty,
 197     LPVOID pPropertyParams,
 198     ULONG cbPropertyParams,
 199     LPVOID pPropertyData,
 200     ULONG cbPropertyData,
 201     PULONG pcbReturnedData )
 202 {
 203     IDsDriverPropertySetImpl *This = (IDsDriverPropertySetImpl *)iface;
 204     FIXME("(%p,%p,%p,%x,%p,%x,%p)\n",This,pDsProperty,pPropertyParams,cbPropertyParams,pPropertyData,cbPropertyData,pcbReturnedData);
 205     return DSERR_UNSUPPORTED;
 206 }
 207
 208 static HRESULT WINAPI IDsDriverPropertySetImpl_Set(
 209     PIDSDRIVERPROPERTYSET iface,
 210     PDSPROPERTY pDsProperty,
 211     LPVOID pPropertyParams,
 212     ULONG cbPropertyParams,
 213     LPVOID pPropertyData,
 214     ULONG cbPropertyData )
 215 {
 216     IDsDriverPropertySetImpl *This = (IDsDriverPropertySetImpl *)iface;
 217     FIXME("(%p,%p,%p,%x,%p,%x)\n",This,pDsProperty,pPropertyParams,cbPropertyParams,pPropertyData,cbPropertyData);
 218     return DSERR_UNSUPPORTED;
 219 }
 220
 221 static HRESULT WINAPI IDsDriverPropertySetImpl_QuerySupport(
 222     PIDSDRIVERPROPERTYSET iface,
 223     REFGUID PropertySetId,
 224     ULONG PropertyId,
 225     PULONG pSupport )
 226 {
 227     IDsDriverPropertySetImpl *This = (IDsDriverPropertySetImpl *)iface;
 228     FIXME("(%p,%s,%x,%p)\n",This,debugstr_guid(PropertySetId),PropertyId,pSupport);
 229     return DSERR_UNSUPPORTED;
 230 }
 231
 232 static const IDsDriverPropertySetVtbl dsdpsvt =
 233 {
 234     IDsDriverPropertySetImpl_QueryInterface,
 235     IDsDriverPropertySetImpl_AddRef,
 236     IDsDriverPropertySetImpl_Release,
 237     IDsDriverPropertySetImpl_Get,
 238     IDsDriverPropertySetImpl_Set,
 239     IDsDriverPropertySetImpl_QuerySupport,
 240 };
 241
 242 /*======================================================================*
 243  *                  Low level DSOUND notify implementation              *
 244  *======================================================================*/
 245
 246 static HRESULT WINAPI IDsDriverNotifyImpl_QueryInterface(
 247     PIDSDRIVERNOTIFY iface,
 248     REFIID riid,
 249     LPVOID *ppobj)
 250 {
 251     IDsDriverNotifyImpl *This = (IDsDriverNotifyImpl *)iface;
 252     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 253
 254     if ( IsEqualGUID(riid, &IID_IUnknown) ||
 255          IsEqualGUID(riid, &IID_IDsDriverNotify) ) {
 256         IDsDriverNotify_AddRef(iface);
 257         *ppobj = This;
 258         return DS_OK;
 259     }
 260
 261     FIXME( "Unknown IID %s\n", debugstr_guid( riid ) );
 262
 263     *ppobj = 0;
 264     return E_NOINTERFACE;
 265 }
 266
 267 static ULONG WINAPI IDsDriverNotifyImpl_AddRef(PIDSDRIVERNOTIFY iface)
 268 {
 269     IDsDriverNotifyImpl *This = (IDsDriverNotifyImpl *)iface;
 270     ULONG refCount = InterlockedIncrement(&This->ref);
 271
 272     TRACE("(%p) ref was %d\n", This, refCount - 1);
 273
 274     return refCount;
 275 }
 276
 277 static ULONG WINAPI IDsDriverNotifyImpl_Release(PIDSDRIVERNOTIFY iface)
 278 {
 279     IDsDriverNotifyImpl *This = (IDsDriverNotifyImpl *)iface;
 280     ULONG refCount = InterlockedDecrement(&This->ref);
 281
 282     TRACE("(%p) ref was %d\n", This, refCount + 1);
 283
 284     if (!refCount) {
 285         IDsDriverBuffer_Release((PIDSDRIVERBUFFER)This->buffer);
 286         HeapFree(GetProcessHeap(), 0, This->notifies);
 287         HeapFree(GetProcessHeap(),0,This);
 288         TRACE("(%p) released\n",This);
 289     }
 290     return refCount;
 291 }
 292
 293 static HRESULT WINAPI IDsDriverNotifyImpl_SetNotificationPositions(
 294     PIDSDRIVERNOTIFY iface,
 295     DWORD howmuch,
 296     LPCDSBPOSITIONNOTIFY notify)
 297 {
 298     IDsDriverNotifyImpl *This = (IDsDriverNotifyImpl *)iface;
 299     TRACE("(%p,0x%08x,%p)\n",This,howmuch,notify);
 300
 301     if (!notify) {
 302         WARN("invalid parameter\n");
 303         return DSERR_INVALIDPARAM;
 304     }
 305
 306     if (TRACE_ON(wave)) {
 307         DWORD i;
 308         for (i=0;i<howmuch;i++)
 309             TRACE("notify at %d to 0x%08lx\n",
 310                 notify[i].dwOffset,(DWORD_PTR)notify[i].hEventNotify);
 311     }
 312
 313     /* Make an internal copy of the caller-supplied array.
 314      * Replace the existing copy if one is already present. */
 315     if (This->notifies)
 316         This->notifies = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 317         This->notifies, howmuch * sizeof(DSBPOSITIONNOTIFY));
 318     else
 319         This->notifies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
 320         howmuch * sizeof(DSBPOSITIONNOTIFY));
 321
 322     memcpy(This->notifies, notify, howmuch * sizeof(DSBPOSITIONNOTIFY));
 323     This->nrofnotifies = howmuch;
 324
 325     return S_OK;
 326 }
 327
 328 static const IDsDriverNotifyVtbl dsdnvt =
 329 {
 330     IDsDriverNotifyImpl_QueryInterface,
 331     IDsDriverNotifyImpl_AddRef,
 332     IDsDriverNotifyImpl_Release,
 333     IDsDriverNotifyImpl_SetNotificationPositions,
 334 };
 335
 336 /*======================================================================*
 337  *                  Low level DSOUND implementation                     *
 338  *======================================================================*/
 339
 340 static HRESULT DSDB_MapBuffer(IDsDriverBufferImpl *dsdb)
 341 {
 342     TRACE("(%p), format=%dx%dx%d\n", dsdb, dsdb->wfex.Format.nSamplesPerSec,
 343           dsdb->wfex.Format.wBitsPerSample, dsdb->wfex.Format.nChannels);
 344     if (!dsdb->mapping) {
 345         dsdb->mapping = mmap(NULL, dsdb->maplen, PROT_WRITE, MAP_SHARED,
 346                              dsdb->fd, 0);
 347         if (dsdb->mapping == (LPBYTE)-1) {
 348             WARN("Could not map sound device for direct access (%s)\n", strerror(errno));
 349             return DSERR_GENERIC;
 350         }
 351         TRACE("The sound device has been mapped for direct access at %p, size=%d\n", dsdb->mapping, dsdb->maplen);
 352
 353         /* for some reason, es1371 and sblive! sometimes have junk in here.
 354          * clear it, or we get junk noise */
 355         /* some libc implementations are buggy: their memset reads from the buffer...
 356          * to work around it, we have to zero the block by hand. We don't do the expected:
 357          * memset(dsdb->mapping,0, dsdb->maplen);
 358          */
 359         {
 360             unsigned char*      p1 = dsdb->mapping;
 361             unsigned            len = dsdb->maplen;
 362             unsigned char       silence = (dsdb->wfex.Format.wBitsPerSample == 8) ? 128 : 0;
 363             unsigned long       ulsilence = (dsdb->wfex.Format.wBitsPerSample == 8) ? 0x80808080 : 0;
 364
 365             if (len >= 16) /* so we can have at least a 4 long area to store... */
 366             {
 367                 /* the mmap:ed value is (at least) dword aligned
 368                  * so, start filling the complete unsigned long:s
 369                  */
 370                 int             b = len >> 2;
 371                 unsigned long*  p4 = (unsigned long*)p1;
 372
 373                 while (b--) *p4++ = ulsilence;
 374                 /* prepare for filling the rest */
 375                 len &= 3;
 376                 p1 = (unsigned char*)p4;
 377             }
 378             /* in all cases, fill the remaining bytes */
 379             while (len-- != 0) *p1++ = silence;
 380         }
 381     }
 382     return DS_OK;
 383 }
 384
 385 static HRESULT DSDB_UnmapBuffer(IDsDriverBufferImpl *dsdb)
 386 {
 387     TRACE("(%p)\n",dsdb);
 388     if (dsdb->mapping) {
 389         if (munmap(dsdb->mapping, dsdb->maplen) < 0) {
 390             ERR("(%p): Could not unmap sound device (%s)\n", dsdb, strerror(errno));
 391             return DSERR_GENERIC;
 392         }
 393         dsdb->mapping = NULL;
 394         TRACE("(%p): sound device unmapped\n", dsdb);
 395     }
 396     return DS_OK;
 397 }
 398
 399 static HRESULT WINAPI IDsDriverBufferImpl_QueryInterface(PIDSDRIVERBUFFER iface, REFIID riid, LPVOID *ppobj)
 400 {
 401     IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface;
 402     TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),*ppobj);
 403
 404     if ( IsEqualGUID(riid, &IID_IUnknown) ||
 405          IsEqualGUID(riid, &IID_IDsDriverBuffer) ) {
 406         IDsDriverBuffer_AddRef(iface);
 407         *ppobj = This;
 408         return DS_OK;
 409     }
 410
 411     if ( IsEqualGUID( &IID_IDsDriverNotify, riid ) ) {
 412         if (!This->notify)
 413             IDsDriverNotifyImpl_Create(This, &(This->notify));
 414         if (This->notify) {
 415             IDsDriverNotify_AddRef((PIDSDRIVERNOTIFY)This->notify);
 416             *ppobj = This->notify;
 417             return DS_OK;
 418         }
 419         *ppobj = 0;
 420         return E_FAIL;
 421     }
 422
 423     if ( IsEqualGUID( &IID_IDsDriverPropertySet, riid ) ) {
 424         if (!This->property_set)
 425             IDsDriverPropertySetImpl_Create(This, &(This->property_set));
 426         if (This->property_set) {
 427             IDsDriverPropertySet_AddRef((PIDSDRIVERPROPERTYSET)This->property_set);
 428             *ppobj = This->property_set;
 429             return DS_OK;
 430         }
 431         *ppobj = 0;
 432         return E_FAIL;
 433     }
 434
 435     FIXME( "Unknown IID %s\n", debugstr_guid( riid ) );
 436
 437     *ppobj = 0;
 438
 439     return E_NOINTERFACE;
 440 }
 441
 442 static ULONG WINAPI IDsDriverBufferImpl_AddRef(PIDSDRIVERBUFFER iface)
 443 {
 444     IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface;
 445     ULONG refCount = InterlockedIncrement(&This->ref);
 446
 447     TRACE("(%p) ref was %d\n", This, refCount - 1);
 448
 449     return refCount;
 450 }
 451
 452 static ULONG WINAPI IDsDriverBufferImpl_Release(PIDSDRIVERBUFFER iface)
 453 {
 454     IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface;
 455     ULONG refCount = InterlockedDecrement(&This->ref);
 456
 457     TRACE("(%p) ref was %d\n", This, refCount + 1);
 458
 459     if (refCount)
 460         return refCount;
 461
 462     if (This == This->drv->primary)
 463         This->drv->primary = NULL;
 464     else {
 465         int i;
 466         for (i = 0; i < This->drv->nrofsecondaries; i++)
 467             if (This->drv->secondaries[i] == This)
 468                 break;
 469         if (i < This->drv->nrofsecondaries) {
 470             /* Put the last buffer of the list in the (now empty) position */
 471             This->drv->secondaries[i] = This->drv->secondaries[This->drv->nrofsecondaries - 1];
 472             This->drv->nrofsecondaries--;
 473             This->drv->secondaries = HeapReAlloc(GetProcessHeap(),0,
 474                 This->drv->secondaries,
 475                 sizeof(PIDSDRIVERBUFFER)*This->drv->nrofsecondaries);
 476             TRACE("(%p) buffer count is now %d\n", This, This->drv->nrofsecondaries);
 477         }
 478
 479         WOutDev[This->drv->wDevID].ossdev.ds_caps.dwFreeHwMixingAllBuffers++;
 480         WOutDev[This->drv->wDevID].ossdev.ds_caps.dwFreeHwMixingStreamingBuffers++;
 481     }
 482
 483     DSDB_UnmapBuffer(This);
 484     HeapFree(GetProcessHeap(),0,This);
 485     TRACE("(%p) released\n",This);
 486     return 0;
 487 }
 488
 489 static HRESULT WINAPI IDsDriverBufferImpl_Lock(PIDSDRIVERBUFFER iface,
 490                                                LPVOID*ppvAudio1,LPDWORD pdwLen1,
 491                                                LPVOID*ppvAudio2,LPDWORD pdwLen2,
 492                                                DWORD dwWritePosition,DWORD dwWriteLen,
 493                                                DWORD dwFlags)
 494 {
 495     /* IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface; */
 496     /* since we (GetDriverDesc flags) have specified DSDDESC_DONTNEEDPRIMARYLOCK,
 497      * and that we don't support secondary buffers, this method will never be called */
 498     TRACE("(%p): stub\n",iface);
 499     return DSERR_UNSUPPORTED;
 500 }
 501
 502 static HRESULT WINAPI IDsDriverBufferImpl_Unlock(PIDSDRIVERBUFFER iface,
 503                                                  LPVOID pvAudio1,DWORD dwLen1,
 504                                                  LPVOID pvAudio2,DWORD dwLen2)
 505 {
 506     /* IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface; */
 507     TRACE("(%p): stub\n",iface);
 508     return DSERR_UNSUPPORTED;
 509 }
 510
 511 static HRESULT WINAPI IDsDriverBufferImpl_SetFormat(PIDSDRIVERBUFFER iface,
 512                                                     LPWAVEFORMATEX pwfx)
 513 {
 514     /* IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface; */
 515
 516     TRACE("(%p,%p)\n",iface,pwfx);
 517     /* On our request (GetDriverDesc flags), DirectSound has by now used
 518      * waveOutClose/waveOutOpen to set the format...
 519      * unfortunately, this means our mmap() is now gone...
 520      * so we need to somehow signal to our DirectSound implementation
 521      * that it should completely recreate this HW buffer...
 522      * this unexpected error code should do the trick... */
 523     return DSERR_BUFFERLOST;
 524 }
 525
 526 static HRESULT WINAPI IDsDriverBufferImpl_SetFrequency(PIDSDRIVERBUFFER iface, DWORD dwFreq)
 527 {
 528     /* IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface; */
 529     TRACE("(%p,%d): stub\n",iface,dwFreq);
 530     return DSERR_UNSUPPORTED;
 531 }
 532
 533 static HRESULT WINAPI IDsDriverBufferImpl_SetVolumePan(PIDSDRIVERBUFFER iface, PDSVOLUMEPAN pVolPan)
 534 {
 535     DWORD vol;
 536     IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface;
 537     TRACE("(%p,%p)\n",This,pVolPan);
 538
 539     vol = pVolPan->dwTotalLeftAmpFactor | (pVolPan->dwTotalRightAmpFactor << 16);
 540
 541     if (wodSetVolume(This->drv->wDevID, vol) != MMSYSERR_NOERROR) {
 542         WARN("wodSetVolume failed\n");
 543         return DSERR_INVALIDPARAM;
 544     }
 545
 546     return DS_OK;
 547 }
 548
 549 static HRESULT WINAPI IDsDriverBufferImpl_SetPosition(PIDSDRIVERBUFFER iface, DWORD dwNewPos)
 550 {
 551     /* IDsDriverImpl *This = (IDsDriverImpl *)iface; */
 552     TRACE("(%p,%d): stub\n",iface,dwNewPos);
 553     return DSERR_UNSUPPORTED;
 554 }
 555
 556 static HRESULT WINAPI IDsDriverBufferImpl_GetPosition(PIDSDRIVERBUFFER iface,
 557                                                       LPDWORD lpdwPlay, LPDWORD lpdwWrite)
 558 {
 559     IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface;
 560     count_info info;
 561     DWORD ptr;
 562
 563     TRACE("(%p)\n",iface);
 564     if (WOutDev[This->drv->wDevID].state == WINE_WS_CLOSED) {
 565         ERR("device not open, but accessing?\n");
 566         return DSERR_UNINITIALIZED;
 567     }
 568     if (ioctl(This->fd, SNDCTL_DSP_GETOPTR, &info) < 0) {
 569         ERR("ioctl(%s, SNDCTL_DSP_GETOPTR) failed (%s)\n",
 570             WOutDev[This->drv->wDevID].ossdev.dev_name, strerror(errno));
 571         return DSERR_GENERIC;
 572     }
 573     ptr = info.ptr & ~3; /* align the pointer, just in case */
 574     if (lpdwPlay) *lpdwPlay = ptr;
 575     if (lpdwWrite) {
 576         /* add some safety margin (not strictly necessary, but...) */
 577         if (WOutDev[This->drv->wDevID].ossdev.duplex_out_caps.dwSupport & WAVECAPS_SAMPLEACCURATE)
 578             *lpdwWrite = ptr + 32;
 579         else
 580             *lpdwWrite = ptr + WOutDev[This->drv->wDevID].dwFragmentSize;
 581         while (*lpdwWrite >= This->buflen)
 582             *lpdwWrite -= This->buflen;
 583     }
 584     TRACE("playpos=%d, writepos=%d\n", lpdwPlay?*lpdwPlay:0, lpdwWrite?*lpdwWrite:0);
 585     return DS_OK;
 586 }
 587
 588 static HRESULT WINAPI IDsDriverBufferImpl_Play(PIDSDRIVERBUFFER iface, DWORD dwRes1, DWORD dwRes2, DWORD dwFlags)
 589 {
 590     IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface;
 591     int enable;
 592     TRACE("(%p,%x,%x,%x)\n",iface,dwRes1,dwRes2,dwFlags);
 593     WOutDev[This->drv->wDevID].ossdev.bOutputEnabled = TRUE;
 594     enable = getEnables(&WOutDev[This->drv->wDevID].ossdev);
 595     if (ioctl(This->fd, SNDCTL_DSP_SETTRIGGER, &enable) < 0) {
 596         if (errno == EINVAL) {
 597             /* Don't give up yet. OSS trigger support is inconsistent. */
 598             if (WOutDev[This->drv->wDevID].ossdev.open_count == 1) {
 599                 /* try the opposite input enable */
 600                 if (WOutDev[This->drv->wDevID].ossdev.bInputEnabled == FALSE)
 601                     WOutDev[This->drv->wDevID].ossdev.bInputEnabled = TRUE;
 602                 else
 603                     WOutDev[This->drv->wDevID].ossdev.bInputEnabled = FALSE;
 604                 /* try it again */
 605                 enable = getEnables(&WOutDev[This->drv->wDevID].ossdev);
 606                 if (ioctl(This->fd, SNDCTL_DSP_SETTRIGGER, &enable) >= 0)
 607                     return DS_OK;
 608             }
 609         }
 610         ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER) failed (%s)\n",
 611             WOutDev[This->drv->wDevID].ossdev.dev_name, strerror(errno));
 612         WOutDev[This->drv->wDevID].ossdev.bOutputEnabled = FALSE;
 613         return DSERR_GENERIC;
 614     }
 615     return DS_OK;
 616 }
 617
 618 static HRESULT WINAPI IDsDriverBufferImpl_Stop(PIDSDRIVERBUFFER iface)
 619 {
 620     IDsDriverBufferImpl *This = (IDsDriverBufferImpl *)iface;
 621     int enable;
 622     TRACE("(%p)\n",iface);
 623     /* no more playing */
 624     WOutDev[This->drv->wDevID].ossdev.bOutputEnabled = FALSE;
 625     enable = getEnables(&WOutDev[This->drv->wDevID].ossdev);
 626     if (ioctl(This->fd, SNDCTL_DSP_SETTRIGGER, &enable) < 0) {
 627         ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER) failed (%s)\n", WOutDev[This->drv->wDevID].ossdev.dev_name, strerror(errno));
 628         return DSERR_GENERIC;
 629     }
 630 #if 0
 631     /* the play position must be reset to the beginning of the buffer */
 632     if (ioctl(This->fd, SNDCTL_DSP_RESET, 0) < 0) {
 633         ERR("ioctl(%s, SNDCTL_DSP_RESET) failed (%s)\n", WOutDev[This->drv->wDevID].ossdev.dev_name, strerror(errno));
 634         return DSERR_GENERIC;
 635     }
 636 #endif
 637     /* Most OSS drivers just can't stop the playback without closing the device...
 638      * so we need to somehow signal to our DirectSound implementation
 639      * that it should completely recreate this HW buffer...
 640      * this unexpected error code should do the trick... */
 641     /* FIXME: ...unless we are doing full duplex, then it's not nice to close the device */
 642     if (WOutDev[This->drv->wDevID].ossdev.open_count == 1)
 643         return DSERR_BUFFERLOST;
 644
 645     return DS_OK;
 646 }
 647
 648 static const IDsDriverBufferVtbl dsdbvt =
 649 {
 650     IDsDriverBufferImpl_QueryInterface,
 651     IDsDriverBufferImpl_AddRef,
 652     IDsDriverBufferImpl_Release,
 653     IDsDriverBufferImpl_Lock,
 654     IDsDriverBufferImpl_Unlock,
 655     IDsDriverBufferImpl_SetFormat,
 656     IDsDriverBufferImpl_SetFrequency,
 657     IDsDriverBufferImpl_SetVolumePan,
 658     IDsDriverBufferImpl_SetPosition,
 659     IDsDriverBufferImpl_GetPosition,
 660     IDsDriverBufferImpl_Play,
 661     IDsDriverBufferImpl_Stop
 662 };
 663
 664 static HRESULT WINAPI IDsDriverImpl_QueryInterface(PIDSDRIVER iface, REFIID riid, LPVOID *ppobj)
 665 {
 666     IDsDriverImpl *This = (IDsDriverImpl *)iface;
 667     TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 668
 669     if ( IsEqualGUID(riid, &IID_IUnknown) ||
 670          IsEqualGUID(riid, &IID_IDsDriver) ) {
 671         IDsDriver_AddRef(iface);
 672         *ppobj = This;
 673         return DS_OK;
 674     }
 675
 676     FIXME( "Unknown IID %s\n", debugstr_guid( riid ) );
 677
 678     *ppobj = 0;
 679
 680     return E_NOINTERFACE;
 681 }
 682
 683 static ULONG WINAPI IDsDriverImpl_AddRef(PIDSDRIVER iface)
 684 {
 685     IDsDriverImpl *This = (IDsDriverImpl *)iface;
 686     ULONG refCount = InterlockedIncrement(&This->ref);
 687
 688     TRACE("(%p) ref was %d\n", This, refCount - 1);
 689
 690     return refCount;
 691 }
 692
 693 static ULONG WINAPI IDsDriverImpl_Release(PIDSDRIVER iface)
 694 {
 695     IDsDriverImpl *This = (IDsDriverImpl *)iface;
 696     ULONG refCount = InterlockedDecrement(&This->ref);
 697
 698     TRACE("(%p) ref was %d\n", This, refCount + 1);
 699
 700     if (!refCount) {
 701         HeapFree(GetProcessHeap(),0,This);
 702         TRACE("(%p) released\n",This);
 703     }
 704     return refCount;
 705 }
 706
 707 static HRESULT WINAPI IDsDriverImpl_GetDriverDesc(PIDSDRIVER iface,
 708                                                   PDSDRIVERDESC pDesc)
 709 {
 710     IDsDriverImpl *This = (IDsDriverImpl *)iface;
 711     TRACE("(%p,%p)\n",iface,pDesc);
 712
 713     /* copy version from driver */
 714     *pDesc = WOutDev[This->wDevID].ossdev.ds_desc;
 715
 716     pDesc->dwFlags |= DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT |
 717         DSDDESC_USESYSTEMMEMORY | DSDDESC_DONTNEEDPRIMARYLOCK |
 718         DSDDESC_DONTNEEDSECONDARYLOCK;
 719     pDesc->dnDevNode            = WOutDev[This->wDevID].waveDesc.dnDevNode;
 720     pDesc->wVxdId               = 0;
 721     pDesc->wReserved            = 0;
 722     pDesc->ulDeviceNum          = This->wDevID;
 723     pDesc->dwHeapType           = DSDHEAP_NOHEAP;
 724     pDesc->pvDirectDrawHeap     = NULL;
 725     pDesc->dwMemStartAddress    = 0;
 726     pDesc->dwMemEndAddress      = 0;
 727     pDesc->dwMemAllocExtra      = 0;
 728     pDesc->pvReserved1          = NULL;
 729     pDesc->pvReserved2          = NULL;
 730     return DS_OK;
 731 }
 732
 733 static HRESULT WINAPI IDsDriverImpl_Open(PIDSDRIVER iface)
 734 {
 735     IDsDriverImpl *This = (IDsDriverImpl *)iface;
 736     int enable;
 737     TRACE("(%p)\n",iface);
 738
 739     /* make sure the card doesn't start playing before we want it to */
 740     WOutDev[This->wDevID].ossdev.bOutputEnabled = FALSE;
 741     WOutDev[This->wDevID].ossdev.bInputEnabled = FALSE;
 742     enable = getEnables(&WOutDev[This->wDevID].ossdev);
 743     if (ioctl(WOutDev[This->wDevID].ossdev.fd, SNDCTL_DSP_SETTRIGGER, &enable) < 0) {
 744         ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER) failed (%s)\n",WOutDev[This->wDevID].ossdev.dev_name, strerror(errno));
 745         return DSERR_GENERIC;
 746     }
 747     return DS_OK;
 748 }
 749
 750 static HRESULT WINAPI IDsDriverImpl_Close(PIDSDRIVER iface)
 751 {
 752     IDsDriverImpl *This = (IDsDriverImpl *)iface;
 753     TRACE("(%p)\n",iface);
 754     if (This->primary) {
 755         ERR("problem with DirectSound: primary not released\n");
 756         return DSERR_GENERIC;
 757     }
 758     return DS_OK;
 759 }
 760
 761 static HRESULT WINAPI IDsDriverImpl_GetCaps(PIDSDRIVER iface, PDSDRIVERCAPS pCaps)
 762 {
 763     IDsDriverImpl *This = (IDsDriverImpl *)iface;
 764     TRACE("(%p,%p)\n",iface,pCaps);
 765     *pCaps = WOutDev[This->wDevID].ossdev.ds_caps;
 766     return DS_OK;
 767 }
 768
 769 static HRESULT DSD_CreatePrimaryBuffer(PIDSDRIVER iface,
 770                                        LPWAVEFORMATEX pwfx,
 771                                        DWORD dwFlags,
 772                                        DWORD dwCardAddress,
 773                                        LPDWORD pdwcbBufferSize,
 774                                        LPBYTE *ppbBuffer,
 775                                        LPVOID *ppvObj)
 776 {
 777     IDsDriverImpl *This = (IDsDriverImpl *)iface;
 778     IDsDriverBufferImpl** ippdsdb = (IDsDriverBufferImpl**)ppvObj;
 779     HRESULT err;
 780     audio_buf_info info;
 781     int enable = 0;
 782     TRACE("(%p,%p,%x,%x,%p,%p,%p)\n",iface,pwfx,dwFlags,dwCardAddress,pdwcbBufferSize,ppbBuffer,ppvObj);
 783
 784     if (This->primary)
 785         return DSERR_ALLOCATED;
 786     if (dwFlags & (DSBCAPS_CTRLFREQUENCY | DSBCAPS_CTRLPAN))
 787         return DSERR_CONTROLUNAVAIL;
 788
 789     *ippdsdb = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDsDriverBufferImpl));
 790     if (*ippdsdb == NULL)
 791         return DSERR_OUTOFMEMORY;
 792     (*ippdsdb)->lpVtbl  = &dsdbvt;
 793     (*ippdsdb)->ref     = 1;
 794     (*ippdsdb)->drv     = This;
 795     copy_format(pwfx, &(*ippdsdb)->wfex);
 796     (*ippdsdb)->fd      = WOutDev[This->wDevID].ossdev.fd;
 797     (*ippdsdb)->dwFlags = dwFlags;
 798
 799     /* check how big the DMA buffer is now */
 800     if (ioctl((*ippdsdb)->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
 801         ERR("ioctl(%s, SNDCTL_DSP_GETOSPACE) failed (%s)\n",
 802             WOutDev[This->wDevID].ossdev.dev_name, strerror(errno));
 803         HeapFree(GetProcessHeap(),0,*ippdsdb);
 804         *ippdsdb = NULL;
 805         return DSERR_GENERIC;
 806     }
 807     (*ippdsdb)->maplen = (*ippdsdb)->buflen = info.fragstotal * info.fragsize;
 808
 809     /* map the DMA buffer */
 810     err = DSDB_MapBuffer(*ippdsdb);
 811     if (err != DS_OK) {
 812         HeapFree(GetProcessHeap(),0,*ippdsdb);
 813         *ippdsdb = NULL;
 814         return err;
 815     }
 816
 817     /* primary buffer is ready to go */
 818     *pdwcbBufferSize    = (*ippdsdb)->maplen;
 819     *ppbBuffer          = (*ippdsdb)->mapping;
 820
 821     /* some drivers need some extra nudging after mapping */
 822     WOutDev[This->wDevID].ossdev.bInputEnabled = FALSE;
 823     WOutDev[This->wDevID].ossdev.bOutputEnabled = FALSE;
 824     enable = getEnables(&WOutDev[This->wDevID].ossdev);
 825     if (ioctl((*ippdsdb)->fd, SNDCTL_DSP_SETTRIGGER, &enable) < 0) {
 826         ERR("ioctl(%s, SNDCTL_DSP_SETTRIGGER) failed (%s)\n",
 827             WOutDev[This->wDevID].ossdev.dev_name, strerror(errno));
 828         return DSERR_GENERIC;
 829     }
 830
 831     This->primary = *ippdsdb;
 832
 833     return DS_OK;
 834 }
 835
 836 static HRESULT DSD_CreateSecondaryBuffer(PIDSDRIVER iface,
 837                                          LPWAVEFORMATEX pwfx,
 838                                          DWORD dwFlags,
 839                                          DWORD dwCardAddress,
 840                                          LPDWORD pdwcbBufferSize,
 841                                          LPBYTE *ppbBuffer,
 842                                          LPVOID *ppvObj)
 843 {
 844     IDsDriverImpl *This = (IDsDriverImpl *)iface;
 845     IDsDriverBufferImpl** ippdsdb = (IDsDriverBufferImpl**)ppvObj;
 846     FIXME("(%p,%p,%x,%x,%p,%p,%p): stub\n",This,pwfx,dwFlags,dwCardAddress,pdwcbBufferSize,ppbBuffer,ppvObj);
 847
 848     *ippdsdb = 0;
 849     return DSERR_UNSUPPORTED;
 850 }
 851
 852 static HRESULT WINAPI IDsDriverImpl_CreateSoundBuffer(PIDSDRIVER iface,
 853                                                       LPWAVEFORMATEX pwfx,
 854                                                       DWORD dwFlags,
 855                                                       DWORD dwCardAddress,
 856                                                       LPDWORD pdwcbBufferSize,
 857                                                       LPBYTE *ppbBuffer,
 858                                                       LPVOID *ppvObj)
 859 {
 860     TRACE("(%p,%p,%x,%x,%p,%p,%p)\n",iface,pwfx,dwFlags,dwCardAddress,pdwcbBufferSize,ppbBuffer,ppvObj);
 861
 862     if (dwFlags & DSBCAPS_PRIMARYBUFFER)
 863         return DSD_CreatePrimaryBuffer(iface,pwfx,dwFlags,dwCardAddress,pdwcbBufferSize,ppbBuffer,ppvObj);
 864
 865     return DSD_CreateSecondaryBuffer(iface,pwfx,dwFlags,dwCardAddress,pdwcbBufferSize,ppbBuffer,ppvObj);
 866 }
 867
 868 static HRESULT WINAPI IDsDriverImpl_DuplicateSoundBuffer(PIDSDRIVER iface,
 869                                                          PIDSDRIVERBUFFER pBuffer,
 870                                                          LPVOID *ppvObj)
 871 {
 872     /* IDsDriverImpl *This = (IDsDriverImpl *)iface; */
 873     TRACE("(%p,%p): stub\n",iface,pBuffer);
 874     return DSERR_INVALIDCALL;
 875 }
 876
 877 static const IDsDriverVtbl dsdvt =
 878 {
 879     IDsDriverImpl_QueryInterface,
 880     IDsDriverImpl_AddRef,
 881     IDsDriverImpl_Release,
 882     IDsDriverImpl_GetDriverDesc,
 883     IDsDriverImpl_Open,
 884     IDsDriverImpl_Close,
 885     IDsDriverImpl_GetCaps,
 886     IDsDriverImpl_CreateSoundBuffer,
 887     IDsDriverImpl_DuplicateSoundBuffer
 888 };
 889
 890 static HRESULT IDsDriverPropertySetImpl_Create(
 891     IDsDriverBufferImpl * dsdb,
 892     IDsDriverPropertySetImpl **pdsdps)
 893 {
 894     IDsDriverPropertySetImpl * dsdps;
 895     TRACE("(%p,%p)\n",dsdb,pdsdps);
 896
 897     dsdps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dsdps));
 898     if (dsdps == NULL) {
 899         WARN("out of memory\n");
 900         return DSERR_OUTOFMEMORY;
 901     }
 902
 903     dsdps->ref = 0;
 904     dsdps->lpVtbl = &dsdpsvt;
 905     dsdps->buffer = dsdb;
 906     dsdb->property_set = dsdps;
 907     IDsDriverBuffer_AddRef((PIDSDRIVER)dsdb);
 908
 909     *pdsdps = dsdps;
 910     return DS_OK;
 911 }
 912
 913 static HRESULT IDsDriverNotifyImpl_Create(
 914     IDsDriverBufferImpl * dsdb,
 915     IDsDriverNotifyImpl **pdsdn)
 916 {
 917     IDsDriverNotifyImpl * dsdn;
 918     TRACE("(%p,%p)\n",dsdb,pdsdn);
 919
 920     dsdn = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dsdn));
 921
 922     if (dsdn == NULL) {
 923         WARN("out of memory\n");
 924         return DSERR_OUTOFMEMORY;
 925     }
 926
 927     dsdn->ref = 0;
 928     dsdn->lpVtbl = &dsdnvt;
 929     dsdn->buffer = dsdb;
 930     dsdb->notify = dsdn;
 931     IDsDriverBuffer_AddRef((PIDSDRIVER)dsdb);
 932
 933     *pdsdn = dsdn;
 934     return DS_OK;
 935 }
 936
 937 DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
 938 {
 939     IDsDriverImpl** idrv = (IDsDriverImpl**)drv;
 940     TRACE("(%d,%p)\n",wDevID,drv);
 941
 942     /* the HAL isn't much better than the HEL if we can't do mmap() */
 943     if (!(WOutDev[wDevID].ossdev.duplex_out_caps.dwSupport & WAVECAPS_DIRECTSOUND)) {
 944         WARN("Warn DirectSound flag not set, falling back to HEL layer\n");
 945         return MMSYSERR_NOTSUPPORTED;
 946     }
 947
 948     *idrv = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDsDriverImpl));
 949     if (!*idrv)
 950         return MMSYSERR_NOMEM;
 951     (*idrv)->lpVtbl          = &dsdvt;
 952     (*idrv)->ref             = 1;
 953     (*idrv)->wDevID          = wDevID;
 954     (*idrv)->primary         = NULL;
 955     (*idrv)->nrofsecondaries = 0;
 956     (*idrv)->secondaries     = NULL;
 957
 958     return MMSYSERR_NOERROR;
 959 }
 960
 961 DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc)
 962 {
 963     TRACE("(%d,%p)\n",wDevID,desc);
 964     *desc = WOutDev[wDevID].ossdev.ds_desc;
 965     return MMSYSERR_NOERROR;
 966 }