Changeset 526

Timestamp:

Jul 22, 2010, 9:33:17 PM (15 years ago)

Author:

David Azarewicz

Message:

Reintegrate branch into trunk

Location:

OCO/trunk

Files:

• drv16/audiohw.cpp (modified) (1 diff)
• drv16/dwavestrm.cpp (modified) (13 diffs)
• drv16/dwavestrm.hpp (modified) (1 diff)
• drv16/fmsynth.cpp (modified) (3 diffs)
• drv16/init.cpp (modified) (1 diff)
• drv16/ioctl.cpp (modified) (32 diffs)
• drv16/maudio.cpp (modified) (14 diffs)
• drv16/midistrm.cpp (modified) (13 diffs)
• drv16/mixer.cpp (modified) (16 diffs)
• drv16/mpu401.cpp (modified) (2 diffs)
• drv16/ossidc16.cpp (modified) (29 diffs)
• drv16/rtmidi.cpp (modified) (5 diffs)
• drv16/strategy.cpp (modified) (21 diffs)
• drv16/waudio.cpp (modified) (23 diffs)
• drv16/waveplay.cpp (modified) (15 diffs)
• drv16/waverec.cpp (modified) (4 diffs)
• drv16/wavestrm.cpp (modified) (24 diffs)
• drv16/wavestrm.hpp (modified) (2 diffs)
• drv16/wtsynth.cpp (modified) (5 diffs)
• include/dbgos2.h (modified) (3 diffs)
• install/control.scr (modified) (2 diffs)
• uniaud.inc (modified) (2 diffs)

OCO/trunk/drv16/audiohw.cpp

@@ -227 +227 @@
     PAUDIOHW pEle = (PAUDIOHW)pAudioHWList->Head();
     while (pEle != NULL) {
-#ifdef DEBUG
-//        dprintf(("dev type: %d",pEle->ulDeviceType));
-#endif
+                //dprintf(("dev type: %d",pEle->ulDeviceType));
        if (pEle->ulDeviceType == Devicetype)
           return(pEle);

OCO/trunk/drv16/dwavestrm.cpp

@@ -46 +46 @@
     if (pStream == NULL)
     {
-        dprintf(("HookHandler stream %lx not found!", (ULONG) ulSysFileNum));
+        rprintf(("HookHandler stream %lx not found!", (ULONG) ulSysFileNum));
         DebugInt3();
         return;
@@ -56 +56 @@
             rc = DevHelp_PostEventSem(pStream->hSem);
             if(rc != 0) {
-                dprintf(("DevHlp_PostEventSem returned %d", rc));
+                rprintf(("DevHlp_PostEventSem returned %d", rc));
             }
         }
@@ -80 +80 @@
     pStreamBuf = new STREAMBUFFER(uLength, (PSTREAMBUF)0, fLooping);
     if(pStreamBuf == NULL) {
-        dprintf(("DWAVESTREAM::Write StreamBuf"));
+        rprintf(("DWAVESTREAM::Write StreamBuf"));
         DebugInt3();
         return 1;
@@ -89 +89 @@
     rc = DevHelp_VirtToLin(SELECTOROF(pLock), OFFSETOF(pLock), &linLock);
     if(rc) {
-        dprintf(("DWAVESTREAM::Write VirtToLin"));
+        rprintf(("DWAVESTREAM::Write VirtToLin"));
         DebugInt3();
         delete pStreamBuf;
@@ -97 +97 @@
     rc = DevHelp_VMLock(VMDHL_LONG | VMDHL_WRITE, (LIN)pbuf, uLength, -1L, linLock, (PULONG)&PageListCount);
     if(rc) {
-        dprintf(("DWAVESTREAM::Write VMLock"));
+        rprintf(("DWAVESTREAM::Write VMLock"));
         DebugInt3();
         delete pStreamBuf;
@@ -105 +105 @@
     rc = DevHelp_VMProcessToGlobal(VMDHGP_WRITE, (LIN)pbuf, uLength, (PLIN)&linAddr);
     if(rc) {
-        dprintf(("DWAVESTREAM::Write ProcToGlob"));
+        rprintf(("DWAVESTREAM::Write ProcToGlob"));
         DebugInt3();
         DevHelp_VMUnLock(linLock);
@@ -143 +143 @@
     hSem = pReg->hStream;
 
-#ifdef DEBUG
     dprintf(("DWAVESTREAM::Register"));
-#endif
     if(DevHelp_OpenEventSem(hSem) != 0) {
-        dprintf(("DevHlp_OpenEventSem %lx failed!", hSem));
+        rprintf(("DevHlp_OpenEventSem %lx failed!", hSem));
         hSem = 0;
         return 1;
@@ -158 +156 @@
 {
     if(DevHelp_CloseEventSem(hSem) != 0) {
-        dprintf(("DevHlp_CloseEventSemaphore %lx failed!", hSem));
+        rprintf(("DevHlp_CloseEventSemaphore %lx failed!", hSem));
         return;
     }
@@ -168 +166 @@
 ULONG DWAVESTREAM::StartStream(void)
 {
-#ifdef DEBUG
         dprintf(("DWAVESTREAM::StartStream"));
-#endif
         return WAVESTREAM::StartStream();
 }
 //*****************************************************************************
 //*****************************************************************************
-void DWAVESTREAM::AddBuffers(BOOL fFirst)
+void DWAVESTREAM::AddBuffers(SHORT sFirst)
 {
    PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhDone.Tail();
    ULONG space, Buff_left, byteswritten;
 
-#ifdef DEBUG
         dprintf(("DW::AddBuffers"));
-#endif
     if (!pTemp) pTemp = (PSTREAMBUFFER)qhInProcess.Tail();
 
@@ -190 +184 @@
         if (pahw->GetPosition(StreamId, &_configinfo, &space) != OSSERR_SUCCESS)
         {
-            dprintf(("DWAVESTREAM::AddBuffers GetPositions"));
+            rprintf(("DWAVESTREAM::AddBuffers GetPositions"));
             DebugInt3();
             return;
         }
-        if(fFirst)
+        if(sFirst)
         {
              space = min(space, 4*_configinfo.ulFragsize);
@@ -222 +216 @@
    else
    {
-     WAVESTREAM::AddBuffers(fFirst);
+     WAVESTREAM::AddBuffers(sFirst);
    }
 }
@@ -284 +278 @@
    WAVESTREAM(streamtype, pinit, filesysnum, mixerStreamId), fError(FALSE), hCtxHook(0), hSem(0)
 {
-#ifdef DEBUG
         dprintf(("DWS::DWS Init"));
-#endif
     if (DevHelp_AllocateCtxHook((NPFN)HookHandlerAsm, &hCtxHook))
     {
-        dprintf(("DWAVESTREAM::DWAVESTREAM AllocCtx"));
+        rprintf(("DWAVESTREAM::DWAVESTREAM AllocCtx"));
         DebugInt3();
         fError = TRUE;
@@ -307 +299 @@
         APIRET rc = DevHelp_PostEventSem(hSem);
         if(rc != 0) {
-            dprintf(("DevHlp_PostEventSem returned %d", rc));
+            rprintf(("DevHlp_PostEventSem returned %d", rc));
         }
         if(DevHelp_CloseEventSem(hSem) != 0) {
-            dprintf(("DevHlp_CloseEventSemaphore %lx failed!", hSem));
+            rprintf(("DevHlp_CloseEventSemaphore %lx failed!", hSem));
         }
     }

OCO/trunk/drv16/dwavestrm.hpp

@@ -59 +59 @@
    virtual void ReturnBuffer(void);   // returns one buffer
 
-   virtual void AddBuffers(BOOL fFirst);            // Initialize the audio buffer object
+   virtual void AddBuffers(SHORT sFirst);           // Initialize the audio buffer object
 
    QUEUEHEAD qhReturn;          //queue with buffers to be returned

OCO/trunk/drv16/fmsynth.cpp

@@ -48 +48 @@
         if(OSS16_MidiOpen(current_device, FM_SEND, pStreamId) != OSSERR_SUCCESS)
         {
-            dprintf(("FMSYNTH::Open: OSS16_MidiOpen failed!!"));
+            rprintf(("FMSYNTH::Open: OSS16_MidiOpen failed!!"));
             DebugInt3();
             midiOutStreamId = 0;
@@ -69 +69 @@
 #if 0
     if(OSS16_MidiClose(StreamId) != OSSERR_SUCCESS) {
-        dprintf(("FMSYNTH::close: OSS16_MidiClose failed!!"));
+        rprintf(("FMSYNTH::close: OSS16_MidiClose failed!!"));
         DebugInt3();
         return FALSE;
@@ -121 +121 @@
 {
     if(MixerSetVolume(mixerStreamId, OSS32_MIX_VOLUME_MIDI, ulVolume) != TRUE) {
-        dprintf(("FMSYNTH::SetVolume: MixerSetVolume failed!!"));
+        rprintf(("FMSYNTH::SetVolume: MixerSetVolume failed!!"));
         //not necessarily fatal; maybe there is no volume control for midi
     }

OCO/trunk/drv16/init.cpp

@@ -110 +110 @@
     //functions have been moved into a seperate code segment)
     if(DevHelp_Lock(SELECTOROF(dbgptr), LOCKTYPE_LONG_ANYMEM, 0, &lockhandle)) {
-            dprintf(("DevHelp_Lock failed on debug selector"));
+            rprintf(("DevHelp_Lock failed on debug selector"));
             DebugInt3();
             return;

OCO/trunk/drv16/ioctl.cpp

@@ -202 +202 @@
    ULONG ulDevicetype;
 
-#ifdef DEBUG
    dprintf(("IACapability: src type: 0x%lx, op %d",p->ulDataType, (USHORT)p->ulOperation));
-#endif
 
    // get the hardware device type based on the datatype and operation
    ulDevicetype = GetHardwareType((USHORT)p->ulDataType,(USHORT)p->ulOperation,LDev);
 
-#ifdef DEBUG
-//   dprintf(("IACapability: dev type: %ld, ldev %d",ulDevicetype, LDev));
-#endif
+        //dprintf(("IACapability: dev type: %ld, ldev %d",ulDevicetype, LDev));
 
    // Tell the caller we support this IOCTL
@@ -231 +227 @@
          p->ulSamplingRate = HZ_44100;
          //
-         dprintf(("IACapability: Error support"));
+         rprintf(("IACapability: Error support"));
          prp->usStatus |= RPERR;
       }
    }
    else {
-#ifdef DEBUG
-//       dprintf(("IACapability: Error get HW obj"));
-#endif
+        //dprintf(("IACapability: Error get HW obj"));
       //PS+++ filling to our parameters as say mmpm2.inf for returning error in this call
       // (for HDA only!!!!!)
@@ -270 +264 @@
    if (p->usIOCtlRequest != AUDIO_CHANGE)
    {
-       dprintf(("IAudioControl: Error support req:%x",p->usIOCtlRequest));
+       rprintf(("IAudioControl: Error support req:%x",p->usIOCtlRequest));
        p->sReturnCode = INVALID_REQUEST;
        prp->usStatus |= RPERR | RPBADCMD;
@@ -284 +278 @@
    if(addr >= 0x10000UL)
    {
-       dprintf(("Invalid MCI_AUDIO_CHANGE pnt %lx!!", (ULONG)pAudChange));
+       rprintf(("Invalid MCI_AUDIO_CHANGE pnt %lx!!", (ULONG)pAudChange));
        p->sReturnCode = INVALID_REQUEST;
        prp->usStatus |= RPERR | RPBADCMD;
@@ -296 +290 @@
    if(addr >= 0x10000UL)
    {
-       dprintf(("Invalid MCI_TRACK_INFO pnt %lx!!", (ULONG)pMasterVol));
+       rprintf(("Invalid MCI_TRACK_INFO pnt %lx!!", (ULONG)pMasterVol));
        p->sReturnCode = INVALID_REQUEST;
        prp->usStatus |= RPERR | RPBADCMD;
@@ -304 +298 @@
    pStream = FindStream_fromFile((ULONG) prp->s.ioctl.usSysFileNum);
    if(pStream == NULL) {
-       dprintf(("IAudioControl stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
+       rprintf(("IAudioControl stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
        DebugInt3();
        return;
@@ -316 +310 @@
        volume = pAudChange->lVolume >> 16UL;
        volume = (volume*OSS32_MAX_VOLUME)/0x7FFFUL;
-//       dprintf(("Set stream volume of %x to %d", prp->s.ioctl.usSysFileNum, volume));
+                //dprintf(("Set stream volume of %x to %d", prp->s.ioctl.usSysFileNum, volume));
        pStream->SetProperty(PROPERTY_VOLUME, MAKE_VOLUME_LR(volume, volume));
    }
@@ -390 +384 @@
         if(DevHelp_VerifyAccess(SELECTOROF(pInit), sizeof(MCI_AUDIO_INIT), OFFSETOF(pInit), VERIFY_READWRITE))
         {
-            dprintf(("Invalid MCI_AUDIO_INIT pnt %lx!!", (ULONG)pInit));
+            rprintf(("Invalid MCI_AUDIO_INIT pnt %lx!!", (ULONG)pInit));
             prp->usStatus |= RPERR | RPBADCMD;
             return;
@@ -411 +405 @@
             if (audioCaps.ulSupport != SUPPORT_SUCCESS)
             {
-                dprintf(("IDirectAudio: DevCaps failed"));
+                rprintf(("IDirectAudio: DevCaps failed"));
                 pInit->sReturnCode = INVALID_REQUEST;
                 prp->usStatus |= RPERR;
@@ -419 +413 @@
         else
         {
-            dprintf(("IDirectAudio: HW DevCaps failed"));
+            rprintf(("IDirectAudio: HW DevCaps failed"));
             pInit->sReturnCode = INVALID_REQUEST;
             prp->usStatus |= RPERR;
@@ -427 +421 @@
         pStream = new DWAVESTREAM(AUDIOHW_WAVE_PLAY, pInit,  prp->s.ioctl.usSysFileNum, MixerStreamId);
         if(pStream == NULL) {
-//            dprintf(("IDirectAudio: pStream"));
+                        //dprintf(("IDirectAudio: pStream"));
             DebugInt3();
             pInit->sReturnCode = INVALID_REQUEST;
@@ -437 +431 @@
         {
             delete pStream;
-//            dprintf(("IlDirectAudio: IsEverythingOk"));
+                        //dprintf(("IlDirectAudio: IsEverythingOk"));
             DebugInt3();
             pInit->sReturnCode = INVALID_REQUEST;
@@ -463 +457 @@
         if(DevHelp_VerifyAccess(SELECTOROF(pInit), sizeof(MCI_AUDIO_INIT), OFFSETOF(pInit), VERIFY_READWRITE))
         {
-            dprintf(("Invalid MCI_AUDIO_INIT pnt %lx!!", (ULONG)pInit));
+            rprintf(("Invalid MCI_AUDIO_INIT pnt %lx!!", (ULONG)pInit));
             prp->usStatus |= RPERR | RPBADCMD;
             return;
@@ -484 +478 @@
             if (audioCaps.ulSupport != SUPPORT_SUCCESS)
             {
-                dprintf(("IlDirectAudio: DevCaps failed"));
+                rprintf(("IlDirectAudio: DevCaps failed"));
                 prp->usStatus |= RPERR;
                 pInit->sReturnCode = INVALID_REQUEST;
                 return;
             }
-//            dprintf(("IoctlDirectAudio ret0"));
+                        //dprintf(("IoctlDirectAudio ret0"));
             pInit->sReturnCode = 0;
             return;
         }
         else {
-            dprintf(("IoctlDirectAudio err req"));
+            rprintf(("IoctlDirectAudio err req"));
             pInit->sReturnCode = INVALID_REQUEST;
             prp->usStatus |= RPERR;
@@ -508 +502 @@
         if(DevHelp_VerifyAccess(SELECTOROF(lpCaps), sizeof(OSS32_DEVCAPS), OFFSETOF(lpCaps), VERIFY_READWRITE))
         {
-            dprintf(("Invalid OSS32_DEVCAPS pnt %lx!!", (ULONG)lpCaps));
+            rprintf(("Invalid OSS32_DEVCAPS pnt %lx!!", (ULONG)lpCaps));
             prp->usStatus |= RPERR | RPBADCMD;
             return;
@@ -519 +513 @@
         {
             pHWobj->DevCaps(lpCaps);
-//            dprintf(("IoctlDirectAudio ret1"));
+                        //dprintf(("IoctlDirectAudio ret1"));
             return;
         }
@@ -525 +519 @@
         {
             prp->usStatus |= RPERR;
-//            dprintf(("IoctlDirectAudio ret err1"));
+                        //dprintf(("IoctlDirectAudio ret err1"));
             return;
         }
@@ -534 +528 @@
     if(pStream == NULL)
     {
-        dprintf(("IDirectAudio stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
+        rprintf(("IDirectAudio stream %lx not found!", (ULONG) prp->s.ioctl.usSysFileNum));
         DebugInt3();
         prp->usStatus |= RPERR | RPBADCMD;
@@ -545 +539 @@
     if(DevHelp_VerifyAccess(SELECTOROF(pDAudioCmd), sizeof(DAUDIO_CMD), OFFSETOF(pDAudioCmd), VERIFY_READWRITE))
     {
-        dprintf(("Invalid DAUDIO_CMD pnt %lx!!", (ULONG)pDAudioCmd));
+        rprintf(("Invalid DAUDIO_CMD pnt %lx!!", (ULONG)pDAudioCmd));
         prp->usStatus |= RPERR | RPBADCMD;
         return;
@@ -553 +547 @@
     {
     case DAUDIO_CLOSE:
-//         dprintf(("ID close"));
+                //dprintf(("ID close"));
         delete pStream;
         break;
@@ -559 +553 @@
     case DAUDIO_SETVOLUME:
     {
-//        dprintf(("ID SetVolume"));
+                //dprintf(("ID SetVolume"));
         pStream->SetProperty(PROPERTY_VOLUME, MAKE_VOLUME_LR(pDAudioCmd->Vol.VolumeL, pDAudioCmd->Vol.VolumeR));
         break;
@@ -566 +560 @@
     case DAUDIO_GETVOLUME:
     {
-//        dprintf(("ID GetVolume"));
+                //dprintf(("ID GetVolume"));
         pDAudioCmd->Vol.VolumeL = GET_VOLUME_L(pStream->GetProperty(PROPERTY_VOLUME));
         pDAudioCmd->Vol.VolumeR = GET_VOLUME_R(pStream->GetProperty(PROPERTY_VOLUME));
@@ -582 +576 @@
         else
         {
-              dprintf(("ID Start rc1"));
+              rprintf(("ID Start rc1"));
               rc = 1; //fail
         }
@@ -616 +610 @@
     case DAUDIO_GETPOS:
     {
-//        dprintf(("ID GetPos"));
+                //dprintf(("ID GetPos"));
         pDAudioCmd->Pos.ulCurrentPos = pStream->GetCurrentPos();
         pDAudioCmd->Pos.ulWritePos   = pStream->GetCurrentWritePos();
@@ -624 +618 @@
     case DAUDIO_ADDBUFFER:
     {
-//        dprintf(("ID AddBuffer"));
+                //dprintf(("ID AddBuffer"));
         rc = pStream->Write((PSTREAMBUF)pDAudioCmd->Buffer.lpBuffer, pDAudioCmd->Buffer.ulBufferLength);
         break;
@@ -631 +625 @@
     case DAUDIO_SETPROPERTY:
     {
-//        dprintf(("ID SetProp"));
+                //dprintf(("ID SetProp"));
         rc = pStream->SetProperty((USHORT)pDAudioCmd->SetProperty.type, pDAudioCmd->SetProperty.value);
         break;
@@ -640 +634 @@
         DDCMDREGISTER reg;
 
-//        dprintf(("ID Reg"));
+                //dprintf(("ID Reg"));
         reg.ulFunction     = DDCMD_REG_STREAM;
         reg.hStream        = pDAudioCmd->Thread.hSemaphore;
@@ -651 +645 @@
     case DAUDIO_DEREGISTER_THREAD:
     {
-//        dprintf(("ID DeReg"));
+                //dprintf(("ID DeReg"));
         pStream->DeRegister();
         break;
@@ -657 +651 @@
 
     case DAUDIO_QUERYVERSION:
-//        dprintf(("ID qVer"));
+                //dprintf(("ID qVer"));
         pDAudioCmd->Version.ulVersion = DAUDIO_VERSION;
         break;
@@ -664 +658 @@
     if(rc)
     {
-//        dprintf(("IoctlDirectAudio ret err rc=%ld",rc));
+                //dprintf(("IoctlDirectAudio ret err rc=%ld",rc));
         prp->usStatus |= RPERR | RPBADCMD;
         return;
     }
-//    dprintf(("IoctlDirectAudio ret Ok"));
+        //dprintf(("IoctlDirectAudio ret Ok"));
     return;
 }
@@ -687 +681 @@
 extern "C" void StrategyIoctl(PREQPACKET prp, USHORT LDev)
 {
-#ifdef DEBUG
     dprintf(("StrategyIoctl:cat:0x%x, code:0x%x cd %d gd %d", prp->s.ioctl.bCategory, prp->s.ioctl.bCode, current_device, LDev));
-#endif
         switch (prp->s.ioctl.bCategory) {
         case DAUDIO_IOCTL_CAT: /* 0x91 */
@@ -721 +713 @@
         }
 
-#ifdef DEBUG
-        dprintf(("StrategyIoctl:ret:0x%x", (USHORT)prp->usStatus));
-#endif
+        //dprintf(("StrategyIoctl:ret:0x%x", (USHORT)prp->usStatus));
         return;
 }

OCO/trunk/drv16/maudio.cpp

@@ -3 +3 @@
 /* SCCSID = %W% %E% */
 /****************************************************************************
- *                                                                          *
- * Copyright (c) IBM Corporation 1994 - 1997.                               *
- *                                                                          *
- * The following IBM OS/2 source code is provided to you solely for the     *
+ *                                                                                                                                                      *
+ * Copyright (c) IBM Corporation 1994 - 1997.                                                           *
+ *                                                                                                                                                      *
+ * The following IBM OS/2 source code is provided to you solely for the         *
  * the purpose of assisting you in your development of OS/2 device drivers. *
- * You may use this code in accordance with the IBM License Agreement       *
- * provided in the IBM Device Driver Source Kit for OS/2.                   *
- *                                                                          *
+ * You may use this code in accordance with the IBM License Agreement           *
+ * provided in the IBM Device Driver Source Kit for OS/2.                                       *
+ *                                                                                                                                                      *
  ****************************************************************************/
 /**@internal %W%
- *  MIDI audio hardware object implementation.
+ *      MIDI audio hardware object implementation.
  * @version %I%
  * @context
- *  Unless otherwise noted, all interfaces are Ring-0, 16-bit, kernel stack.
+ *      Unless otherwise noted, all interfaces are Ring-0, 16-bit, kernel stack.
  * @notes
  * @history
@@ -25 +25 @@
 #include <os2medef.h>
 #include <audio.h>
-#include "midi_idc.h"                    // RTMIDI interfaces
+#include "midi_idc.h"                                    // RTMIDI interfaces
 #include "maudio.hpp"
 #include <dbgos2.h>
@@ -37 +37 @@
 {
 
-   pCaps->ulSupport       = SUPPORT_SUCCESS;
+   pCaps->ulSupport       = SUPPORT_SUCCESS;
    pCaps->ulDataSubType   = SUBTYPE_NONE;
    pCaps->ulResourceUnits = 1;
    pCaps->ulResourceClass = 1;
-   pCaps->fCanRecord      = FALSE;
-   pCaps->ulFlags         = INPUT   |          // Input select is supported
-                            OUTPUT  |          // Output select is supported
-                            MONITOR |          // Monitor is supported
-                            VOLUME;            // Volume control is supported
+   pCaps->fCanRecord      = FALSE;
+   pCaps->ulFlags                 = INPUT       |                  // Input select is supported
+                                                        OUTPUT  |                  // Output select is supported
+                                                        MONITOR |                  // Monitor is supported
+                                                        VOLUME;                    // Volume control is supported
 }
 //******************************************************************************
@@ -59 +59 @@
 {
    for (int iChannel=0; iChannel<16; iChannel++) {
-      writeByte(StreamId, (BYTE) (0xB0 + iChannel));    // channel mode
-      writeByte(StreamId, 123);                         // all notes off
-      writeByte(StreamId, 0);
+          writeByte(StreamId, (BYTE) (0xB0 + iChannel));        // channel mode
+          writeByte(StreamId, 123);                                             // all notes off
+          writeByte(StreamId, 0);
    }
 
@@ -72 +72 @@
 int MIDIAUDIO::writeByte(OSSSTREAMID StreamId, BYTE b)
 {
-   return 0;    // Failure.
+   return 0;    // Failure.
 }
 //******************************************************************************
@@ -78 +78 @@
 int MIDIAUDIO::readByte(OSSSTREAMID StreamId)
 {
-   return -1;   // Failure.
+   return -1;   // Failure.
 }
 //******************************************************************************
@@ -108 +108 @@
 BOOL MIDIAUDIO::SetVolume(OSSSTREAMID StreamId, OSSSTREAMID mixerStreamId, ULONG ulVolume)
 {
-    return FALSE;
+        return FALSE;
 }
 //******************************************************************************
 //******************************************************************************
-int MIDIAUDIO::Pause(OSSSTREAMID StreamId)         // Pause the operation
+int MIDIAUDIO::Pause(OSSSTREAMID StreamId)                 // Pause the operation
 {
-//    dprintf(("DUMMY MIDIAUDIO::Pause"));
-    DebugInt3();
-    return 0;
+        //dprintf(("DUMMY MIDIAUDIO::Pause"));
+        DebugInt3();
+        return 0;
 }
 //******************************************************************************
 //******************************************************************************
-int MIDIAUDIO::Resume(OSSSTREAMID StreamId)        // Resume the operation
+int MIDIAUDIO::Resume(OSSSTREAMID StreamId)        // Resume the operation
 {
-//    dprintf(("DUMMY MIDIAUDIO::Resume"));
-    DebugInt3();
-    return 0;
+        //dprintf(("DUMMY MIDIAUDIO::Resume"));
+        DebugInt3();
+        return 0;
 }
 //******************************************************************************
@@ -130 +130 @@
 void MIDIAUDIO::noteOff(OSSSTREAMID StreamId, BYTE mchan, BYTE note, BYTE velocity )
 {
-//    dprintf2(("MIDIAUDIO::noteOff %d %d %d", mchan, note, velocity));
-    if(OSS16_MidiNoteOff(StreamId, mchan, note, velocity) != OSSERR_SUCCESS) {
-       DebugInt3();
-    }
+        //dprintf2(("MIDIAUDIO::noteOff %d %d %d", mchan, note, velocity));
+        if(OSS16_MidiNoteOff(StreamId, mchan, note, velocity) != OSSERR_SUCCESS) {
+           DebugInt3();
+        }
 }
 //******************************************************************************
@@ -139 +139 @@
 void MIDIAUDIO::noteOn(OSSSTREAMID StreamId, BYTE mchan, BYTE note, BYTE velocity )
 {
-//    dprintf2(("MIDIAUDIO::noteOn %d %d %d", mchan, note, velocity));
-    if(OSS16_MidiNoteOn(StreamId, mchan, note, velocity) != OSSERR_SUCCESS) {
-        DebugInt3();
-    }
+        //dprintf2(("MIDIAUDIO::noteOn %d %d %d", mchan, note, velocity));
+        if(OSS16_MidiNoteOn(StreamId, mchan, note, velocity) != OSSERR_SUCCESS) {
+                DebugInt3();
+        }
 }
 //******************************************************************************
@@ -148 +148 @@
 void MIDIAUDIO::polyphonicPressure(OSSSTREAMID StreamId, BYTE mchan, BYTE note, BYTE value )
 {
-//    dprintf2(("MIDIAUDIO::polyphonicPressure %d %d %d", mchan, note, value));
-    if(OSS16_MidiKeyPressure(StreamId, mchan, note, value) != OSSERR_SUCCESS) {
-        DebugInt3();
-    }
+        //dprintf2(("MIDIAUDIO::polyphonicPressure %d %d %d", mchan, note, value));
+        if(OSS16_MidiKeyPressure(StreamId, mchan, note, value) != OSSERR_SUCCESS) {
+                DebugInt3();
+        }
 }
 //******************************************************************************
@@ -157 +157 @@
 void MIDIAUDIO::controlChange(OSSSTREAMID StreamId, BYTE mchan, BYTE control_number, BYTE value )
 {
-//    dprintf2(("MIDIAUDIO::controlChange %d %d %d", mchan, control_number, value));
-    if(OSS16_MidiControlChange(StreamId, mchan, control_number, value) != OSSERR_SUCCESS) {
-        DebugInt3();
-    }
+        //dprintf2(("MIDIAUDIO::controlChange %d %d %d", mchan, control_number, value));
+        if(OSS16_MidiControlChange(StreamId, mchan, control_number, value) != OSSERR_SUCCESS) {
+                DebugInt3();
+        }
 }
 //******************************************************************************
@@ -166 +166 @@
 void MIDIAUDIO::programChange(OSSSTREAMID StreamId, BYTE mchan, BYTE program_number )
 {
-//    dprintf2(("MIDIAUDIO::programChange %d %d", mchan, program_number));
-    if(OSS16_MidiProgramChange(StreamId, mchan, program_number) != OSSERR_SUCCESS) {
-        DebugInt3();
-    }
+        //dprintf2(("MIDIAUDIO::programChange %d %d", mchan, program_number));
+        if(OSS16_MidiProgramChange(StreamId, mchan, program_number) != OSSERR_SUCCESS) {
+                DebugInt3();
+        }
 }
 //******************************************************************************
@@ -175 +175 @@
 void MIDIAUDIO::channelPressure(OSSSTREAMID StreamId, BYTE mchan, BYTE value )
 {
-//    dprintf2(("MIDIAUDIO::channelPressure %d %d", mchan, value));
-    if(OSS16_MidiChannelPressure(StreamId, mchan, value) != OSSERR_SUCCESS) {
-        DebugInt3();
-    }
+        //dprintf2(("MIDIAUDIO::channelPressure %d %d", mchan, value));
+        if(OSS16_MidiChannelPressure(StreamId, mchan, value) != OSSERR_SUCCESS) {
+                DebugInt3();
+        }
 }
 //******************************************************************************
@@ -184 +184 @@
 void MIDIAUDIO::pitchBend(OSSSTREAMID StreamId, BYTE mchan, BYTE value_lsb, BYTE value_msb)
 {
-//    dprintf2(("MIDIAUDIO::pitchBend %d %d %d", mchan, value_lsb, value_msb));
-    if(OSS16_MidiKeyPressure(StreamId, mchan, value_lsb, value_msb) != OSSERR_SUCCESS) {
-        DebugInt3();
-    }
+        //dprintf2(("MIDIAUDIO::pitchBend %d %d %d", mchan, value_lsb, value_msb));
+        if(OSS16_MidiKeyPressure(StreamId, mchan, value_lsb, value_msb) != OSSERR_SUCCESS) {
+                DebugInt3();
+        }
 }
 //******************************************************************************

OCO/trunk/drv16/midistrm.cpp

@@ -3 +3 @@
 /* SCCSID = %W% %E% */
 /****************************************************************************
- *                                                                          *
- * Copyright (c) IBM Corporation 1994 - 1997.                               *
- *                                                                          *
- * The following IBM OS/2 source code is provided to you solely for the     *
+ *                                                                                                                                                      *
+ * Copyright (c) IBM Corporation 1994 - 1997.                                                           *
+ *                                                                                                                                                      *
+ * The following IBM OS/2 source code is provided to you solely for the         *
  * the purpose of assisting you in your development of OS/2 device drivers. *
- * You may use this code in accordance with the IBM License Agreement       *
- * provided in the IBM Device Driver Source Kit for OS/2.                   *
- *                                                                          *
+ * You may use this code in accordance with the IBM License Agreement           *
+ * provided in the IBM Device Driver Source Kit for OS/2.                                       *
+ *                                                                                                                                                      *
  ****************************************************************************/
 /**@internal %W%
  * @notes
- *  MIDISTREAM class implementation.  The Midi Stream class is derived
- *  from the Stream class.
+ *      MIDISTREAM class implementation.  The Midi Stream class is derived
+ *      from the Stream class.
  * @version %I%
  * @context Unless otherwise noted, all interfaces are Ring-0, 16-bit,
- *  kernel stack.
+ *      kernel stack.
  * @history
  *
  */
 #define INCL_NOPMAPI
-#define INCL_DOSERRORS            // for ERROR_INVALID_FUNCTION
+#define INCL_DOSERRORS                    // for ERROR_INVALID_FUNCTION
 #include <os2.h>
 #include <os2me.h>
-#include <audio.h>                // for #define MIDI
+#include <audio.h>                                // for #define MIDI
 
 #include <include.h>
@@ -39 +39 @@
 USHORT MIDISTREAM::_usBitNumber[ NUM_MidiChannels ] =
   { 0x0001, 0x0002, 0x0004, 0x0008,
-    0x0010, 0x0020, 0x0040, 0x0080,
-    0x0100, 0x0200, 0x0400, 0x0800,
-    0x1000, 0x2000, 0x4000, 0x8000 };
+        0x0010, 0x0020, 0x0040, 0x0080,
+        0x0100, 0x0200, 0x0400, 0x0800,
+        0x1000, 0x2000, 0x4000, 0x8000 };
 
 
 /**@internal CalcDelay
- * @param    None
- * @return   None
+ * @param        None
+ * @return       None
  * @notes
- *           600,000,000 microseconds/10 minutes
- *----------------------------------------------------------   ==   X microseconds/clock
- *                                    usCPQNnum
- *  (ulTempo beats/10 min) * ( 24 * ------------- clocks/beat )
- *                                    usCPQNden
- *
- *
- *      25,000,000 * usCPQNden
+ *                       600,000,000 microseconds/10 minutes
+ *----------------------------------------------------------   ==       X microseconds/clock
+ *                                                                        usCPQNnum
+ *      (ulTempo beats/10 min) * ( 24 * ------------- clocks/beat )
+ *                                                                        usCPQNden
+ *
+ *
+ *              25,000,000 * usCPQNden
  *==  --------------------------
- *       ulTempo * usCPQNnum
+ *               ulTempo * usCPQNnum
  *
  * where
  * usCPQNden = ((usCPQN & 0x3F) + 1) * 3
- * usCPQNnum = 1                                    if bit 6 of usCPQN is set
- *
- *    or
+ * usCPQNnum = 1                                                                        if bit 6 of usCPQN is set
+ *
+ *        or
  *
  * usCPQNden = 1
- * usCPQNnum = usCPQN + 1                           if bit 6 is not set
+ * usCPQNnum = usCPQN + 1                                                       if bit 6 is not set
  */
 void MIDISTREAM::CalcDelay(void)
@@ -72 +72 @@
    ULONG ul;
 
-   if (usCPQN & 0x40) {          // bit 6 is set if it's a denominator
-      ul = 25000000 * ((usCPQN & 0x3F) + 1);
-      ulPerClock = ul / ulTempo;
-      ulPerClock *= 3;
+   if (usCPQN & 0x40) {                  // bit 6 is set if it's a denominator
+          ul = 25000000 * ((usCPQN & 0x3F) + 1);
+          ulPerClock = ul / ulTempo;
+          ulPerClock *= 3;
    } else {
-      ul = ulTempo * (usCPQN+1);
-      ulPerClock = 25000000 / ul;
+          ul = ulTempo * (usCPQN+1);
+          ulPerClock = 25000000 / ul;
    }
 }
@@ -84 +84 @@
 
 /**@external MIDISTRM::Process
- *  Consume MIDI bytes from the MMPM/2 stream buffers and send
- *  them off to the MIDI parser to be interpreted.
+ *      Consume MIDI bytes from the MMPM/2 stream buffers and send
+ *      them off to the MIDI parser to be interpreted.
  * @param void
  * @return void
  * @notes Runs at Task time on a global context hook;  does not run
- *  on an interrupt level.  Interacts with the Timer object defined
- *  for this stream to obtain current time and to request next Stream
- *  time to be scheduled.
+ *      on an interrupt level.  Interacts with the Timer object defined
+ *      for this stream to obtain current time and to request next Stream
+ *      time to be scheduled.
  */
 void MIDISTREAM::Process( void )
 {
-   ULONG ulNewTime;                    // Time, in mSec, on entry.
-   ULONG ulElapsedTime;                // Elapsed time, last tick to this one.
+   ULONG ulNewTime;                                // Time, in mSec, on entry.
+   ULONG ulElapsedTime;                            // Elapsed time, last tick to this one.
 
    // Update time variables.
    ulNewTime = ((MIDIAUDIO*) pahw)->getTimer()->ulGetTime();
    if ( ulNewTime > _ulLastProcess )
-      ulElapsedTime = ulNewTime - _ulLastProcess;
+          ulElapsedTime = ulNewTime - _ulLastProcess;
    else
-      ulElapsedTime = 0;
+          ulElapsedTime = 0;
 
    _ulLastProcess = ulNewTime;
    ulCurrentTime = ulNewTime;
 
-   if (qhInProcess.IsElements() == 0)   // no buffers to process?
-      return;
-
-   if (ulStreamState == STREAM_PAUSED)    // is the stream paused?
-      return;
+   if (qhInProcess.IsElements() == 0)   // no buffers to process?
+          return;
+
+   if (ulStreamState == STREAM_PAUSED)    // is the stream paused?
+          return;
 
    ProcessEvents();
@@ -123 +123 @@
 
    while (lWait <= 0 && qhInProcess.IsElements()) {
-      parse(*(pbuff + (pstreambuff->ulBuffpos)++));
-
-      if (pstreambuff->ulBuffpos >= buffsz) {
-         qhDone.PushOnTail(qhInProcess.PopHead());
-         pstreambuff = (PSTREAMBUFFER) qhInProcess.Head();
-         pbuff = pstreambuff->pBuffptr;
-         buffsz = pstreambuff->ulBuffsz;
-      }
+          parse(*(pbuff + (pstreambuff->ulBuffpos)++));
+
+          if (pstreambuff->ulBuffpos >= buffsz) {
+                 qhDone.PushOnTail(qhInProcess.PopHead());
+                 pstreambuff = (PSTREAMBUFFER) qhInProcess.Head();
+                 pbuff = pstreambuff->pBuffptr;
+                 buffsz = pstreambuff->ulBuffsz;
+          }
    }
    while (qhDone.IsElements())
-      ReturnBuffer();
+          ReturnBuffer();
 
    // Determine next time to run.  If we submit a time that has already
@@ -163 +163 @@
 }
 /**@internal MIDISTREAM::_allNotesOff
- *  Shut off all notes that are currently playing.
+ *      Shut off all notes that are currently playing.
  * @param None.
  * @return void
  * @notes This function walks the _notesOn array and shuts off any note
- *  that is flagged as being actively played.
+ *      that is flagged as being actively played.
  */
 void MIDISTREAM::_allNotesOff( void )
 {
    for ( USHORT noteNum=0; noteNum < NUM_MidiNotes; ++noteNum)
-      if (_notesOn[noteNum])
-         // This note number is playing on one or more channels.
-         // Shut the note off on all channels on which it is playing.
-         for ( USHORT mchan=0; mchan < NUM_MidiChannels; ++mchan)
-            if (_notesOn[noteNum] & _usBitNumber[mchan]) {
-               pahw->noteOff(StreamId,  (BYTE)mchan, (BYTE)noteNum, 0 );
-               _notesOn[noteNum] &= ~(_usBitNumber[mchan]);
-            }
+          if (_notesOn[noteNum])
+                 // This note number is playing on one or more channels.
+                 // Shut the note off on all channels on which it is playing.
+                 for ( USHORT mchan=0; mchan < NUM_MidiChannels; ++mchan)
+                        if (_notesOn[noteNum] & _usBitNumber[mchan]) {
+                           pahw->noteOff(StreamId,      (BYTE)mchan, (BYTE)noteNum, 0 );
+                           _notesOn[noteNum] &= ~(_usBitNumber[mchan]);
+                        }
 }
 //******************************************************************************
@@ -185 +185 @@
 ULONG  MIDISTREAM::StartStream(void)
 {
-//    dprintf(("MIDISTREAM::StartStream %lx %lx", (void far *)this, StreamId));
-    
-    state = S_Init;                        // Reset parser state.
-    message.clear();                       // Clear current message.
-    lWait = 0;  //SvL, reset this too
-
-    pahw->getTimer()->vSetTime(ulCurrentTime);
-    if (!pahw->Start(StreamId)) {
-        DebugInt3();
-        return ERROR_START_STREAM;
-    }
-
-    ulStreamState = STREAM_STREAMING;
-    pahw->SetVolume(StreamId, getMixerStreamId(), volume);
-    return NO_ERROR;
+        //dprintf(("MIDISTREAM::StartStream %lx %lx", (void far *)this, StreamId));
+
+        state = S_Init;                                            // Reset parser state.
+        message.clear();                                           // Clear current message.
+        lWait = 0;      //SvL, reset this too
+
+        pahw->getTimer()->vSetTime(ulCurrentTime);
+        if (!pahw->Start(StreamId)) {
+                DebugInt3();
+                return ERROR_START_STREAM;
+        }
+
+        ulStreamState = STREAM_STREAMING;
+        pahw->SetVolume(StreamId, getMixerStreamId(), volume);
+        return NO_ERROR;
 }
 //******************************************************************************
@@ -205 +205 @@
 ULONG  MIDISTREAM::StopStream(PCONTROL_PARM pControl)
 {
-    if(ulStreamState == STREAM_STOPPED) {
-//              dprintf(("MIDISTREAM::StopStream %lx (already stopped)", StreamId));
-            pControl->ulTime = GetCurrentTime();
-            return NO_ERROR;
-    }
-
-//    dprintf(("MIDISTREAM::StopStream %lx %lx", (void far *)this, StreamId));
-    ulStreamState = STREAM_STOPPED;
-    pahw->Stop(StreamId);
-    _allNotesOff();
-    ReturnBuffers();
-    pControl->ulTime = GetCurrentTime();
-    return NO_ERROR;
+        if(ulStreamState == STREAM_STOPPED) {
+                //dprintf(("MIDISTREAM::StopStream %lx (already stopped)", StreamId));
+                pControl->ulTime = GetCurrentTime();
+                return NO_ERROR;
+        }
+
+        //dprintf(("MIDISTREAM::StopStream %lx %lx", (void far *)this, StreamId));
+        ulStreamState = STREAM_STOPPED;
+        pahw->Stop(StreamId);
+        _allNotesOff();
+        ReturnBuffers();
+        pControl->ulTime = GetCurrentTime();
+        return NO_ERROR;
 }
 //******************************************************************************
@@ -223 +223 @@
 ULONG  MIDISTREAM::PauseStream(PCONTROL_PARM pControl)
 {
-//    dprintf(("MIDISTREAM::PauseStream %lx %lx", (void far *)this, StreamId));
-    if (ulStreamState == STREAM_PAUSED) {   // is the stream paused?
-        DebugInt3();
-        return ERROR_INVALID_SEQUENCE;
-    }
-
-    pahw->Stop(StreamId);
-    _allNotesOff();
-    pControl->ulTime = GetCurrentTime();
-    ulStreamState = STREAM_PAUSED;
-    return NO_ERROR;
+        //dprintf(("MIDISTREAM::PauseStream %lx %lx", (void far *)this, StreamId));
+        if (ulStreamState == STREAM_PAUSED) {   // is the stream paused?
+                DebugInt3();
+                return ERROR_INVALID_SEQUENCE;
+        }
+
+        pahw->Stop(StreamId);
+        _allNotesOff();
+        pControl->ulTime = GetCurrentTime();
+        ulStreamState = STREAM_PAUSED;
+        return NO_ERROR;
 }
 //******************************************************************************
@@ -239 +239 @@
 ULONG  MIDISTREAM::ResumeStream(void)
 {
-//    dprintf(("MIDISTREAM::ResumeStream %lx %lx", (void far *)this, StreamId));
-    if (ulStreamState != STREAM_PAUSED) {   // is the stream paused?
-        DebugInt3();
-        return ERROR_INVALID_SEQUENCE;
-    }
-
-    state = S_Init;                        // Reset parser state.
-    message.clear();                       // Clear current message.
-    pahw->getTimer()->vSetTime(ulCurrentTime);
-    pahw->Start(StreamId);
-    pahw->SetVolume(StreamId, getMixerStreamId(), volume);
-    ulStreamState = STREAM_STREAMING;
-    return NO_ERROR;
+        //dprintf(("MIDISTREAM::ResumeStream %lx %lx", (void far *)this, StreamId));
+        if (ulStreamState != STREAM_PAUSED) {   // is the stream paused?
+                DebugInt3();
+                return ERROR_INVALID_SEQUENCE;
+        }
+
+        state = S_Init;                                            // Reset parser state.
+        message.clear();                                           // Clear current message.
+        pahw->getTimer()->vSetTime(ulCurrentTime);
+        pahw->Start(StreamId);
+        pahw->SetVolume(StreamId, getMixerStreamId(), volume);
+        ulStreamState = STREAM_STREAMING;
+        return NO_ERROR;
 }
 //******************************************************************************
@@ -257 +257 @@
 BOOL MIDISTREAM::SetProperty(int type, ULONG value, ULONG reserved)
 {
-    switch(type) {
-    case PROPERTY_VOLUME:
-        volume = value; 
-        if(ulStreamState == STREAM_STREAMING) {
-           pahw->SetVolume(StreamId, getMixerStreamId(), volume);
-        }
-        break;
-
-    default:
-        return STREAM::SetProperty(type, value, reserved);
-    }
-    return TRUE;
+        switch(type) {
+        case PROPERTY_VOLUME:
+                volume = value;
+                if(ulStreamState == STREAM_STREAMING) {
+                   pahw->SetVolume(StreamId, getMixerStreamId(), volume);
+                }
+                break;
+
+        default:
+                return STREAM::SetProperty(type, value, reserved);
+        }
+        return TRUE;
 }
 //******************************************************************************
@@ -275 +275 @@
    STREAM(streamtype, filesysnum, mixerStreamId)
 {
-//    dprintf(("MIDISTREAM::ctor"));
-
-    // get the pointer to the hardware object
-    pahw = (MIDIAUDIO *)GetHardwareDevice(streamtype);
-    if(pahw) {
-        if(pahw->Open(0, streamtype, filesysnum, &StreamId) == FALSE) {
-//            dprintf(("MIDISTREAM ctor: open failed!!"));
-            DebugInt3();
-        }
-    }
-    else DebugInt3();
-
-    // Initialize tempo & scheduling information.
-    ulTempo = 1200;
-    usCPQN = 0;
-    CalcDelay();
-    lWait = 0;
-    _ulLastProcess = 0;
-
-    // Reset the parser.
-    state = S_Init;
-    message.clear();
-
-    // Reset our tracking of which notes are currently on.
-    for (int i=0; i<NUM_MidiNotes; ++i)
-        _notesOn[ i ] = 0;
+        //dprintf(("MIDISTREAM::ctor"));
+
+        // get the pointer to the hardware object
+        pahw = (MIDIAUDIO *)GetHardwareDevice(streamtype);
+        if(pahw) {
+                if(pahw->Open(0, streamtype, filesysnum, &StreamId) == FALSE) {
+//                        dprintf(("MIDISTREAM ctor: open failed!!"));
+                        DebugInt3();
+                }
+        }
+        else DebugInt3();
+
+        // Initialize tempo & scheduling information.
+        ulTempo = 1200;
+        usCPQN = 0;
+        CalcDelay();
+        lWait = 0;
+        _ulLastProcess = 0;
+
+        // Reset the parser.
+        state = S_Init;
+        message.clear();
+
+        // Reset our tracking of which notes are currently on.
+        for (int i=0; i<NUM_MidiNotes; ++i)
+                _notesOn[ i ] = 0;
 }
 //******************************************************************************
@@ -306 +306 @@
 MIDISTREAM::~MIDISTREAM()
 {
-    if(StreamId && pahw) {
-        pahw->Close(StreamId);
-    }
-}
-//******************************************************************************
-//******************************************************************************
-
+        if(StreamId && pahw) {
+                pahw->Close(StreamId);
+        }
+}
+//******************************************************************************
+//******************************************************************************
+

OCO/trunk/drv16/mixer.cpp

@@ -116 +116 @@
         if(DevHelp_VerifyAccess(SELECTOROF(pMixStruct), sizeof(MIXSTRUCT), OFFSETOF(pMixStruct), VERIFY_READWRITE))
         {
-            dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
+            rprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
             prp->usStatus |= RPERR | RPBADCMD;
             return;
@@ -144 +144 @@
         if(DevHelp_VerifyAccess(SELECTOROF(pMixStruct), sizeof(MIXSTRUCT), OFFSETOF(pMixStruct), VERIFY_READONLY))
         {
-            dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
+            rprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
             prp->usStatus |= RPERR | RPBADCMD;
             return;
@@ -192 +192 @@
             //  case I90SRC_RES6:
             default:
-                dprintf(("IoctlMixer: Unk VolL:%lx", (ULONG)pMixStruct->VolumeL));
+                rprintf(("IoctlMixer: Unk VolL:%lx", (ULONG)pMixStruct->VolumeL));
                 break;
             }
@@ -253 +253 @@
         if(DevHelp_VerifyAccess(SELECTOROF(pIoctlData), sizeof(ULONG), OFFSETOF(pIoctlData), VERIFY_READWRITE))
         {
-            dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pIoctlData));
+            rprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pIoctlData));
             prp->usStatus |= RPERR | RPBADCMD;
             return;
@@ -263 +263 @@
         if(DevHelp_VerifyAccess(SELECTOROF(pIoctlMap), sizeof(ALSAIOCTLMap), OFFSETOF(pIoctlMap), VERIFY_READWRITE))
         {
-            dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
+            rprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pMixStruct));
             prp->usStatus |= RPERR | RPBADCMD;
             return;
@@ -277 +277 @@
         if(DevHelp_VerifyAccess(SELECTOROF(pIoctlData), sizeof(ULONG), OFFSETOF(pIoctlData), VERIFY_READONLY))
         {
-            dprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pIoctlData));
+            rprintf(("Invalid IOCTL90 pointer %lx!!", (ULONG)pIoctlData));
             prp->usStatus |= RPERR | RPBADCMD;
             return;
@@ -286 +286 @@
         if(hMixerNotifySem != 0) {
             if(DevHelp_OpenEventSem(hMixerNotifySem) != 0) {
-                dprintf(("CALLBACKREG: DevHlp_OpenEventSem %lx failed!", hMixerNotifySem));
+                rprintf(("CALLBACKREG: DevHlp_OpenEventSem %lx failed!", hMixerNotifySem));
                 prp->usStatus |= RPERR | RPBADCMD;
                 return;
@@ -294 +294 @@
         if(oldsem) {
             if(DevHelp_CloseEventSem(oldsem) != 0) {
-                dprintf(("CALLBACKREG: DevHlp_OpenEventSem %lx failed!", oldsem));
+                rprintf(("CALLBACKREG: DevHlp_OpenEventSem %lx failed!", oldsem));
                 prp->usStatus |= RPERR | RPBADCMD;
                 return;
@@ -304 +304 @@
 //   case MSGBUF:
     default:
-        dprintf(("IoctlMixer: bad code:%lx", (ULONG)prp->s.ioctl.bCode));
+        rprintf(("IoctlMixer: bad code:%lx", (ULONG)prp->s.ioctl.bCode));
         prp->usStatus |= RPERR | RPBADCMD;
         return;
@@ -317 +317 @@
         fSetWaveVolume = FALSE;
         //if per-stream volume not supported, change PCM volume instead
+        //dprintf(("Setting PCM volume instead"));
         return MixerSetVolume(mixerStreamId, OSS32_MIX_VOLUME_PCM, Volume, fFlags);
     }
@@ -358 +359 @@
 
     if(OSS16_MixSetVolume(mixerStreamId, (USHORT)ulControl, ulVolume) != OSSERR_SUCCESS) {
-        dprintf(("MixerSetVolume: OSS16_MixSetVolume failed!!"));
+        rprintf(("MixerSetVolume: OSS16_MixSetVolume failed!!"));
         return FALSE;
     }
@@ -506 +507 @@
 
     if(OSS16_MixSetProperty(mixerStreamId, (USHORT)ulControl, ulALSAValue) != OSSERR_SUCCESS) {
-        dprintf(("MixerSetProperty: OSS16_MixSetProperty failed!!"));
+        rprintf(("MixerSetProperty: OSS16_MixSetProperty failed!!"));
         return FALSE;
     }
@@ -592 +593 @@
         rc = DevHelp_PostEventSem(hMixerNotifySem);
         if(rc != 0) {
-            dprintf(("MixerNotifyChange: DevHlp_PostEventSem returned %d", rc));
+            rprintf(("MixerNotifyChange: DevHlp_PostEventSem returned %d", rc));
         }
         rc = DevHelp_VirtToLin(SELECTOROF(pNumPosts), OFFSETOF(pNumPosts), &linaddr);
@@ -602 +603 @@
         rc = DevHelp_ResetEventSem(hMixerNotifySem, linaddr);
         if(rc != 0) {
-            dprintf(("MixerNotifyChange: DevHelp_ResetEventSem returned %d", rc));
+            rprintf(("MixerNotifyChange: DevHelp_ResetEventSem returned %d", rc));
         }
     }
@@ -651 +652 @@
     }
     if(mixcaps.fuCtrlCaps & OSS32_MIX_FLAG(OSS32_MIX_VOLUME_MIDI)) {
-                dprintf(("MixerInit: MIX_VOLUME_MIDI not processed"));
+                rprintf(("MixerInit: MIX_VOLUME_MIDI not processed"));
     }
     if(mixcaps.fuCtrlCaps & OSS32_MIX_FLAG(OSS32_MIX_VOLUME_LINEIN)) {
@@ -729 +730 @@
         mixinfo.VolumeR = mixinfo.VolumeL = 80;
         IoctlMixer(&rp, LDev);
-//              dprintf(("MixerInit: MIX_VOLUME_HEADPHONE not processed"));
+                //dprintf(("MixerInit: MIX_VOLUME_HEADPHONE not processed"));
     }
     if(mixcaps.fuCtrlCaps & OSS32_MIX_FLAG(OSS32_MIX_VOLUME_AUX)) {

OCO/trunk/drv16/mpu401.cpp

@@ -61 +61 @@
    strcpy( szRTMIDI_Name, szName );    // Setup instance name.
    strcat( szRTMIDI_Name, szSuffix );  // Append ASCII number to instance name.
-//   dprintf(("rtmidi name [%s]",szRTMIDI_Name));
+        //dprintf(("rtmidi name [%s]",szRTMIDI_Name));
    ulRTMIDI_Caps = MIDICAPSA_INPUT | MIDICAPSA_OUTPUT;    // Set RTMIDI caps.
    midiOutStreamId = 0;
@@ -72 +72 @@
 {
 //    dprintf(("MPU_401::open"));
-    if(midiOutStreamId == 0) 
+    if(midiOutStreamId == 0)
     {
         //vladest        if(OSS16_MidiOpen(OSS32_DEFAULT_MPU401_DEVICE, MPU401_SEND, pStreamId) != OSSERR_SUCCESS)

OCO/trunk/drv16/ossidc16.cpp

@@ -5 +5 @@
  */
 
-extern "C" {               // 16-bit header files are not C++ aware
+extern "C" {                       // 16-bit header files are not C++ aware
 #define  INCL_16
 #define  INCL_DOSINFOSEG
@@ -33 +33 @@
 
 void DumpDeviceCaps (LPOSS32_DEVCAPS pDevCaps);
-void DumpWaveCaps   (LPWAVE_CAPS pWaveCaps);
-void DumpMixerCaps  (LPOSS32_MIXCAPS pMixCaps);
+void DumpWaveCaps       (LPWAVE_CAPS pWaveCaps);
+void DumpMixerCaps      (LPOSS32_MIXCAPS pMixCaps);
 #endif
 
@@ -56 +56 @@
    // Attach to the 32 bits OSS driver
    if(DevHelp_AttachDD((NPSZ)"ALSA32$ ",(NPBYTE)&IDCTable)) {
-      return FALSE;
+          return FALSE;
    }
    idcpacket.init.handler16 = (ULONG)(VOID FAR *)OSSIDC_ENTRY;
@@ -77 +77 @@
    IDC32_PACKET  idcpacket;
    OSS32_DEVCAPS devcaps;
-   OSSRET        ret;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-   idcpacket.fileid           = 0x666;
+   OSSRET                ret;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+   idcpacket.fileid               = 0x666;
    idcpacket.devcaps.devicenr = devicenr;
    idcpacket.devcaps.pDevCaps = (ULONG)&devcaps;
@@ -87 +87 @@
 
 #ifdef DEBUG
-    if (ret == OSSERR_SUCCESS)
-        DumpDeviceCaps (&devcaps);
-    else
-        dprintf (("IDC32_OSS32_QUERYDEVCAPS - FAILED!"));
+        if (ret == OSSERR_SUCCESS)
+                DumpDeviceCaps (&devcaps);
+        else
+                dprintf (("IDC32_OSS32_QUERYDEVCAPS - FAILED!"));
 #endif
 
@@ -123 +123 @@
 {
    IDC32_PACKET idcpacket;
-   OSSRET       ret;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-   idcpacket.fileid          = ulSysFileNum;
-   idcpacket.open.devicenr   = devicenr;
+   OSSRET               ret;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+   idcpacket.fileid              = ulSysFileNum;
+   idcpacket.open.devicenr       = devicenr;
    idcpacket.open.streamtype = (ulStreamType == STREAM_WAVE_PLAY) ? OSS32_STREAM_WAVEOUT : OSS32_STREAM_WAVEIN;
    ret = CallOSS32(IDC32_WAVE_OPEN, &idcpacket);
@@ -216 +216 @@
    if(SELECTOROF(pHwParams) != _SS())
    {//must be located on the stack!
-       dprintf(("OSS16_WaveSetFormat error. Invalid stack segment for parameters..."));
-       DebugInt3();
-       return OSSERR_INVALID_PARAMETER;
+           dprintf(("OSS16_WaveSetFormat error. Invalid stack segment for parameters..."));
+           DebugInt3();
+           return OSSERR_INVALID_PARAMETER;
    }
 
-   idcpacket.fileid               = FindStreamFileId_fromStreamId(StreamId);
-   idcpacket.streamid             = StreamId;
+   idcpacket.fileid                       = FindStreamFileId_fromStreamId(StreamId);
+   idcpacket.streamid                     = StreamId;
    idcpacket.sethwparams.hwparams = (ULONG)pHwParams;
    return CallOSS32(IDC32_WAVE_SETHWPARAMS, &idcpacket);
@@ -229 +229 @@
 //******************************************************************************
 OSSRET DBGCALLCONV OSS16_WaveAddBuffer(OSSSTREAMID StreamId, LINEAR pBuffer, ULONG size,
-                                       ULONG FAR *lpBytesTransferred)
-{
-   IDC32_PACKET idcpacket;
-   OSSRET       ret;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
-   idcpacket.streamid      = StreamId;
+                                                                           ULONG FAR *lpBytesTransferred)
+{
+   IDC32_PACKET idcpacket;
+   OSSRET               ret;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
+   idcpacket.streamid      = StreamId;
    idcpacket.buffer.buffer = pBuffer;
    idcpacket.buffer.size   = size;
@@ -250 +250 @@
 {
    IDC32_PACKET idcpacket;
-   OSSRET       ret;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
-   idcpacket.streamid      = StreamId;
+   OSSRET               ret;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
+   idcpacket.streamid      = StreamId;
    ret =  CallOSS32(IDC32_WAVE_GETPOS, &idcpacket);
 
@@ -266 +266 @@
 {
    IDC32_PACKET idcpacket;
-   OSSRET       ret;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
-   idcpacket.streamid      = StreamId;
+   OSSRET               ret;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
+   idcpacket.streamid      = StreamId;
    ret =  CallOSS32(IDC32_WAVE_GETSPACE, &idcpacket);
 
@@ -282 +282 @@
 {
    IDC32_PACKET idcpacket;
-   OSSRET       ret;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
-   idcpacket.streamid      = StreamId;
+   OSSRET               ret;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
+   idcpacket.streamid      = StreamId;
    ret =  CallOSS32(IDC32_WAVE_GETHWPTR, &idcpacket);
 
@@ -298 +298 @@
 {
    IDC32_PACKET idcpacket;
-   OSSRET       ret;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
-   idcpacket.streamid      = StreamId;
+   OSSRET               ret;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+   idcpacket.fileid        = FindStreamFileId_fromStreamId(StreamId);
+   idcpacket.streamid      = StreamId;
    ret =  CallOSS32(IDC32_WAVE_GETSTATUS, &idcpacket);
 
@@ -317 +317 @@
    _fmemset(&idcpacket, 0, sizeof(idcpacket));
 
-   idcpacket.fileid            = FindStreamFileId_fromStreamId(StreamId);
-   idcpacket.streamid          = StreamId;
+   idcpacket.fileid                = FindStreamFileId_fromStreamId(StreamId);
+   idcpacket.streamid              = StreamId;
    idcpacket.setwavevol.volume = volume;
    return CallOSS32(IDC32_WAVE_SETVOLUME, &idcpacket);
@@ -327 +327 @@
 {
    IDC32_PACKET idcpacket;
-   OSSRET       ret;
+   OSSRET               ret;
 
    dprintf(("OSS16_MidiOpen. type: %d",midiType));
    _fmemset(&idcpacket, 0, sizeof(idcpacket));
 
-   idcpacket.fileid          = 0x666;  //TODO
-   idcpacket.open.devicenr   = devicenr;
+   idcpacket.fileid              = 0x666;  //TODO
+   idcpacket.open.devicenr       = devicenr;
    switch(midiType) {
    case MPU401_RECEIVE:
-       idcpacket.open.streamtype = OSS32_STREAM_MPU401_MIDIIN;
-       break;
+           idcpacket.open.streamtype = OSS32_STREAM_MPU401_MIDIIN;
+           break;
    case MPU401_SEND:
-       idcpacket.open.streamtype = OSS32_STREAM_MPU401_MIDIOUT;
-       break;
+           idcpacket.open.streamtype = OSS32_STREAM_MPU401_MIDIOUT;
+           break;
    case FM_SEND:
-       idcpacket.open.streamtype = OSS32_STREAM_FM_MIDIOUT;
-       break;
+           idcpacket.open.streamtype = OSS32_STREAM_FM_MIDIOUT;
+           break;
    case WAVETABLE_SEND:
-       idcpacket.open.streamtype = OSS32_STREAM_WAVETABLE_MIDIOUT;
-       break;
+           idcpacket.open.streamtype = OSS32_STREAM_WAVETABLE_MIDIOUT;
+           break;
    }
    ret = CallOSS32(IDC32_MIDI_OPEN, &idcpacket);
@@ -361 +361 @@
    _fmemset(&idcpacket, 0, sizeof(idcpacket));
 
-   idcpacket.fileid             = 0x666;  //TODO
-   idcpacket.streamid           = StreamId;
+   idcpacket.fileid                     = 0x666;  //TODO
+   idcpacket.streamid                   = StreamId;
    idcpacket.midiwrite.midiByte = midiByte;
    return CallOSS32(IDC32_MIDI_WRITE, &idcpacket);
@@ -371 +371 @@
 {
    IDC32_PACKET idcpacket;
-   OSSRET       ret;
-
-//   dprintf(("OSS16_MidiRead. id: %d",StreamId));
+   OSSRET               ret;
+
+//       dprintf(("OSS16_MidiRead. id: %d",StreamId));
    _fmemset(&idcpacket, 0, sizeof(idcpacket));
 
    if(SELECTOROF(buffer) != _SS())
    {//must be located on the stack!
-       DebugInt3();
-       return OSSERR_INVALID_PARAMETER;
+           DebugInt3();
+           return OSSERR_INVALID_PARAMETER;
    }
 
-   idcpacket.fileid           = 0x666;  //TODO
-   idcpacket.streamid         = StreamId;
+   idcpacket.fileid               = 0x666;      //TODO
+   idcpacket.streamid             = StreamId;
    idcpacket.midiread.buffer  = (ULONG)buffer;
    idcpacket.midiread.bufsize = bufsize;
@@ -397 +397 @@
    IDC32_PACKET   idcpacket;
    OSS32_MIDICAPS midiCaps;
-   OSSRET         ret;
+   OSSRET                 ret;
 
    dprintf(("OSS16_MidiQueryCaps. id: %d",streamid));
@@ -530 +530 @@
 {
    IDC32_PACKET idcpacket;
-   OSSRET       ret;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-   idcpacket.fileid          = 0x766;  //TODO
-   idcpacket.open.devicenr   = devicenr;
+   OSSRET               ret;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+   idcpacket.fileid              = 0x766;  //TODO
+   idcpacket.open.devicenr       = devicenr;
    ret = CallOSS32(IDC32_MIXER_OPEN, &idcpacket);
    *pStreamId = idcpacket.streamid;
@@ -560 +560 @@
    _fmemset(&idcpacket, 0, sizeof(idcpacket));
 
-   idcpacket.fileid        = 0x766;  //TODO
-   idcpacket.streamid      = StreamId;
+   idcpacket.fileid        = 0x766;  //TODO
+   idcpacket.streamid      = StreamId;
    idcpacket.mixvol.line   = usLine;
    idcpacket.mixvol.volume = ulVolume;
@@ -572 +572 @@
 {
    IDC32_PACKET idcpacket;
-   OSSRET       ret;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-   idcpacket.fileid        = 0x766;  //TODO
-   idcpacket.streamid      = StreamId;
+   OSSRET               ret;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+   idcpacket.fileid        = 0x766;  //TODO
+   idcpacket.streamid      = StreamId;
    idcpacket.mixvol.line   = usLine;
 
@@ -592 +592 @@
    _fmemset(&idcpacket, 0, sizeof(idcpacket));
 
-   idcpacket.fileid           = 0x766;  //TODO
-   idcpacket.streamid         = StreamId;
+   idcpacket.fileid               = 0x766;      //TODO
+   idcpacket.streamid             = StreamId;
    idcpacket.mixprop.property = usProperty;
-   idcpacket.mixprop.value    = ulValue;
+   idcpacket.mixprop.value        = ulValue;
 
    return CallOSS32(IDC32_MIXER_SETPROPERTY, &idcpacket);
@@ -603 +603 @@
 OSSRET DBGCALLCONV OSS16_MixGetProperty(OSSSTREAMID StreamId, USHORT usProperty, ULONG FAR *pValue)
 {
-    IDC32_PACKET idcpacket;
-    OSSRET       ret;
-
-    _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-    idcpacket.fileid           = 0x766;  //TODO
-    idcpacket.streamid         = StreamId;
-    idcpacket.mixprop.property = usProperty;
-
-    ret = CallOSS32(IDC32_MIXER_GETPROPERTY, &idcpacket);
-    *pValue = idcpacket.mixprop.value;
-    return ret;
+        IDC32_PACKET idcpacket;
+        OSSRET           ret;
+
+        _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+        idcpacket.fileid                   = 0x766;  //TODO
+        idcpacket.streamid                 = StreamId;
+        idcpacket.mixprop.property = usProperty;
+
+        ret = CallOSS32(IDC32_MIXER_GETPROPERTY, &idcpacket);
+        *pValue = idcpacket.mixprop.value;
+        return ret;
 }
 //******************************************************************************
@@ -620 +620 @@
 OSSRET DBGCALLCONV OSS16_MixQueryCaps(OSSSTREAMID Streamid, OSS32_MIXCAPS FAR *pCaps)
 {
-    IDC32_PACKET    idcpacket;
-    OSS32_MIXCAPS mixerCaps;
-    OSSRET          ret;
-
-    _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-    idcpacket.fileid   = 0x766; //TODO
-    idcpacket.streamid = Streamid;
-    idcpacket.mixcaps.pCaps = (ULONG)&mixerCaps;
-    ret = CallOSS32(IDC32_MIXER_QUERYCAPS, &idcpacket);
+        IDC32_PACKET    idcpacket;
+        OSS32_MIXCAPS mixerCaps;
+        OSSRET                  ret;
+
+        _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+        idcpacket.fileid   = 0x766; //TODO
+        idcpacket.streamid = Streamid;
+        idcpacket.mixcaps.pCaps = (ULONG)&mixerCaps;
+        ret = CallOSS32(IDC32_MIXER_QUERYCAPS, &idcpacket);
 
 #ifdef DEBUG
-    if (ret == OSSERR_SUCCESS)
-        DumpMixerCaps (&mixerCaps);
-    else
-        dprintf (("IDC32_MIXER_QUERYCAPS - FAILED!"));
+        if (ret == OSSERR_SUCCESS)
+                DumpMixerCaps (&mixerCaps);
+        else
+                dprintf (("IDC32_MIXER_QUERYCAPS - FAILED!"));
 #endif
 
-    _fmemcpy(pCaps, &mixerCaps, sizeof(mixerCaps));
-    return ret;
+        _fmemcpy(pCaps, &mixerCaps, sizeof(mixerCaps));
+        return ret;
 }
 //******************************************************************************
@@ -646 +646 @@
 OSSRET CallOSS32(USHORT cmd, IDC32_PACKET FAR *pIDCPacket)
 {
-    ULONG rc = 0;
-    ULONG idcptr  = (ULONG)IDCTable.ProtIDCEntry;
-    ULONG idcparm;
-
-    if(idcptr == 0)
-            return OSSERR_ACCESS_DENIED;
-
-    if(SELECTOROF(pIDCPacket) != _SS()) {
-       dprintf(("CallOSS32 error. Invalid stack segment for parameters..."));
-       DebugInt3();
-       return OSSERR_INVALID_PARAMETER;
-    }
-
-//    dprintf(("CallOSS32. cmd: %d", cmd));
-
-    idcparm = (ULONG)pIDCPacket;
-
-    _asm {
-            pusha
-            mov  cx, cmd
-            mov  dx, word ptr [idcparm+2]
-            mov  bx, word ptr [idcparm]
-            call dword ptr [idcptr]
-            mov  word ptr rc, ax
-            mov  word ptr [rc+2], dx
-            popa
-    }
-    return(rc);
+        ULONG rc = 0;
+        ULONG idcptr  = (ULONG)IDCTable.ProtIDCEntry;
+        ULONG idcparm;
+
+        if(idcptr == 0)
+                return OSSERR_ACCESS_DENIED;
+
+        if(SELECTOROF(pIDCPacket) != _SS()) {
+           dprintf(("CallOSS32 error. Invalid stack segment for parameters..."));
+           DebugInt3();
+           return OSSERR_INVALID_PARAMETER;
+        }
+
+//        dprintf(("CallOSS32. cmd: %d", cmd));
+
+        idcparm = (ULONG)pIDCPacket;
+
+        _asm {
+                pusha
+                mov  cx, cmd
+                mov  dx, word ptr [idcparm+2]
+                mov  bx, word ptr [idcparm]
+                call dword ptr [idcptr]
+                mov  word ptr rc, ax
+                mov  word ptr [rc+2], dx
+                popa
+        }
+        return(rc);
 }
 //******************************************************************************
@@ -683 +683 @@
 {
    IDC32_PACKET idcpacket;
-   ULONG        buffer;
-
-   _fmemset(&idcpacket, 0, sizeof(idcpacket));
-
-    if (DevHelp_VirtToLin(SELECTOROF(debstr),OFFSETOF(debstr),&buffer))
-        return OSSERR_INVALID_PARAMETER;
-
-
-   idcpacket.buffer.buffer  = (ULONG)buffer;
+   ULONG                buffer;
+
+   _fmemset(&idcpacket, 0, sizeof(idcpacket));
+
+        if (DevHelp_VirtToLin(SELECTOROF(debstr),OFFSETOF(debstr),&buffer))
+                return OSSERR_INVALID_PARAMETER;
+
+
+   idcpacket.buffer.buffer      = (ULONG)buffer;
    idcpacket.buffer.size = bufsize;
    return CallOSS32(IDC32_DEBUG_STRING, &idcpacket);
@@ -704 +704 @@
 #pragma on (unreferenced)
 {
-    //dprintf(("OSSIDC cmd:%lx param1:%lx param2:%lx", cmd, param1, param2));
-    switch(cmd & 0xFFFF)
-    {
-    case IDC16_INIT:
-            break;
-
-    case IDC16_EXIT:
-        DestroyStreams();
-            IDCTable.ProtIDCEntry = 0;
-            break;
-    case IDC16_MIDI_IRQ:
-        MPU_401::processIrq(0);
-        break;
-
-    case IDC16_CLOSE_UNI16:
-        {
-            force_closed = 1;
-#ifdef DEBUG
-            dprintf(("IDC16_CLOSE_UNI16"));
-#endif
-            pWavePlay->Close(0);
-            //WAVEAUDIO::WavePlayClose();
-            break;
-        }
-    case IDC16_PROCESS:
-    {
-        PWAVESTREAM pStream;
+        //dprintf(("OSSIDC cmd:%lx param1:%lx param2:%lx", cmd, param1, param2));
+        switch(cmd & 0xFFFF)
+        {
+        case IDC16_INIT:
+                break;
+
+        case IDC16_EXIT:
+                DestroyStreams();
+                IDCTable.ProtIDCEntry = 0;
+                        break;
+        case IDC16_MIDI_IRQ:
+                MPU_401::processIrq(0);
+                break;
+
+        case IDC16_CLOSE_UNI16:
+                {
+                        force_closed = 1;
+                        dprintf(("IDC16_CLOSE_UNI16"));
+                        pWavePlay->Close(0);
+                        //WAVEAUDIO::WavePlayClose();
+                        break;
+                }
+        case IDC16_PROCESS:
+        {
+                PWAVESTREAM pStream;
                 //dprintf(("IDC16_PROCESS, %d", param1));
-        //Signal all active wave playback streams to update their status
-            pStream = (PWAVESTREAM)FindFirstActiveStream(STREAM_WAVE_PLAY);
-            while(pStream)
-           {
-                pStream->Process();
-               pStream = (PWAVESTREAM)FindNextActiveStream(STREAM_WAVE_PLAY, pStream);
-           }
-           //Signal all active wave capture streams to update their status
-           pStream = (PWAVESTREAM)FindFirstActiveStream(STREAM_WAVE_CAPTURE);
-           while(pStream)
-           {
-                 pStream->Process();
-                 pStream = (PWAVESTREAM)FindNextActiveStream(STREAM_WAVE_CAPTURE, pStream);
-           }
-                        //dprintf(("IDC16_PROCESS end"));
-           break;
-    }
-
-    }
-    return 0;
+                //Signal all active wave playback streams to update their status
+                pStream = (PWAVESTREAM)FindFirstActiveStream(STREAM_WAVE_PLAY);
+                while(pStream) {
+                        pStream->Process();
+                        pStream = (PWAVESTREAM)FindNextActiveStream(STREAM_WAVE_PLAY, pStream);
+                }
+                //Signal all active wave capture streams to update their status
+                pStream = (PWAVESTREAM)FindFirstActiveStream(STREAM_WAVE_CAPTURE);
+                while(pStream) {
+                        pStream->Process();
+                        pStream = (PWAVESTREAM)FindNextActiveStream(STREAM_WAVE_CAPTURE, pStream);
+                }
+                //dprintf(("IDC16_PROCESS end"));
+                break;
+        }
+
+        }
+        return 0;
 }
 //******************************************************************************
@@ -760 +756 @@
 void DumpMixerCaps (LPOSS32_MIXCAPS pMixCaps)
 {
-    dprintf (("\nMixerCaps"));
-    dprintf (("  name       '%s'", pMixCaps->name));
-    dprintf (("  fuCtrlCaps %lxh", pMixCaps->fuCtrlCaps));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_MASTER_FRONT))
-        dprintf (("             OSS32_MIX_VOLUME_MASTER_FRONT"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_MASTER_REAR))
-        dprintf (("             OSS32_MIX_VOLUME_MASTER_REAR"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_PCM))
-        dprintf (("             OSS32_MIX_VOLUME_PCM"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_MIDI))
-        dprintf (("             OSS32_MIX_VOLUME_MIDI"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_LINEIN))
-        dprintf (("             OSS32_MIX_VOLUME_LINEIN"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_MIC))
-        dprintf (("             OSS32_MIX_VOLUME_MIC"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_CD))
-        dprintf (("             OSS32_MIX_VOLUME_CD"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_SPDIF))
-        dprintf (("             OSS32_MIX_VOLUME_SPDIF"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_VIDEO))
-        dprintf (("             OSS32_MIX_VOLUME_VIDEO"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_SPEAKER))
-        dprintf (("             OSS32_MIX_VOLUME_SPEAKER"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_PHONE))
-        dprintf (("             OSS32_MIX_VOLUME_PHONE"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_HEADPHONE))
-        dprintf (("             OSS32_MIX_VOLUME_HEADPHONE"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_AUX))
-        dprintf (("             OSS32_MIX_VOLUME_AUX"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_CAPTURE))
-        dprintf (("             OSS32_MIX_VOLUME_CAPTURE"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_INPUTSRC))
-        dprintf (("             OSS32_MIX_INPUTSRC"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_LEVEL_BASS))
-        dprintf (("             OSS32_MIX_LEVEL_BASS"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_LEVEL_TREBLE))
-        dprintf (("             OSS32_MIX_LEVEL_TREBLE"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_LEVEL_3DCENTER))
-        dprintf (("             OSS32_MIX_LEVEL_3DCENTER"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_LEVEL_3DDEPTH))
-        dprintf (("             OSS32_MIX_LEVEL_3DDEPTH"));
-    if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_SWITCH_MICBOOST))
-        dprintf (("             OSS32_MIX_SWITCH_MICBOOST"));
-
-
-    dprintf (("  fuRecCaps  %lxh", pMixCaps->fuRecCaps));
-    if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_MIC))
-        dprintf (("             OSS32_MIX_RECSRC_MIC"));
-    if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_CD))
-        dprintf (("             OSS32_MIX_RECSRC_CD"));
-    if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_LINE))
-        dprintf (("             OSS32_MIX_RECSRC_LINE"));
-    if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_VIDEO))
-        dprintf (("             OSS32_MIX_RECSRC_VIDEO"));
-    if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_AUX))
-        dprintf (("             OSS32_MIX_RECSRC_AUX"));
-    if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_MIXER))
-        dprintf (("             OSS32_MIX_RECSRC_MIXER"));
-    if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_MIXER_MONO))
-        dprintf (("             OSS32_MIX_RECSRC_MIXER_MONO"));
-    if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_PHONE))
-        dprintf (("             OSS32_MIX_RECSRC_PHONE"));
-    if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_SYNTH))
-        dprintf (("             OSS32_MIX_RECSRC_SYNTH"));
+        dprintf (("\nMixerCaps"));
+        dprintf (("  name       '%s'", pMixCaps->name));
+        dprintf (("  fuCtrlCaps %lxh", pMixCaps->fuCtrlCaps));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_MASTER_FRONT))
+                dprintf (("             OSS32_MIX_VOLUME_MASTER_FRONT"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_MASTER_REAR))
+                dprintf (("             OSS32_MIX_VOLUME_MASTER_REAR"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_PCM))
+                dprintf (("             OSS32_MIX_VOLUME_PCM"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_MIDI))
+                dprintf (("             OSS32_MIX_VOLUME_MIDI"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_LINEIN))
+                dprintf (("             OSS32_MIX_VOLUME_LINEIN"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_MIC))
+                dprintf (("             OSS32_MIX_VOLUME_MIC"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_CD))
+                dprintf (("             OSS32_MIX_VOLUME_CD"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_SPDIF))
+                dprintf (("             OSS32_MIX_VOLUME_SPDIF"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_VIDEO))
+                dprintf (("             OSS32_MIX_VOLUME_VIDEO"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_SPEAKER))
+                dprintf (("             OSS32_MIX_VOLUME_SPEAKER"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_PHONE))
+                dprintf (("             OSS32_MIX_VOLUME_PHONE"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_HEADPHONE))
+                dprintf (("             OSS32_MIX_VOLUME_HEADPHONE"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_AUX))
+                dprintf (("             OSS32_MIX_VOLUME_AUX"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_VOLUME_CAPTURE))
+                dprintf (("             OSS32_MIX_VOLUME_CAPTURE"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_INPUTSRC))
+                dprintf (("             OSS32_MIX_INPUTSRC"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_LEVEL_BASS))
+                dprintf (("             OSS32_MIX_LEVEL_BASS"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_LEVEL_TREBLE))
+                dprintf (("             OSS32_MIX_LEVEL_TREBLE"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_LEVEL_3DCENTER))
+                dprintf (("             OSS32_MIX_LEVEL_3DCENTER"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_LEVEL_3DDEPTH))
+                dprintf (("             OSS32_MIX_LEVEL_3DDEPTH"));
+        if (pMixCaps->fuCtrlCaps & OSS32_MIX_FLAG (OSS32_MIX_SWITCH_MICBOOST))
+                dprintf (("             OSS32_MIX_SWITCH_MICBOOST"));
+
+
+        dprintf (("  fuRecCaps  %lxh", pMixCaps->fuRecCaps));
+        if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_MIC))
+                dprintf (("             OSS32_MIX_RECSRC_MIC"));
+        if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_CD))
+                dprintf (("             OSS32_MIX_RECSRC_CD"));
+        if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_LINE))
+                dprintf (("             OSS32_MIX_RECSRC_LINE"));
+        if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_VIDEO))
+                dprintf (("             OSS32_MIX_RECSRC_VIDEO"));
+        if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_AUX))
+                dprintf (("             OSS32_MIX_RECSRC_AUX"));
+        if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_MIXER))
+                dprintf (("             OSS32_MIX_RECSRC_MIXER"));
+        if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_MIXER_MONO))
+                dprintf (("             OSS32_MIX_RECSRC_MIXER_MONO"));
+        if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_PHONE))
+                dprintf (("             OSS32_MIX_RECSRC_PHONE"));
+        if (pMixCaps->fuRecCaps & OSS32_MIX_FLAG (OSS32_MIX_RECSRC_SYNTH))
+                dprintf (("             OSS32_MIX_RECSRC_SYNTH"));
 }
 //******************************************************************************
@@ -829 +825 @@
 void DumpDeviceCaps (LPOSS32_DEVCAPS pDevCaps)
 {
-    dprintf (("\nDeviceCaps"));
-    dprintf (("  nrDevices     %d", pDevCaps->nrDevices));
-
-    dprintf (("  ulCaps        %uxh", pDevCaps->ulCaps));
-    if (pDevCaps->ulCaps & OSS32_CAPS_WAVE_PLAYBACK)
-        dprintf (("                OSS32_CAPS_WAVE_PLAYBACK"));
-    if (pDevCaps->ulCaps & OSS32_CAPS_WAVE_CAPTURE)
-        dprintf (("                OSS32_CAPS_WAVE_CAPTURE"));
-    if (pDevCaps->ulCaps & OSS32_CAPS_FMSYNTH_PLAYBACK)
-        dprintf (("                OSS32_CAPS_FMSYNTH_PLAYBACK"));
-    if (pDevCaps->ulCaps & OSS32_CAPS_WAVETABLE_PLAYBACK)
-        dprintf (("                OSS32_CAPS_WAVETABLE_PLAYBACK"));
-    if (pDevCaps->ulCaps & OSS32_CAPS_MPU401_PLAYBACK)
-        dprintf (("                OSS32_CAPS_MPU401_PLAYBACK"));
-    if (pDevCaps->ulCaps & OSS32_CAPS_MPU401_CAPTURE)
-        dprintf (("                OSS32_CAPS_MPU401_CAPTURE"));
-
-    dprintf (("  szDeviceName  %s", (char far*)pDevCaps->szDeviceName));
-    dprintf (("  szMixerName   %s", (char far*)pDevCaps->szMixerName));
-
-
-    dprintf (("WaveOutCaps"));
-    DumpWaveCaps (&pDevCaps->waveOutCaps);
-
-    dprintf (("WaveInCaps"));
-    DumpWaveCaps (&pDevCaps->waveInCaps);
+        dprintf (("\nDeviceCaps"));
+        dprintf (("  nrDevices     %d", pDevCaps->nrDevices));
+
+        dprintf (("  ulCaps        %uxh", pDevCaps->ulCaps));
+        if (pDevCaps->ulCaps & OSS32_CAPS_WAVE_PLAYBACK)
+                dprintf (("                OSS32_CAPS_WAVE_PLAYBACK"));
+        if (pDevCaps->ulCaps & OSS32_CAPS_WAVE_CAPTURE)
+                dprintf (("                OSS32_CAPS_WAVE_CAPTURE"));
+        if (pDevCaps->ulCaps & OSS32_CAPS_FMSYNTH_PLAYBACK)
+                dprintf (("                OSS32_CAPS_FMSYNTH_PLAYBACK"));
+        if (pDevCaps->ulCaps & OSS32_CAPS_WAVETABLE_PLAYBACK)
+                dprintf (("                OSS32_CAPS_WAVETABLE_PLAYBACK"));
+        if (pDevCaps->ulCaps & OSS32_CAPS_MPU401_PLAYBACK)
+                dprintf (("                OSS32_CAPS_MPU401_PLAYBACK"));
+        if (pDevCaps->ulCaps & OSS32_CAPS_MPU401_CAPTURE)
+                dprintf (("                OSS32_CAPS_MPU401_CAPTURE"));
+
+        dprintf (("  szDeviceName  %s", (char far*)pDevCaps->szDeviceName));
+        dprintf (("  szMixerName   %s", (char far*)pDevCaps->szMixerName));
+
+
+        dprintf (("WaveOutCaps"));
+        DumpWaveCaps (&pDevCaps->waveOutCaps);
+
+        dprintf (("WaveInCaps"));
+        DumpWaveCaps (&pDevCaps->waveInCaps);
 }
 //******************************************************************************
@@ -860 +856 @@
 void DumpWaveCaps (LPWAVE_CAPS pWaveCaps)
 {
-    dprintf (("  nrStreams     %d",   pWaveCaps->nrStreams));
-    dprintf (("  ulMinChannels %ld",   pWaveCaps->ulMinChannels));
-    dprintf (("  ulMaxChannels %ld",   pWaveCaps->ulMaxChannels));
-    dprintf (("  ulChanFlags   %lxh",  pWaveCaps->ulChanFlags));
-    if (pWaveCaps->ulChanFlags & OSS32_CAPS_PCM_CHAN_MONO)
-        dprintf (("                OSS32_CAPS_PCM_CHAN_MONO"));
-    if (pWaveCaps->ulChanFlags & OSS32_CAPS_PCM_CHAN_STEREO)
-        dprintf (("                OSS32_CAPS_PCM_CHAN_STEREO"));
-    if (pWaveCaps->ulChanFlags & OSS32_CAPS_PCM_CHAN_QUAD)
-        dprintf (("                OSS32_CAPS_PCM_CHAN_QUAD"));
-    if (pWaveCaps->ulChanFlags & OSS32_CAPS_PCM_CHAN_5_1)
-        dprintf (("                OSS32_CAPS_PCM_CHAN_5_1"));
-
-
-    dprintf (("  ulMinRate     %ld",   pWaveCaps->ulMinRate));
-    dprintf (("  ulMaxRate     %ld",   pWaveCaps->ulMaxRate));
-
-    dprintf (("  ulRateFlags   %lxh",  pWaveCaps->ulRateFlags));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_5512)
-        dprintf (("                OSS32_CAPS_PCM_RATE_5512"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_8000)
-        dprintf (("                OSS32_CAPS_PCM_RATE_8000"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_11025)
-        dprintf (("                OSS32_CAPS_PCM_RATE_11025"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_16000)
-        dprintf (("                OSS32_CAPS_PCM_RATE_16000"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_22050)
-        dprintf (("                OSS32_CAPS_PCM_RATE_22050"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_32000)
-        dprintf (("                OSS32_CAPS_PCM_RATE_32000"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_44100)
-        dprintf (("                OSS32_CAPS_PCM_RATE_44100"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_48000)
-        dprintf (("                OSS32_CAPS_PCM_RATE_48000"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_64000)
-        dprintf (("                OSS32_CAPS_PCM_RATE_64000"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_88200)
-        dprintf (("                OSS32_CAPS_PCM_RATE_88200"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_96000)
-        dprintf (("                OSS32_CAPS_PCM_RATE_96000"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_176400)
-        dprintf (("                OSS32_CAPS_PCM_RATE_176400"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_192000)
-        dprintf (("                OSS32_CAPS_PCM_RATE_192000"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_HALFDUPLEX)
-        dprintf (("                OSS32_CAPS_PCM_RATE_HALFDUPLEX"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_CONTINUOUS)
-        dprintf (("                OSS32_CAPS_PCM_RATE_CONTINUOUS"));
-    if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_KNOT)
-        dprintf (("                OSS32_CAPS_PCM_RATE_KNOT"));
-
-
-    dprintf (("  ulDataFormats %lxh",  pWaveCaps->ulDataFormats));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S8)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_S8"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_U8"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S16_LE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_S16_LE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S16_BE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_S16_BE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U16_LE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_U16_LE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U16_BE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_U16_BE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S24_LE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_S24_LE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S24_BE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_S24_BE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U24_LE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_U24_LE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U24_BE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_U24_BE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S32_LE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_S32_LE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S32_BE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_S32_BE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U32_LE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_U32_LE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U32_BE)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_U32_BE"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_MULAW)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_MULAW"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_ALAW)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_ALAW"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_ADPCM)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_ADPCM"));
-    if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_MPEG)
-        dprintf (("                OSS32_CAPS_PCM_FORMAT_MPEG"));
+        dprintf (("  nrStreams     %d",   pWaveCaps->nrStreams));
+        dprintf (("  ulMinChannels %ld",   pWaveCaps->ulMinChannels));
+        dprintf (("  ulMaxChannels %ld",   pWaveCaps->ulMaxChannels));
+        dprintf (("  ulChanFlags   %lxh",  pWaveCaps->ulChanFlags));
+        if (pWaveCaps->ulChanFlags & OSS32_CAPS_PCM_CHAN_MONO)
+                dprintf (("                OSS32_CAPS_PCM_CHAN_MONO"));
+        if (pWaveCaps->ulChanFlags & OSS32_CAPS_PCM_CHAN_STEREO)
+                dprintf (("                OSS32_CAPS_PCM_CHAN_STEREO"));
+        if (pWaveCaps->ulChanFlags & OSS32_CAPS_PCM_CHAN_QUAD)
+                dprintf (("                OSS32_CAPS_PCM_CHAN_QUAD"));
+        if (pWaveCaps->ulChanFlags & OSS32_CAPS_PCM_CHAN_5_1)
+                dprintf (("                OSS32_CAPS_PCM_CHAN_5_1"));
+
+
+        dprintf (("  ulMinRate     %ld",   pWaveCaps->ulMinRate));
+        dprintf (("  ulMaxRate     %ld",   pWaveCaps->ulMaxRate));
+
+        dprintf (("  ulRateFlags   %lxh",  pWaveCaps->ulRateFlags));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_5512)
+                dprintf (("                OSS32_CAPS_PCM_RATE_5512"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_8000)
+                dprintf (("                OSS32_CAPS_PCM_RATE_8000"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_11025)
+                dprintf (("                OSS32_CAPS_PCM_RATE_11025"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_16000)
+                dprintf (("                OSS32_CAPS_PCM_RATE_16000"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_22050)
+                dprintf (("                OSS32_CAPS_PCM_RATE_22050"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_32000)
+                dprintf (("                OSS32_CAPS_PCM_RATE_32000"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_44100)
+                dprintf (("                OSS32_CAPS_PCM_RATE_44100"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_48000)
+                dprintf (("                OSS32_CAPS_PCM_RATE_48000"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_64000)
+                dprintf (("                OSS32_CAPS_PCM_RATE_64000"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_88200)
+                dprintf (("                OSS32_CAPS_PCM_RATE_88200"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_96000)
+                dprintf (("                OSS32_CAPS_PCM_RATE_96000"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_176400)
+                dprintf (("                OSS32_CAPS_PCM_RATE_176400"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_192000)
+                dprintf (("                OSS32_CAPS_PCM_RATE_192000"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_HALFDUPLEX)
+                dprintf (("                OSS32_CAPS_PCM_RATE_HALFDUPLEX"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_CONTINUOUS)
+                dprintf (("                OSS32_CAPS_PCM_RATE_CONTINUOUS"));
+        if (pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_KNOT)
+                dprintf (("                OSS32_CAPS_PCM_RATE_KNOT"));
+
+
+        dprintf (("  ulDataFormats %lxh",  pWaveCaps->ulDataFormats));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S8)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_S8"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_U8"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S16_LE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_S16_LE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S16_BE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_S16_BE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U16_LE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_U16_LE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U16_BE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_U16_BE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S24_LE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_S24_LE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S24_BE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_S24_BE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U24_LE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_U24_LE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U24_BE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_U24_BE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S32_LE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_S32_LE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S32_BE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_S32_BE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U32_LE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_U32_LE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U32_BE)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_U32_BE"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_MULAW)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_MULAW"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_ALAW)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_ALAW"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_ADPCM)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_ADPCM"));
+        if (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_MPEG)
+                dprintf (("                OSS32_CAPS_PCM_FORMAT_MPEG"));
 }
 //******************************************************************************

OCO/trunk/drv16/rtmidi.cpp

@@ -61 +61 @@
 
    if (DevHelp_AttachDD((NPSZ) "MIDI$   ", (NPBYTE) &DDTable)) {
-       dprintf(("rtmidi: error attaching to MIDI.SYS"));
+       rprintf(("rtmidi: error attaching to MIDI.SYS"));
        return;
    }
@@ -74 +74 @@
    DDTable.pfn( &reg );
    if (SELECTOROF(reg.pfnRegisterA) != SELECTOROF(DDTable.pfn)) {
-       dprintf(("rtmidi: invalid selector for pfnRegisterA"));
+       rprintf(("rtmidi: invalid selector for pfnRegisterA"));
       return;
    }
@@ -136 +136 @@
         return MIDIERRA_HW_FAILED;
     }
-#ifdef DEBUG
 //    dprintf(("rtmidi: Open. Mode: %d",usMode));
-#endif
     switch (usMode) {
         case MIDIMODE_OPEN_RECEIVE:
@@ -144 +142 @@
             pma->midiOutStreamId = pma->RTMIDI_OpenReceive();
             if(!pma->midiOutStreamId) return MIDIERRA_HW_FAILED;
-#ifdef DEBUG
 //            dprintf(("rtmidi: Receive openened. stream: %d",pma->midiOutStreamId));
-#endif
             return 0;
         }
@@ -153 +149 @@
             pma->midiInStreamId = pma->RTMIDI_OpenSend();
             if(!pma->midiInStreamId) return MIDIERRA_HW_FAILED;
-#ifdef DEBUG
 //            dprintf(("rtmidi: Send openened. stream: %d",pma->midiInStreamId));
-#endif
             return 0;
         }

OCO/trunk/drv16/strategy.cpp

@@ -3 +3 @@
 /* SCCSID = %W% %E% */
 /****************************************************************************
- *                                                                          *
- * Copyright (c) IBM Corporation 1994 - 1997.                               *
- *                                                                          *
- * The following IBM OS/2 source code is provided to you solely for the     *
+ *                                                                                                                                                      *
+ * Copyright (c) IBM Corporation 1994 - 1997.                                                           *
+ *                                                                                                                                                      *
+ * The following IBM OS/2 source code is provided to you solely for the         *
  * the purpose of assisting you in your development of OS/2 device drivers. *
- * You may use this code in accordance with the IBM License Agreement       *
- * provided in the IBM Device Driver Source Kit for OS/2.                   *
- *                                                                          *
+ * You may use this code in accordance with the IBM License Agreement           *
+ * provided in the IBM Device Driver Source Kit for OS/2.                                       *
+ *                                                                                                                                                      *
  ****************************************************************************/
 /**@internal %W%
@@ -17 +17 @@
  * @version %I%
  * @context Unless otherwise noted, all interfaces are Ring-0, 16-bit,
- *  kernel stack.
+ *      kernel stack.
  * @history
  *
  */
-extern "C" {               // 16-bit header files are not C++ aware
+extern "C" {                       // 16-bit header files are not C++ aware
 #define INCL_NOPMAPI
 #define INCL_DOSINFOSEG
@@ -33 +33 @@
 #include <devhelp.h>
 #include "strategy.h"
-#include "rtmidi.hpp"                  // Object definition
+#include "rtmidi.hpp"                              // Object definition
 #include "end.h"
 
@@ -84 +84 @@
 extern "C" char szAZX[];
 
-static char *pszIntelICH        = (char *)szINTEL_ICH;
+static char *pszIntelICH                = (char *)szINTEL_ICH;
 static char *pszSigmatel9721_23 = (char *)szSIGMATEL_9721_23;
-static char *pszSBLive          = (char *)szSBLIVE;
-static char *pszCMedia          = (char *)szCMEDIA;
-static char *pszCrystal4281     = (char *)szCS4281;
-static char *pszALS4000         = (char *)szALS4000;
-static char *pszCrystal46XX     = (char *)szCS46XX;
-static char *pszVIA82XX         = (char *)szVIA82XX;
-static char *pszESS1938         = (char *)szESS1938;
-static char *pszVORTEX          = (char *)szVORTEX;
-static char *pszES1371          = (char *)szES1371;
-static char *pszES1370          = (char *)szES1370;
-static char *pszYAMAHA          = (char *)szYAMAHA;
-static char *pszMAESTRO         = (char *)szMAESTRO;
-static char *pszMAESTRO3        = (char *)szMAESTRO3;
-static char *pszALLEGRO         = (char *)szALLEGRO;
-static char *pszALI5451         = (char *)szALI5451;
-static char *pszSI7012          = (char *)szSI7012;
-static char *pszALI5455         = (char *)szALI5455;
-static char *pszNVIDIA          = (char *)szNVIDIA;
-static char *pszAMD             = (char *)szAMD;
-static char *pszTRIDENT         = (char *)szTRIDENT;
-static char *pszNEOMAGIC        = (char *)szNEOMAGIC;
-static char *pszFM801           = (char *)szFM801;
-static char *pszATIIXP          = (char *)szATIIXP;
-static char *pszAUDIGYLS        = (char *)szAUDIGYLS;
-static char *pszBT87X           = (char *)szBT87X;
-static char *pszAZX             = (char *)szAZX;
+static char *pszSBLive                  = (char *)szSBLIVE;
+static char *pszCMedia                  = (char *)szCMEDIA;
+static char *pszCrystal4281     = (char *)szCS4281;
+static char *pszALS4000                 = (char *)szALS4000;
+static char *pszCrystal46XX     = (char *)szCS46XX;
+static char *pszVIA82XX                 = (char *)szVIA82XX;
+static char *pszESS1938                 = (char *)szESS1938;
+static char *pszVORTEX                  = (char *)szVORTEX;
+static char *pszES1371                  = (char *)szES1371;
+static char *pszES1370                  = (char *)szES1370;
+static char *pszYAMAHA                  = (char *)szYAMAHA;
+static char *pszMAESTRO                 = (char *)szMAESTRO;
+static char *pszMAESTRO3                = (char *)szMAESTRO3;
+static char *pszALLEGRO                 = (char *)szALLEGRO;
+static char *pszALI5451                 = (char *)szALI5451;
+static char *pszSI7012                  = (char *)szSI7012;
+static char *pszALI5455                 = (char *)szALI5455;
+static char *pszNVIDIA                  = (char *)szNVIDIA;
+static char *pszAMD                     = (char *)szAMD;
+static char *pszTRIDENT                 = (char *)szTRIDENT;
+static char *pszNEOMAGIC                = (char *)szNEOMAGIC;
+static char *pszFM801                   = (char *)szFM801;
+static char *pszATIIXP                  = (char *)szATIIXP;
+static char *pszAUDIGYLS                = (char *)szAUDIGYLS;
+static char *pszBT87X                   = (char *)szBT87X;
+static char *pszAZX                     = (char *)szAZX;
 #endif /* ENABLE_HW_CERTIFICATION */
 
-       BOOL fNoHardware         = FALSE;
+           BOOL fNoHardware             = FALSE;
 
 extern void DBGCALLCONV APM_Init();
@@ -126 +126 @@
   int d;
   for (;;)
-    {
-//       d = (int)(unsigned char)*string1 - (int)(unsigned char)(*string2 ^ 0x81);
-       d = (int)(unsigned char)*string1 - (int)(unsigned char)*string2;
-       if (d != 0 || *string1 == 0 || *string2 == 0)
-         return d;
-       ++string1; ++string2;
-    }
+        {
+//               d = (int)(unsigned char)*string1 - (int)(unsigned char)(*string2 ^ 0x81);
+           d = (int)(unsigned char)*string1 - (int)(unsigned char)*string2;
+           if (d != 0 || *string1 == 0 || *string2 == 0)
+                 return d;
+           ++string1; ++string2;
+        }
 }
 //******************************************************************************
@@ -141 +141 @@
 
   while (count != 0)
-    {
-        //      d = (int)(unsigned char)*string1 - (int)(unsigned char)(*string2 ^ 0x81);
-      d = (int)(unsigned char)*string1 - (int)(unsigned char)*string2;
-      if (d != 0 || *string1 == 0 || *string2 == 0)
-        return d;
-      ++string1; ++string2;
-      --count;
-    }
+        {
+                //              d = (int)(unsigned char)*string1 - (int)(unsigned char)(*string2 ^ 0x81);
+          d = (int)(unsigned char)*string1 - (int)(unsigned char)*string2;
+          if (d != 0 || *string1 == 0 || *string2 == 0)
+                return d;
+          ++string1; ++string2;
+          --count;
+        }
   return 0;
 }
@@ -160 +160 @@
    if(OSS16_AttachToPdd() != OSSERR_SUCCESS)
    {
-       DebugInt3();
-//       DevHelp_Beep(500, 100);
-       goto failure;
+           DebugInt3();
+//               DevHelp_Beep(500, 100);
+           goto failure;
    }
 
@@ -168 +168 @@
    if(OSS16_QueryDevCaps(current_device, &devCaps[0]) != OSSERR_SUCCESS)
    {
-       DebugInt3();
-       //       DevHelp_Beep(2000, 100);
-       goto failure;
+           DebugInt3();
+           //           DevHelp_Beep(2000, 100);
+           goto failure;
    }
    dprintf(("Device 0 name: %s", (char FAR *)devCaps[0].szDeviceName));
    if(devCaps[0].nrDevices > OSS32_MAX_AUDIOCARDS)
    {
-       DebugInt3();
-       devCaps[0].nrDevices = OSS32_MAX_AUDIOCARDS;
+           DebugInt3();
+           devCaps[0].nrDevices = OSS32_MAX_AUDIOCARDS;
    }
    //Get caps of other devices (if present)
    for(i=1;i<devCaps[0].nrDevices;i++)
    {
-       if(OSS16_QueryDevCaps(i, &devCaps[i]) != OSSERR_SUCCESS) {
-           DebugInt3();
-           goto failure;
-       }
+           if(OSS16_QueryDevCaps(i, &devCaps[i]) != OSSERR_SUCCESS) {
+                   DebugInt3();
+                   goto failure;
+           }
    }
 
@@ -191 +191 @@
    //Check for certified audiocard/chipsets
    if(!xorstrncmp(devCaps[0].szDeviceName, pszIntelICH, 6) ||
-      !xorstrcmp(devCaps[0].szDeviceName, pszSI7012) ||
-      !xorstrcmp(devCaps[0].szDeviceName, pszALI5455) ||
-      !xorstrncmp(devCaps[0].szDeviceName, pszNVIDIA, 6) ||
-      !xorstrcmp(devCaps[0].szDeviceName, pszAMD))
-   {
-       soundCard = INTELICH;
+          !xorstrcmp(devCaps[0].szDeviceName, pszSI7012) ||
+          !xorstrcmp(devCaps[0].szDeviceName, pszALI5455) ||
+          !xorstrncmp(devCaps[0].szDeviceName, pszNVIDIA, 6) ||
+          !xorstrcmp(devCaps[0].szDeviceName, pszAMD))
+   {
+           soundCard = INTELICH;
    }
    else
    if(!xorstrcmp(devCaps[0].szDeviceName, pszSBLive))
    {
-       soundCard = SBLIVE;
+           soundCard = SBLIVE;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszCMedia, 11))
    {
-       soundCard = CMEDIA;
+           soundCard = CMEDIA;
    }
    else
    if(!xorstrcmp(devCaps[0].szDeviceName, pszCrystal4281))
    {
-       soundCard = CS4281;
+           soundCard = CS4281;
    }
    else
    if(!xorstrcmp(devCaps[0].szDeviceName, pszALS4000))
    {
-       //hardware not completely full duplex; sample rates must be identical if
-       //both playback & recording active
-       devCaps[0].waveInCaps.ulRateFlags  |= OSS32_CAPS_PCM_RATE_HALFDUPLEX;
-       devCaps[0].waveOutCaps.ulRateFlags |= OSS32_CAPS_PCM_RATE_HALFDUPLEX;
-       soundCard = ALS4000;
+           //hardware not completely full duplex; sample rates must be identical if
+           //both playback & recording active
+           devCaps[0].waveInCaps.ulRateFlags  |= OSS32_CAPS_PCM_RATE_HALFDUPLEX;
+           devCaps[0].waveOutCaps.ulRateFlags |= OSS32_CAPS_PCM_RATE_HALFDUPLEX;
+           soundCard = ALS4000;
    }
    else
    if(!xorstrcmp(devCaps[0].szDeviceName, pszCrystal46XX))
    {
-       soundCard = CS46XX;
+           soundCard = CS46XX;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszVIA82XX, 6))
    {
-       soundCard = VIA82XX;
+           soundCard = VIA82XX;
    }
    else
    if(!xorstrcmp(devCaps[0].szDeviceName, pszESS1938))
    {
-       soundCard = ESS1938;
+           soundCard = ESS1938;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszVORTEX, 6))
    {
-       soundCard = VORTEX;
+           soundCard = VORTEX;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszYAMAHA,6))
    {
-       soundCard = YAMAHA;
+           soundCard = YAMAHA;
    }
    else
    if(!xorstrcmp(devCaps[0].szDeviceName, pszMAESTRO))
    {
-       soundCard = MAESTRO;
-   }
-   else
-       if(!xorstrcmp(devCaps[0].szDeviceName, pszMAESTRO3) ||
-          !xorstrcmp(devCaps[0].szDeviceName, pszALLEGRO))
-   {
-       soundCard = MAESTRO3;
-   }
-   else
-       if(!xorstrncmp(devCaps[0].szDeviceName, pszES1371, 6) ||
-          !xorstrncmp(devCaps[0].szDeviceName, pszES1370, 6))
-   {
-       soundCard = ENSONIQ;
+           soundCard = MAESTRO;
+   }
+   else
+           if(!xorstrcmp(devCaps[0].szDeviceName, pszMAESTRO3) ||
+                  !xorstrcmp(devCaps[0].szDeviceName, pszALLEGRO))
+   {
+           soundCard = MAESTRO3;
+   }
+   else
+           if(!xorstrncmp(devCaps[0].szDeviceName, pszES1371, 6) ||
+                  !xorstrncmp(devCaps[0].szDeviceName, pszES1370, 6))
+   {
+           soundCard = ENSONIQ;
    }
    else
    if(!xorstrcmp(devCaps[0].szDeviceName, pszALI5451))
    {
-       soundCard = ALI5451;
+           soundCard = ALI5451;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszTRIDENT,7))
    {
-       soundCard = TRIDENT;
+           soundCard = TRIDENT;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszNEOMAGIC,5))
    {
-       soundCard = NEOMAGIC;
+           soundCard = NEOMAGIC;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszFM801,5))
    {
-       soundCard = FM801;
+           soundCard = FM801;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszATIIXP,7))
    {
-       soundCard = ATIIXP;
+           soundCard = ATIIXP;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszAUDIGYLS,6))
    {
-       soundCard = AUDIGYLS;
+           soundCard = AUDIGYLS;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszBT87X,5))
    {
-       soundCard = BT87X;
+           soundCard = BT87X;
    }
    else
    if(!xorstrncmp(devCaps[0].szDeviceName, pszAZX,9))
    {
-       soundCard = AZX;
+           soundCard = AZX;
    }
    else {
-//       printk("Soundcard %s not supported", (char FAR *)devCaps[0].szDeviceName);
-       dprintf(("Soundcard %s not supported", (char FAR *)devCaps[0].szDeviceName));
-//       DevHelp_Beep(1000, 50);
-       DebugInt3();
-       goto failure;
+           rprintf(("Soundcard %s not supported", (char FAR *)devCaps[0].szDeviceName));
+                //DevHelp_Beep(1000, 50);
+           DebugInt3();
+           goto failure;
    }
 #endif /* ENABLE_HW_CERTIFICATION */
@@ -315 +314 @@
 
 failure:
-//    DevHelp_Beep(1000, 50);
-    fNoHardware = TRUE;
-    return FALSE;
+//        DevHelp_Beep(1000, 50);
+        fNoHardware = TRUE;
+        return FALSE;
 }
 
@@ -329 +328 @@
 {
    if(InitializeAudio() == FALSE) {
-       return;
+           return;
    }
    if(fNoHardware) return;
@@ -338 +337 @@
    if(devCaps[0].ulCaps & OSS32_CAPS_FMSYNTH_PLAYBACK)
    {
-       dprintf(("Creating FM Synthesizer device"));
-
-       // Build a FMSYNTH object.  First create a timer, then the HW object.
-       TIMER* pFMSynthTimer =
-           new TIMER( NULL, MIDI_TimerInterval, STREAM_FMSYNTH_PLAY );
-       if (pFMSynthTimer->eState() != TIMER_Disabled)
-           new FMSYNTH( pFMSynthTimer );
-
-       SetHardwareType(AUDIOHW_FMSYNTH_PLAY, MIDI, OPERATION_PLAY, 1);
-       SetHardwareType(AUDIOHW_FMSYNTH_PLAY, DATATYPE_MIDI, OPERATION_PLAY, 1);
-       // MIDI on Warp 3
-       SetHardwareType(AUDIOHW_FMSYNTH_PLAY, DATATYPE_NULL, OPERATION_PLAY, 1);
+           dprintf(("Creating FM Synthesizer device"));
+
+           // Build a FMSYNTH object.  First create a timer, then the HW object.
+           TIMER* pFMSynthTimer =
+                   new TIMER( NULL, MIDI_TimerInterval, STREAM_FMSYNTH_PLAY );
+           if (pFMSynthTimer->eState() != TIMER_Disabled)
+                   new FMSYNTH( pFMSynthTimer );
+
+           SetHardwareType(AUDIOHW_FMSYNTH_PLAY, MIDI, OPERATION_PLAY, 1);
+           SetHardwareType(AUDIOHW_FMSYNTH_PLAY, DATATYPE_MIDI, OPERATION_PLAY, 1);
+           // MIDI on Warp 3
+           SetHardwareType(AUDIOHW_FMSYNTH_PLAY, DATATYPE_NULL, OPERATION_PLAY, 1);
    }
 
    if((devCaps[0].ulCaps & OSS32_CAPS_MPU401_PLAYBACK) &&
-      (devCaps[0].ulCaps & OSS32_CAPS_MPU401_CAPTURE))
-   {
-       dprintf(("Creating MPU401 device"));
-
-       // Build the MPU401 object. First create a timer, then the HW object.
-       TIMER* pMPUTimer =
-           // vladest      new TIMER(NULL, MIDI_TimerInterval, STREAM_MPU401_PLAY );
-           new TIMER(NULL, MIDI_TimerInterval, STREAM_MPU401_CAPTURE );
-
-       if (pMPUTimer->eState() != TIMER_Disabled)
-           new MPU_401(pMPUTimer);
-
-//       SetHardwareType(AUDIOHW_MPU401_PLAY, MIDI, OPERATION_PLAY, 0);
-//       SetHardwareType(AUDIOHW_MPU401_PLAY, DATATYPE_MIDI, OPERATION_PLAY, 0);
-
-       SetHardwareType(AUDIOHW_MPU401_CAPTURE, MIDI, OPERATION_RECORD, 0);
-       SetHardwareType(AUDIOHW_MPU401_CAPTURE, DATATYPE_MIDI, OPERATION_RECORD, 0);
-
-       RTMIDI::vConnect();
+          (devCaps[0].ulCaps & OSS32_CAPS_MPU401_CAPTURE))
+   {
+           dprintf(("Creating MPU401 device"));
+
+           // Build the MPU401 object. First create a timer, then the HW object.
+           TIMER* pMPUTimer =
+                   // vladest      new TIMER(NULL, MIDI_TimerInterval, STREAM_MPU401_PLAY );
+                   new TIMER(NULL, MIDI_TimerInterval, STREAM_MPU401_CAPTURE );
+
+           if (pMPUTimer->eState() != TIMER_Disabled)
+                   new MPU_401(pMPUTimer);
+
+//               SetHardwareType(AUDIOHW_MPU401_PLAY, MIDI, OPERATION_PLAY, 0);
+//               SetHardwareType(AUDIOHW_MPU401_PLAY, DATATYPE_MIDI, OPERATION_PLAY, 0);
+
+           SetHardwareType(AUDIOHW_MPU401_CAPTURE, MIDI, OPERATION_RECORD, 0);
+           SetHardwareType(AUDIOHW_MPU401_CAPTURE, DATATYPE_MIDI, OPERATION_RECORD, 0);
+
+           RTMIDI::vConnect();
    }
    APM_Init();
@@ -380 +379 @@
  * Purpose:  Worker rountine for the Strategy Open function.
  *
- * Notes:    The Strategy Open doesn't require allocation of any resources,
- *           and the function is treated as a NOP.  The first allocation of
- *           resources happens at Strategy IOCtl time, in the handler for
- *           the AudioInit IOCtl.
- *           Check to see if the VDD has claimed the hardware and return with
- *           the busy bit on the the request packet.
- *           Increment the InUseCount so we know that an OS/2 app has an
- *           instance open and we don't let the VDD take the hardware..
+ * Notes:        The Strategy Open doesn't require allocation of any resources,
+ *                       and the function is treated as a NOP.  The first allocation of
+ *                       resources happens at Strategy IOCtl time, in the handler for
+ *                       the AudioInit IOCtl.
+ *                       Check to see if the VDD has claimed the hardware and return with
+ *                       the busy bit on the the request packet.
+ *                       Increment the InUseCount so we know that an OS/2 app has an
+ *                       instance open and we don't let the VDD take the hardware..
  *
  *
@@ -395 +394 @@
 {
    if (usVDDHasHardware) {
-      prp->usStatus = RPDONE | RPERR | RPBUSY;
+          prp->usStatus = RPDONE | RPERR | RPBUSY;
    }
    else {
-      ++usInUseCount;
+          ++usInUseCount;
    }
 }
@@ -405 +404 @@
 void StrategyClose(PREQPACKET prp)
 {
-    --usInUseCount;
-    PSTREAM pstream = FindStream_fromFile( prp->s.open_close.usSysFileNum );
-    if (pstream)
-        delete pstream;
-    else
-        dprintf(("Close NULL stream"));;         //### Log unexpected condition.
+        --usInUseCount;
+        PSTREAM pstream = FindStream_fromFile( prp->s.open_close.usSysFileNum );
+        if (pstream)
+                delete pstream;
+        else
+                dprintf(("Close NULL stream"));;                 //### Log unexpected condition.
 }
 //******************************************************************************
@@ -416 +415 @@
 void StrategyDeinstall(PREQPACKET prp)
 {
-    while (pAudioHWList->IsElements())
-        pAudioHWList->DestroyElement(pAudioHWList->PopHead());
+        while (pAudioHWList->IsElements())
+                pAudioHWList->DestroyElement(pAudioHWList->PopHead());
 }
 //******************************************************************************
@@ -423 +422 @@
 void StrategyShutdown(PREQPACKET prp)
 {
-    dprintf(("StrategyShutdown %d", prp->s.shutdown.Function));
+        dprintf(("StrategyShutdown %d", prp->s.shutdown.Function));
 }
 //******************************************************************************
@@ -446 +445 @@
 
    if(fNoHardware) {
-       prp->usStatus = RPDONE | RPERR | RPGENFAIL;
-       return;
+           prp->usStatus = RPDONE | RPERR | RPGENFAIL;
+           return;
    }
 
@@ -455 +454 @@
 
    switch (prp->bCommand) {
-      case STRATEGY_INIT:
-         StrategyInit(prp);
-         break;
-      case STRATEGY_OPEN:
-         StrategyOpen(prp);
-         break;
-      case STRATEGY_CLOSE:
-         StrategyClose(prp);
-         break;
-      case STRATEGY_GENIOCTL:
-         StrategyIoctl(prp, 0);
-         break;
-      case STRATEGY_DEINSTALL:
-         StrategyDeinstall(prp);
-         break;
-      case STRATEGY_INITCOMPLETE:
-         StrategyInitComplete(prp);
-         break;
-      case STRATEGY_SHUTDOWN:
-         StrategyShutdown(prp);
-         break;
-      default:
-         dprintf(("Strategy Unk:0x%x", prp->bCommand));
-         prp->usStatus = RPDONE | RPERR | RPGENFAIL;
+          case STRATEGY_INIT:
+                 StrategyInit(prp);
+                 break;
+          case STRATEGY_OPEN:
+                 StrategyOpen(prp);
+                 break;
+          case STRATEGY_CLOSE:
+                 StrategyClose(prp);
+                 break;
+          case STRATEGY_GENIOCTL:
+                 StrategyIoctl(prp, 0);
+                 break;
+          case STRATEGY_DEINSTALL:
+                 StrategyDeinstall(prp);
+                 break;
+          case STRATEGY_INITCOMPLETE:
+                 StrategyInitComplete(prp);
+                 break;
+          case STRATEGY_SHUTDOWN:
+                 StrategyShutdown(prp);
+                 break;
+          default:
+                 rprintf(("Strategy Unk:0x%x", prp->bCommand));
+                 prp->usStatus = RPDONE | RPERR | RPGENFAIL;
    }
 #ifdef DEBUG
@@ -493 +492 @@
 
    if(fNoHardware) {
-       prp->usStatus = RPDONE | RPERR | RPGENFAIL;
-       if(prp->bCommand == STRATEGY_INIT) {
-           prp->s.init_out.usCodeEnd = 0;
-           prp->s.init_out.usDataEnd = 0;
-       }
-       return;
+           prp->usStatus = RPDONE | RPERR | RPGENFAIL;
+           if(prp->bCommand == STRATEGY_INIT) {
+                   prp->s.init_out.usCodeEnd = 0;
+                   prp->s.init_out.usDataEnd = 0;
+           }
+           return;
    }
 
@@ -506 +505 @@
 
    switch (prp->bCommand) {
-      case STRATEGY_INIT:
-         prp->usStatus = RPDONE;
-         prp->s.init_out.usCodeEnd = (USHORT) &end_of_text;
-         prp->s.init_out.usDataEnd = (USHORT) &end_of_heap;
-         break;
-      case STRATEGY_OPEN:
-         StrategyOpen(prp);
-         break;
-      case STRATEGY_CLOSE:
-         StrategyClose(prp);
-         break;
-      case STRATEGY_GENIOCTL:
-         StrategyIoctl(prp, 1);
-         break;
-      case STRATEGY_DEINSTALL:
-         StrategyDeinstall(prp);
-         break;
-      case STRATEGY_INITCOMPLETE:
-         prp->usStatus = RPDONE;
-         break;
-      default:
-         prp->usStatus = RPDONE | RPERR | RPGENFAIL;
+          case STRATEGY_INIT:
+                 prp->usStatus = RPDONE;
+                 prp->s.init_out.usCodeEnd = (USHORT) &end_of_text;
+                 prp->s.init_out.usDataEnd = (USHORT) &end_of_heap;
+                 break;
+          case STRATEGY_OPEN:
+                 StrategyOpen(prp);
+                 break;
+          case STRATEGY_CLOSE:
+                 StrategyClose(prp);
+                 break;
+          case STRATEGY_GENIOCTL:
+                 StrategyIoctl(prp, 1);
+                 break;
+          case STRATEGY_DEINSTALL:
+                 StrategyDeinstall(prp);
+                 break;
+          case STRATEGY_INITCOMPLETE:
+                 prp->usStatus = RPDONE;
+                 break;
+          default:
+                 prp->usStatus = RPDONE | RPERR | RPGENFAIL;
    }
 #ifdef DEBUG

OCO/trunk/drv16/waudio.cpp

@@ -2 +2 @@
 /* SCCSID = %W% %E% */
 /****************************************************************************
- *                                                                          *
- * Copyright (c) IBM Corporation 1994 - 1997.                               *
- *                                                                          *
- * The following IBM OS/2 source code is provided to you solely for the     *
+ *                                                                                                                                                      *
+ * Copyright (c) IBM Corporation 1994 - 1997.                                                           *
+ *                                                                                                                                                      *
+ * The following IBM OS/2 source code is provided to you solely for the         *
  * the purpose of assisting you in your development of OS/2 device drivers. *
- * You may use this code in accordance with the IBM License Agreement       *
- * provided in the IBM Device Driver Source Kit for OS/2.                   *
- *                                                                          *
+ * You may use this code in accordance with the IBM License Agreement           *
+ * provided in the IBM Device Driver Source Kit for OS/2.                                       *
+ *                                                                                                                                                      *
  ****************************************************************************/
 /**@internal %W%
  * @notes
- *  The default for 8 bps is unsigned and signed for > 8 bps
- *  The default byte order for > 8 bps is little endian
- *  (important for devices that support both formats)
+ *      The default for 8 bps is unsigned and signed for > 8 bps
+ *      The default byte order for > 8 bps is little endian
+ *      (important for devices that support both formats)
  *
  * @version %I%
  * @context Unless otherwise noted, all interfaces are Ring-0, 16-bit,
- *  <stack context>.
+ *      <stack context>.
  * @history
  *
@@ -86 +86 @@
 //
 ULONG aaulWave[NUMFREQS][BPSTYPES][MONOSTEREO] = {
-      WAVE_FORMAT_1M08,    /* 11.025kHz, 8-bit  Mono   */
-      WAVE_FORMAT_1S08,    /* 11.025kHz, 8-bit  Stereo */
-      WAVE_FORMAT_1M16,    /* 11.025kHz, 16-bit Mono   */
-      WAVE_FORMAT_1S16,    /* 11.025kHz, 16-bit Stereo */
-      WAVE_FORMAT_1M16,    /* 11.025kHz, 24-bit Mono   */ //TODO: what else can we fill in?
-      WAVE_FORMAT_1S16,    /* 11.025kHz, 24-bit Stereo */ //TODO: what else can we fill in?
-      WAVE_FORMAT_1M16,    /* 11.025kHz, 32-bit Mono   */ //TODO: what else can we fill in?
-      WAVE_FORMAT_1S16,    /* 11.025kHz, 32-bit Stereo */ //TODO: what else can we fill in?
-      WAVE_FORMAT_2M08,    /* 22.05kHz , 8-bit  Mono   */
-      WAVE_FORMAT_2S08,    /* 22.05kHz , 8-bit  Stereo */
-      WAVE_FORMAT_2M16,    /* 22.05kHz , 16-bit Mono   */
-      WAVE_FORMAT_2S16,    /* 22.05kHz , 16-bit Stereo */
-      WAVE_FORMAT_2M16,    /* 22.05kHz , 24-bit Mono   */ //TODO: what else can we fill in?
-      WAVE_FORMAT_2S16,    /* 22.05kHz , 24-bit Stereo */ //TODO: what else can we fill in?
-      WAVE_FORMAT_2M16,    /* 22.05kHz , 32-bit Mono   */ //TODO: what else can we fill in?
-      WAVE_FORMAT_2S16,    /* 22.05kHz , 32-bit Stereo */ //TODO: what else can we fill in?
-      WAVE_FORMAT_4M08,    /* 44.1kHz  , 8-bit  Mono   */
-      WAVE_FORMAT_4S08,    /* 44.1kHz  , 8-bit  Stereo */
-      WAVE_FORMAT_4M16,    /* 44.1kHz  , 16-bit Mono   */
-      WAVE_FORMAT_4S16,    /* 44.1kHz  , 16-bit Stereo */
-      WAVE_FORMAT_4M16,    /* 44.1kHz  , 24-bit Mono   */ //TODO: what else can we fill in?
-      WAVE_FORMAT_4S16,    /* 44.1kHz  , 24-bit Stereo */ //TODO: what else can we fill in?
-      WAVE_FORMAT_4M16,    /* 44.1kHz  , 32-bit Mono   */ //TODO: what else can we fill in?
-      WAVE_FORMAT_4S16,    /* 44.1kHz  , 32-bit Stereo */ //TODO: what else can we fill in?
-      WAVE_FORMAT_8M08,    /*  8.0kHz  , 8-bit  Mono   */
-      WAVE_FORMAT_8S08,    /*  8.0kHz  , 8-bit  Stereo */
-      WAVE_FORMAT_8M16,    /*  8.0kHz  , 16-bit Mono   */
-      WAVE_FORMAT_8S16,    /*  8.0kHz  , 16-bit Stereo */
-      WAVE_FORMAT_8M16,    /*  8.0kHz  , 24-bit Mono   */ //TODO: what else can we fill in?
-      WAVE_FORMAT_8S16,    /*  8.0kHz  , 24-bit Stereo */ //TODO: what else can we fill in?
-      WAVE_FORMAT_8M16,    /*  8.0kHz  , 32-bit Mono   */ //TODO: what else can we fill in?
-      WAVE_FORMAT_8S16     /*  8.0kHz  , 32-bit Stereo */ //TODO: what else can we fill in?
-      };
+          WAVE_FORMAT_1M08,    /* 11.025kHz, 8-bit      Mono   */
+          WAVE_FORMAT_1S08,    /* 11.025kHz, 8-bit      Stereo */
+          WAVE_FORMAT_1M16,    /* 11.025kHz, 16-bit Mono   */
+          WAVE_FORMAT_1S16,    /* 11.025kHz, 16-bit Stereo */
+          WAVE_FORMAT_1M16,    /* 11.025kHz, 24-bit Mono   */ //TODO: what else can we fill in?
+          WAVE_FORMAT_1S16,    /* 11.025kHz, 24-bit Stereo */ //TODO: what else can we fill in?
+          WAVE_FORMAT_1M16,    /* 11.025kHz, 32-bit Mono   */ //TODO: what else can we fill in?
+          WAVE_FORMAT_1S16,    /* 11.025kHz, 32-bit Stereo */ //TODO: what else can we fill in?
+          WAVE_FORMAT_2M08,    /* 22.05kHz , 8-bit      Mono   */
+          WAVE_FORMAT_2S08,    /* 22.05kHz , 8-bit      Stereo */
+          WAVE_FORMAT_2M16,    /* 22.05kHz , 16-bit Mono   */
+          WAVE_FORMAT_2S16,    /* 22.05kHz , 16-bit Stereo */
+          WAVE_FORMAT_2M16,    /* 22.05kHz , 24-bit Mono   */ //TODO: what else can we fill in?
+          WAVE_FORMAT_2S16,    /* 22.05kHz , 24-bit Stereo */ //TODO: what else can we fill in?
+          WAVE_FORMAT_2M16,    /* 22.05kHz , 32-bit Mono   */ //TODO: what else can we fill in?
+          WAVE_FORMAT_2S16,    /* 22.05kHz , 32-bit Stereo */ //TODO: what else can we fill in?
+          WAVE_FORMAT_4M08,    /* 44.1kHz  , 8-bit      Mono   */
+          WAVE_FORMAT_4S08,    /* 44.1kHz  , 8-bit      Stereo */
+          WAVE_FORMAT_4M16,    /* 44.1kHz  , 16-bit Mono   */
+          WAVE_FORMAT_4S16,    /* 44.1kHz  , 16-bit Stereo */
+          WAVE_FORMAT_4M16,    /* 44.1kHz  , 24-bit Mono   */ //TODO: what else can we fill in?
+          WAVE_FORMAT_4S16,    /* 44.1kHz  , 24-bit Stereo */ //TODO: what else can we fill in?
+          WAVE_FORMAT_4M16,    /* 44.1kHz  , 32-bit Mono   */ //TODO: what else can we fill in?
+          WAVE_FORMAT_4S16,    /* 44.1kHz  , 32-bit Stereo */ //TODO: what else can we fill in?
+          WAVE_FORMAT_8M08,    /*  8.0kHz  , 8-bit      Mono   */
+          WAVE_FORMAT_8S08,    /*  8.0kHz  , 8-bit      Stereo */
+          WAVE_FORMAT_8M16,    /*  8.0kHz  , 16-bit Mono   */
+          WAVE_FORMAT_8S16,    /*  8.0kHz  , 16-bit Stereo */
+          WAVE_FORMAT_8M16,    /*  8.0kHz  , 24-bit Mono   */ //TODO: what else can we fill in?
+          WAVE_FORMAT_8S16,    /*  8.0kHz  , 24-bit Stereo */ //TODO: what else can we fill in?
+          WAVE_FORMAT_8M16,    /*  8.0kHz  , 32-bit Mono   */ //TODO: what else can we fill in?
+          WAVE_FORMAT_8S16         /*  8.0kHz  , 32-bit Stereo */ //TODO: what else can we fill in?
+          };
 
 //
@@ -125 +125 @@
 // _usfind_matching_sample_rate) and the number of channels
 ULONG aaulAlaw[NUMFREQS][MONOSTEREO] = {
-      ALAW_8B11KM,      /* 8bit 11kHz mono*/
-      ALAW_8B11KS,      /* 8bit 11kHz stereo*/
-      ALAW_8B22KM,      /* 8bit 22kHz mono*/
-      ALAW_8B22KS,      /* 8bit 22kHz stereo*/
-      ALAW_8B44KM,      /* 8bit 44kHz mono*/
-      ALAW_8B44KS,      /* 8bit 44kHz stereo*/
-      ALAW_8B8KM ,      /* 8bit 8kHz mono*/
-      ALAW_8B8KS        /* 8bit 8kHz stereo*/
-      };
+          ALAW_8B11KM,          /* 8bit 11kHz mono*/
+          ALAW_8B11KS,          /* 8bit 11kHz stereo*/
+          ALAW_8B22KM,          /* 8bit 22kHz mono*/
+          ALAW_8B22KS,          /* 8bit 22kHz stereo*/
+          ALAW_8B44KM,          /* 8bit 44kHz mono*/
+          ALAW_8B44KS,          /* 8bit 44kHz stereo*/
+          ALAW_8B8KM ,          /* 8bit 8kHz mono*/
+          ALAW_8B8KS            /* 8bit 8kHz stereo*/
+          };
 //
 // the following 2-D array defines the subtypes for DATATYPE_MULAW
@@ -139 +139 @@
 // _usfind_matching_sample_rate) and the number of channels
 ULONG aaulMulaw[NUMFREQS][MONOSTEREO] = {
-      MULAW_8B11KM,     /* 8bit 11kHz mono*/
-      MULAW_8B11KS,     /* 8bit 11kHz stereo*/
-      MULAW_8B22KM,     /* 8bit 22kHz mono*/
-      MULAW_8B22KS,     /* 8bit 22kHz stereo*/
-      MULAW_8B44KM,     /* 8bit 44kHz mono*/
-      MULAW_8B44KS,     /* 8bit 44kHz stereo*/
-      MULAW_8B8KM ,     /* 8bit 8kHz mono*/
-      MULAW_8B8KS       /* 8bit 8kHz stereo*/
-      };
+          MULAW_8B11KM,         /* 8bit 11kHz mono*/
+          MULAW_8B11KS,         /* 8bit 11kHz stereo*/
+          MULAW_8B22KM,         /* 8bit 22kHz mono*/
+          MULAW_8B22KS,         /* 8bit 22kHz stereo*/
+          MULAW_8B44KM,         /* 8bit 44kHz mono*/
+          MULAW_8B44KS,         /* 8bit 44kHz stereo*/
+          MULAW_8B8KM ,         /* 8bit 8kHz mono*/
+          MULAW_8B8KS           /* 8bit 8kHz stereo*/
+          };
 
 //
@@ -161 +161 @@
 
 WAVEAUDIO::WAVEAUDIO(ULONG devicetype, ULONG ulDeviceNr) :
-      AUDIOHW(devicetype)
-{
-    this->ulDeviceNr = ulDeviceNr;
-
-    StreamId = 0;
+          AUDIOHW(devicetype)
+{
+        this->ulDeviceNr = ulDeviceNr;
+
+        StreamId = 0;
 }
 
 /**@internal _usfind_matching_sample_rate
- * @param    PULONG pulSampleRate
- * @param    PULONG pSampleRates
+ * @param        PULONG pulSampleRate
+ * @param        PULONG pSampleRates
  * @return
  * @notes
@@ -182 +182 @@
 USHORT WAVEAUDIO::_usfind_matching_sample_rate(PULONG pulSampleRate, int nrSampleRates, PULONG pSampleRates)
 {
-    ULONG  ulMinDistance = 0x7fffffff;
-    USHORT usMatching;
-    USHORT us;
-
-    if(nrSampleRates == 0) {
-        nrSampleRates = 4;
-        pSampleRates  = aulSuppSampleRates;
-    }
-    for ( us = 0; us < nrSampleRates; us++ ) {
-        ULONG ulDistance = distance( *pulSampleRate, pSampleRates[us] );
-        if (ulDistance < ulMinDistance) {
-            ulMinDistance = ulDistance;
-            usMatching = us;
-        }
-    }
-    *pulSampleRate = pSampleRates[usMatching];
-    return usMatching;
+        ULONG  ulMinDistance = 0x7fffffff;
+        USHORT usMatching;
+        USHORT us;
+
+        if(nrSampleRates == 0) {
+                nrSampleRates = 4;
+                pSampleRates  = aulSuppSampleRates;
+        }
+        for ( us = 0; us < nrSampleRates; us++ ) {
+                ULONG ulDistance = distance( *pulSampleRate, pSampleRates[us] );
+                if (ulDistance < ulMinDistance) {
+                        ulMinDistance = ulDistance;
+                        usMatching = us;
+                }
+        }
+        *pulSampleRate = pSampleRates[usMatching];
+        return usMatching;
 }
 //******************************************************************************
@@ -208 +208 @@
 ULONG WAVEAUDIO::QueryDataFlags(ULONG ulOperation, ULONG ulDataType, ULONG ulBitsPerSample)
 {
-   ULONG      ulFlags;
+   ULONG          ulFlags;
    PWAVE_CAPS pWaveCaps;
 
-   ulFlags = FIXED    |    // Fixed length data
-             LEFT_ALIGNED; // Left align bits on byte bndry (for samples < 8 bits; TODO)
+   ulFlags = FIXED        |    // Fixed length data
+                         LEFT_ALIGNED; // Left align bits on byte bndry (for samples < 8 bits; TODO)
 
    if(ulOperation == OPERATION_PLAY) {
-        pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
+                pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
    }
    else pWaveCaps = &devCaps[ulDeviceNr].waveInCaps;
@@ -223 +223 @@
    case DATATYPE_WAVEFORM:
    case PCM:
-       //NOTE1: The default for 8 bps is unsigned and signed for > 8 bps !!!
-       //NOTE2: The default byte order for > 8 bps is little endian
-
-       switch(ulBitsPerSample)
-       {
-       case 8:
-           //default = unsigned
-           break;
-       case 16:
-           //default = signed
-           ulFlags |= TWOS_COMPLEMENT;
-
-           if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE))
-           {
-               ulFlags |= BIG_ENDIAN;
-           }
-           //else little endian
-           break;
-       case 24:
-           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_SIGNED)
-           {
-               ulFlags |= TWOS_COMPLEMENT;
-           }
-           //else unsigned
-
-           if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE))
-           {
-               ulFlags |= BIG_ENDIAN;
-           }
-           //else little endian
-           break;
-       case 32:
-           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_SIGNED)
-           {
-               ulFlags |= TWOS_COMPLEMENT;
-           }
-           //else unsigned
-
-           if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE))
-           {
-               ulFlags |= BIG_ENDIAN;
-           }
-           //else little endian
-           break;
-       }//switch BPS
-       break;
+           //NOTE1: The default for 8 bps is unsigned and signed for > 8 bps !!!
+           //NOTE2: The default byte order for > 8 bps is little endian
+
+           switch(ulBitsPerSample)
+           {
+           case 8:
+                   //default = unsigned
+                   break;
+           case 16:
+                   //default = signed
+                   ulFlags |= TWOS_COMPLEMENT;
+
+                   if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE))
+                   {
+                           ulFlags |= BIG_ENDIAN;
+                   }
+                   //else little endian
+                   break;
+           case 24:
+                   if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_SIGNED)
+                   {
+                           ulFlags |= TWOS_COMPLEMENT;
+                   }
+                   //else unsigned
+
+                   if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE))
+                   {
+                           ulFlags |= BIG_ENDIAN;
+                   }
+                   //else little endian
+                   break;
+           case 32:
+                   if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_SIGNED)
+                   {
+                           ulFlags |= TWOS_COMPLEMENT;
+                   }
+                   //else unsigned
+
+                   if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE))
+                   {
+                           ulFlags |= BIG_ENDIAN;
+                   }
+                   //else little endian
+                   break;
+           }//switch BPS
+           break;
 
    case DATATYPE_ALAW:
    case DATATYPE_RIFF_ALAW:
    case A_LAW:
-       break;
+           break;
 
    case DATATYPE_MULAW:
    case DATATYPE_RIFF_MULAW:
    case MU_LAW:
-       break;
+           break;
 
    case DATATYPE_ADPCM_AVC:
    case DATATYPE_CT_ADPCM:
-       break;
+           break;
 
    default:
-       DebugInt3();
-       return 0;
+           DebugInt3();
+           return 0;
    }
    return ulFlags;
@@ -294 +294 @@
 //******************************************************************************
 ULONG WAVEAUDIO::QueryOSSDataFormat(ULONG ulOperation, ULONG ulDataType,
-                                    ULONG ulBitsPerSample)
+                                                                        ULONG ulBitsPerSample)
 {
    ULONG ulDataFormat;
@@ -300 +300 @@
 
    if(ulOperation == OPERATION_PLAY) {
-        pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
+                pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
    }
    else pWaveCaps = &devCaps[ulDeviceNr].waveInCaps;
@@ -308 +308 @@
    case DATATYPE_WAVEFORM:
    case PCM:
-       //NOTE1: The default for 8 bps is unsigned and signed for > 8 bps !!!
-       //NOTE2: The default byte order for > 8 bps is little endian
-       switch(ulBitsPerSample)
-       {
-       case 8:
-           //Default is unsigned, so check that first
-           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8)
-           {
-                ulDataFormat = OSS32_PCM_FORMAT_U8;
-           }
-           else ulDataFormat = OSS32_PCM_FORMAT_S8;
-           break;
-
-       case 16:
-           //Default is signed, so check that first
-           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED)
-           {//signed LE or BE
-               //Default is LE, so check that first
-               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE)
-               {
-                    ulDataFormat = OSS32_PCM_FORMAT_S16_LE;
-               }
-               else ulDataFormat = OSS32_PCM_FORMAT_S16_BE;
-           }
-           else
-           {//unsigned LE or BE
-               //Default is LE, so check that first
-               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE)
-               {
-                    ulDataFormat = OSS32_PCM_FORMAT_U16_LE;
-               }
-               else ulDataFormat = OSS32_PCM_FORMAT_U16_BE;
-           }
-           break;
-
-       case 24:
-           //Default is signed, so check that first
-           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_SIGNED)
-           {//signed LE or BE
-               //Default is LE, so check that first
-               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE)
-               {
-                    ulDataFormat = OSS32_PCM_FORMAT_S24_LE;
-               }
-               else ulDataFormat = OSS32_PCM_FORMAT_S24_BE;
-           }
-           else
-           {//unsigned LE or BE
-               //Default is LE, so check that first
-               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE)
-               {
-                    ulDataFormat = OSS32_PCM_FORMAT_U24_LE;
-               }
-               else ulDataFormat = OSS32_PCM_FORMAT_U24_BE;
-           }
-           break;
-
-       case 32:
-           //Default is signed, so check that first
-           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_SIGNED)
-           {//signed LE or BE
-               //Default is LE, so check that first
-               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE)
-               {
-                    ulDataFormat = OSS32_PCM_FORMAT_S32_LE;
-               }
-               else ulDataFormat = OSS32_PCM_FORMAT_S32_BE;
-           }
-           else
-           {//unsigned LE or BE
-               //Default is LE, so check that first
-               if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE)
-               {
-                    ulDataFormat = OSS32_PCM_FORMAT_U32_LE;
-               }
-               else ulDataFormat = OSS32_PCM_FORMAT_U32_BE;
-           }
-           break;
-       }//switch BPS
-       break;
+           //NOTE1: The default for 8 bps is unsigned and signed for > 8 bps !!!
+           //NOTE2: The default byte order for > 8 bps is little endian
+           switch(ulBitsPerSample)
+           {
+           case 8:
+                   //Default is unsigned, so check that first
+                   if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8)
+                   {
+                                ulDataFormat = OSS32_PCM_FORMAT_U8;
+                   }
+                   else ulDataFormat = OSS32_PCM_FORMAT_S8;
+                   break;
+
+           case 16:
+                   //Default is signed, so check that first
+                   if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED)
+                   {//signed LE or BE
+                           //Default is LE, so check that first
+                           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE)
+                           {
+                                        ulDataFormat = OSS32_PCM_FORMAT_S16_LE;
+                           }
+                           else ulDataFormat = OSS32_PCM_FORMAT_S16_BE;
+                   }
+                   else
+                   {//unsigned LE or BE
+                           //Default is LE, so check that first
+                           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_LE)
+                           {
+                                        ulDataFormat = OSS32_PCM_FORMAT_U16_LE;
+                           }
+                           else ulDataFormat = OSS32_PCM_FORMAT_U16_BE;
+                   }
+                   break;
+
+           case 24:
+                   //Default is signed, so check that first
+                   if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_SIGNED)
+                   {//signed LE or BE
+                           //Default is LE, so check that first
+                           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE)
+                           {
+                                        ulDataFormat = OSS32_PCM_FORMAT_S24_LE;
+                           }
+                           else ulDataFormat = OSS32_PCM_FORMAT_S24_BE;
+                   }
+                   else
+                   {//unsigned LE or BE
+                           //Default is LE, so check that first
+                           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS_LE)
+                           {
+                                        ulDataFormat = OSS32_PCM_FORMAT_U24_LE;
+                           }
+                           else ulDataFormat = OSS32_PCM_FORMAT_U24_BE;
+                   }
+                   break;
+
+           case 32:
+                   //Default is signed, so check that first
+                   if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_SIGNED)
+                   {//signed LE or BE
+                           //Default is LE, so check that first
+                           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE)
+                           {
+                                        ulDataFormat = OSS32_PCM_FORMAT_S32_LE;
+                           }
+                           else ulDataFormat = OSS32_PCM_FORMAT_S32_BE;
+                   }
+                   else
+                   {//unsigned LE or BE
+                           //Default is LE, so check that first
+                           if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS_LE)
+                           {
+                                        ulDataFormat = OSS32_PCM_FORMAT_U32_LE;
+                           }
+                           else ulDataFormat = OSS32_PCM_FORMAT_U32_BE;
+                   }
+                   break;
+           }//switch BPS
+           break;
 
    case DATATYPE_ALAW:
    case DATATYPE_RIFF_ALAW:
    case A_LAW:
-       ulDataFormat = OSS32_PCM_FORMAT_ALAW;
-       break;
+           ulDataFormat = OSS32_PCM_FORMAT_ALAW;
+           break;
 
    case DATATYPE_MULAW:
    case DATATYPE_RIFF_MULAW:
    case MU_LAW:
-       ulDataFormat = OSS32_PCM_FORMAT_MULAW;
-       break;
+           ulDataFormat = OSS32_PCM_FORMAT_MULAW;
+           break;
 
    case DATATYPE_ADPCM_AVC:
    case DATATYPE_CT_ADPCM:
-       ulDataFormat = OSS32_PCM_FORMAT_ADPCM;
-       break;
+           ulDataFormat = OSS32_PCM_FORMAT_ADPCM;
+           break;
 
    default:
-       dprintf(("DataFormat wrong:%x",ulBitsPerSample));
-       DebugInt3();
-       return 0;
+           rprintf(("DataFormat wrong:%x",ulBitsPerSample));
+           DebugInt3();
+           return 0;
    }
    return ulDataFormat;  //flag to format type
@@ -417 +417 @@
 //******************************************************************************
 BOOL WAVEAUDIO::SetupConversion(PWAVECONFIGINFO pConfigInfo,
-                                ULONG ulOperation, ULONG ulDataType,
-                                ULONG ulNumChannels, ULONG ulBitsPerSample)
-{
-    USHORT usConversion;
-    PWAVE_CAPS pWaveCaps;
-    ULONG  ulNrSampleRates;
-
-    usConversion = CONVERT_NONE;
-
-    if(ulOperation == OPERATION_PLAY) {
-         pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
-    }
-    else pWaveCaps = &devCaps[ulDeviceNr].waveInCaps;
-
-    //Check if hardware only supports one sample rate; if true, then we perform
-    //manual sample rate conversion before sending buffers to the ALSA driver
-    FindMatchingSampleRate(pConfigInfo->ulSampleRate, pWaveCaps->ulRateFlags, &ulNrSampleRates, &pConfigInfo->ulFixedSampleRate);
-    if(ulNrSampleRates <= 2 && pConfigInfo->ulSampleRate != pConfigInfo->ulFixedSampleRate) {
-        pConfigInfo->fSampleRateConversion = TRUE;
-    }
-    else {
-        pConfigInfo->fSampleRateConversion = FALSE;
-    }
-
-    //check if mono/stereo conversion is necessary
-    if(ulNumChannels < pWaveCaps->ulMinChannels) {
-        if(ulNumChannels == 1) {
-            if(ulOperation == OPERATION_PLAY)
-                 usConversion |= CONVERT_MONO_STEREO;
-            else usConversion |= CONVERT_STEREO_MONO;
-        }
-        else DebugInt3();
-    }
-    else
-    if(ulNumChannels > pWaveCaps->ulMaxChannels) {
-        if(ulNumChannels == 2) {
-            if(ulOperation == OPERATION_PLAY)
-                 usConversion |= CONVERT_STEREO_MONO;
-            else usConversion |= CONVERT_MONO_STEREO;
-        }
-        else DebugInt3();
-    }
-
-    //check for sample bit conversion
-    switch(ulDataType) {
-    case DATATYPE_NULL: //Warp 3 buggy data type
-    case DATATYPE_WAVEFORM:
-    case PCM:
-        switch(ulBitsPerSample)
-        {
-        case 8:
-            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_8BPS))
-            {
-                if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS)) {
-                    DebugInt3();
-                    return FALSE;
-                }
-                if(ulOperation == OPERATION_PLAY)
-                     usConversion |= CONVERT_8_16;
-                else usConversion |= CONVERT_16_8;
-
-                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED)
-                {
-                    if(ulOperation == OPERATION_PLAY) {
-                         usConversion |= CONVERT_UNSIGNED_TO_SIGNED;
-                    }
-                    else usConversion |= CONVERT_SIGNED_TO_UNSIGNED;
-                }
-                else usConversion |= CONVERT_UNSIGNED;  //unsigned to unsigned
-            }
-            else
-            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8) &&
-                (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S8))
-            {
-                if(ulOperation == OPERATION_PLAY)
-                     usConversion |= (CONVERT_UNSIGNED_TO_SIGNED | CONVERT_8BPS);
-                else usConversion |= (CONVERT_SIGNED_TO_UNSIGNED | CONVERT_8BPS);
-            }
-            else {
-                if(usConversion != CONVERT_NONE) {
-                    usConversion |= (CONVERT_8BPS | CONVERT_UNSIGNED);
-                }
-            }
-            break;
-
-        case 16:
-            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS))
-            {
-                if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_8BPS)) {
-                    DebugInt3();
-                    return FALSE;
-                }
-                if(ulOperation == OPERATION_PLAY)
-                     usConversion |= CONVERT_16_8;
-                else usConversion |= CONVERT_8_16;
-
-                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8)
-                {
-                    if(ulOperation == OPERATION_PLAY) {
-                         usConversion |= CONVERT_SIGNED_TO_UNSIGNED;
-                    }
-                    else usConversion |= CONVERT_UNSIGNED_TO_SIGNED;
-                }
-                else usConversion |= CONVERT_SIGNED;  //signed to signed
-            }
-            else
-            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED) &&
-                (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_UNSIGNED))
-            {
-                if(ulOperation == OPERATION_PLAY)
-                     usConversion |= (CONVERT_SIGNED_TO_UNSIGNED | CONVERT_16BPS);
-                else usConversion |= (CONVERT_UNSIGNED_TO_SIGNED | CONVERT_16BPS);
-            }
-            else {
-                if(usConversion != CONVERT_NONE) {
-                    usConversion |= (CONVERT_16BPS | CONVERT_SIGNED);
-                }
-            }
-            break;
-        }
-        break;
-
-    case DATATYPE_ALAW:
-    case DATATYPE_RIFF_ALAW:
-    case A_LAW:
-    case DATATYPE_MULAW:
-    case DATATYPE_RIFF_MULAW:
-    case MU_LAW:
-    case DATATYPE_ADPCM_AVC:
-    case DATATYPE_CT_ADPCM:
-    default:
-        DebugInt3();
-        return FALSE;
-    }
-
-    pConfigInfo->usConversion = usConversion;
-
-    switch(usConversion) {
-    case CONVERT_NONE:
-        pConfigInfo->usConversion = CONVERT_NONE;
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = ConvertNone;
-//        dprintf(("CNV_NONE"));
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_8_SIGNED:
-    case CONVERT_8_SIGNED_TO_8_UNSIGNED:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = Convert8To8SignChange;
-//        dprintf(("CNV_8_U_TO_8_S/CNV_8_S_TO_8_U"));
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_8_UNSIGNED_MONO_STEREO:
-    case CONVERT_8_SIGNED_TO_8_SIGNED_MONO_STEREO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);   //factor 2
-        pConfigInfo->pfnConvert = Convert8MonoTo8Stereo;
-//        dprintf(("CNV_8_U_TO_8_U_MN_ST/CNV_8_S_TO_8_S_MN_ST"));
-        break;
-
-    case CONVERT_8_SIGNED_TO_8_UNSIGNED_MONO_STEREO:
-    case CONVERT_8_UNSIGNED_TO_8_SIGNED_MONO_STEREO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);   //factor 2
-        pConfigInfo->pfnConvert = Convert8MonoTo8StereoSignChange;
-//        dprintf(("CNV_8_S_TO_8_U_MN_ST/CNV_8_U_TO_8_S_MN_ST"));
-        break;
-
-    case CONVERT_8_SIGNED_TO_16_SIGNED:
-    case CONVERT_8_UNSIGNED_TO_16_UNSIGNED:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);   //factor 2
-        pConfigInfo->pfnConvert = Convert8To16;
-//        dprintf(("CNV_8_S_TO_16_S/CNV_8_U_TO_16_U"));
-        break;
-
-    case CONVERT_8_SIGNED_TO_16_UNSIGNED:
-    case CONVERT_8_UNSIGNED_TO_16_SIGNED:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);   //factor 2
-        pConfigInfo->pfnConvert = Convert8To16SignChange;
-        //dprintf(("CNV_8_S_TO_16_U/CNV_8_U_TO_16_S"));
-        break;
-
-    case CONVERT_8_SIGNED_TO_16_SIGNED_MONO_STEREO:
-    case CONVERT_8_UNSIGNED_TO_16_UNSIGNED_MONO_STEREO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(2,0);   //factor 4
-        pConfigInfo->pfnConvert = Convert8MonoTo16Stereo;
-        //dprintf(("CNV_8_S_TO_16_S_MN_ST/CNV_8_U_TO_16_U_MN_ST"));
-        break;
-
-    case CONVERT_8_SIGNED_TO_16_UNSIGNED_MONO_STEREO:
-    case CONVERT_8_UNSIGNED_TO_16_SIGNED_MONO_STEREO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(2,0);   //factor 4
-        pConfigInfo->pfnConvert = Convert8MonoTo16StereoSignChange;
-        //dprintf(("CNV_8_S_TO_16_U_MN_ST/CNV_8_U_TO_16_S_MN_ST"));
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_8_UNSIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert8UnsignedTo8UnsignedStereoMono;
-        //dprintf(("CNV_8_U_TO_8_U_ST_MN"));
-        break;
-
-    case CONVERT_8_SIGNED_TO_8_SIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert8SignedTo8SignedStereoMono;
-        //dprintf(("CNV_8_S_TO_8_S_ST_MN"));
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_8_SIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert8UnsignedTo8SignedStereoMono;
-        //dprintf(("CNV_8_U_TO_8_S_ST_MN"));
-        break;
-
-    case CONVERT_8_SIGNED_TO_8_UNSIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert8SignedTo8UnsignedStereoMono;
-        //dprintf(("CNV_8_S_TO_8_U_ST_MN"));
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_16_UNSIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = Convert8UnsignedTo16UnsignedStereoMono;
-        //dprintf(("CNV_8_U_TO_16_U_ST_MN"));
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_16_SIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = Convert8UnsignedTo16SignedStereoMono;
-        //dprintf(("CNV_8_U_TO_16_S_ST_MN"));
-        break;
-
-    case CONVERT_8_SIGNED_TO_16_SIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = Convert8SignedTo16SignedStereoMono;
-        //dprintf(("CNV_8_S_TO_16_S_ST_MN"));
-        break;
-
-    case CONVERT_8_SIGNED_TO_16_UNSIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = Convert8SignedTo16UnsignedStereoMono;
-        //dprintf(("CNV_8_S_TO_16_U_ST_MN"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_16_SIGNED:
-    case CONVERT_16_SIGNED_TO_16_UNSIGNED:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = Convert16To16SignChange;
-        //dprintf(("CNV_16_U_TO_16_S/CNV_16_S_TO_16_U"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_8_UNSIGNED:
-    case CONVERT_16_SIGNED_TO_8_SIGNED:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert16To8;
-        //dprintf(("CNV_16_U_TO_8_U/CNV_16_S_TO_8_S"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_8_SIGNED:
-    case CONVERT_16_SIGNED_TO_8_UNSIGNED:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert16To8SignChange;
-        //dprintf(("CNV_16_U_TO_8_S/CNV_16_S_TO_8_U"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_16_UNSIGNED_MONO_STEREO:
-    case CONVERT_16_SIGNED_TO_16_SIGNED_MONO_STEREO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);   //factor 2
-        pConfigInfo->pfnConvert = Convert16MonoTo16Stereo;
-        //dprintf(("CNV_16_U_TO_16_U_MN_ST/CNV_16_S_TO_16_S_MN_ST"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_16_SIGNED_MONO_STEREO:
-    case CONVERT_16_SIGNED_TO_16_UNSIGNED_MONO_STEREO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);   //factor 2
-        pConfigInfo->pfnConvert = Convert16MonoTo16StereoSignChange;
-        //dprintf(("CNV_16_U_TO_16_S_MN_ST/CNV_16_S_TO_16_U_MN_ST"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_8_UNSIGNED_MONO_STEREO:
-    case CONVERT_16_SIGNED_TO_8_UNSIGNED_MONO_STEREO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = Convert16MonoTo8Stereo;
-        //dprintf(("CNV_16_U_TO_8_U_MONO_ST/CNV_16_S_TO_8_U_MN_ST"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_8_SIGNED_MONO_STEREO:
-    case CONVERT_16_SIGNED_TO_8_SIGNED_MONO_STEREO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = Convert16MonoTo8StereoSignChange;
-        //dprintf(("CNV_16_U_TO_8_S_MN_ST/CNV_16_S_TO_8_S_MN_ST"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_16_SIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert16UnsignedTo16SignedStereoMono;
-        //dprintf(("CNV_16_U_TO_16_S_ST_MN"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_16_UNSIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert16UnsignedTo16UnsignedStereoMono;
-        //dprintf(("CNV_16_U_TO_16_U_ST_MN"));
-        break;
-
-    case CONVERT_16_SIGNED_TO_16_SIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert16SignedTo16SignedStereoMono;
-        //dprintf(("CNV_16_S_TO_16_S_ST_MN"));
-        break;
-
-    case CONVERT_16_SIGNED_TO_16_UNSIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);   //factor 0.5
-        pConfigInfo->pfnConvert = Convert16SignedTo16UnsignedStereoMono;
-        //dprintf(("CNV_16_S_TO_16_U_ST_MN"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_8_UNSIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,2);   //factor 0.25
-        pConfigInfo->pfnConvert = Convert16UnsignedTo8UnsignedStereoMono;
-        //dprintf(("CNV_16_U_TO_8_U_ST_MN"));
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_8_SIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,2);   //factor 0.25
-        pConfigInfo->pfnConvert = Convert16UnsignedTo8SignedStereoMono;
-        //dprintf(("CNV_16_U_TO_8_S_ST_MN"));
-        break;
-
-    case CONVERT_16_SIGNED_TO_8_SIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,2);   //factor 0.25
-        pConfigInfo->pfnConvert = Convert16SignedTo8SignedStereoMono;
-        //dprintf(("CNV_16_S_TO_8_S_ST_MN"));
-        break;
-
-    case CONVERT_16_SIGNED_TO_8_UNSIGNED_STEREO_MONO:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,2);   //factor 0.25
-        pConfigInfo->pfnConvert = Convert16SignedTo8UnsignedStereoMono;
-        //dprintf(("CNV_16_S_TO_8_U_ST_MN"));
-        break;
-
-    default:
-        pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);   //factor 1
-        pConfigInfo->pfnConvert = NULL;
-        DebugInt3();
-        return FALSE;
-    }
-
-    dprintf(("Cnv factor %lx", pConfigInfo->ulConversionFactor));
-
-    //Some hardware can't do full duplex with different sample rates (e.g. ALS4000)
-    //NOTE: This isn't going to be pretty if the other active stream has a much lower
-    //      sample rate...
-    if(pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_HALFDUPLEX) {
-        WAVESTREAM *pWaveStream;
-
-        pWaveStream = (WAVESTREAM *)FindActiveStream((ulOperation == OPERATION_PLAY) ? STREAM_WAVE_CAPTURE : STREAM_WAVE_PLAY);
-        if(pWaveStream != NULL) {
-            pConfigInfo->ulFixedSampleRate     = pWaveStream->GetProperty(PROPERTY_FREQUENCY);
-            pConfigInfo->fSampleRateConversion = TRUE;
-            dprintf(("Force sample rate cnv for legacy hardware -> %d", pConfigInfo->ulFixedSampleRate));
-        }
-    }
-
-    if(pConfigInfo->fSampleRateConversion)
-    {
-        if(QuerySampleFormat(ulOperation, pConfigInfo) == TRUE)
-        {
-            if(pConfigInfo->ulHwBitsPerSample == 8) {
-                if(pConfigInfo->ulHwNumChannels == 2) {
-                     pConfigInfo->pfnSRateConv = SRateConvert8Stereo;
-                }
-                else pConfigInfo->pfnSRateConv = SRateConvert8Mono;
-            }
-            else
-            if(pConfigInfo->ulHwBitsPerSample == 16) {
-                if(pConfigInfo->ulHwNumChannels == 2) {
-                     pConfigInfo->pfnSRateConv = SRateConvert16Stereo;
-                }
-                else pConfigInfo->pfnSRateConv = SRateConvert16Mono;
-            }
-            else {
-                pConfigInfo->pfnSRateConv = NULL;
-                DebugInt3();
-            }
-            pConfigInfo->ulSRatePosition  = 0;
-            if(ulOperation == OPERATION_PLAY) {
-                 pConfigInfo->ulSRateIncrement = SRATE_CALC_INCREMENT(pConfigInfo->ulFixedSampleRate, pConfigInfo->ulSampleRate);
-            }
-            else pConfigInfo->ulSRateIncrement = SRATE_CALC_INCREMENT_INVERT(pConfigInfo->ulFixedSampleRate, pConfigInfo->ulSampleRate);
-
-            dprintf(("Sample rate cnv: increment %ld", pConfigInfo->ulSRateIncrement));
-        }
-        else {
-            pConfigInfo->pfnSRateConv = NULL;
-            DebugInt3();
-            return FALSE;
-        }
-    }
-    return TRUE;
+                                                                ULONG ulOperation, ULONG ulDataType,
+                                                                ULONG ulNumChannels, ULONG ulBitsPerSample)
+{
+        USHORT usConversion;
+        PWAVE_CAPS pWaveCaps;
+        ULONG  ulNrSampleRates;
+
+        usConversion = CONVERT_NONE;
+
+        if(ulOperation == OPERATION_PLAY) {
+                 pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
+        }
+        else pWaveCaps = &devCaps[ulDeviceNr].waveInCaps;
+
+        //Check if hardware only supports one sample rate; if true, then we perform
+        //manual sample rate conversion before sending buffers to the ALSA driver
+        FindMatchingSampleRate(pConfigInfo->ulSampleRate, pWaveCaps->ulRateFlags, &ulNrSampleRates, &pConfigInfo->ulFixedSampleRate);
+        if(ulNrSampleRates <= 2 && pConfigInfo->ulSampleRate != pConfigInfo->ulFixedSampleRate) {
+                pConfigInfo->fSampleRateConversion = TRUE;
+        }
+        else {
+                pConfigInfo->fSampleRateConversion = FALSE;
+        }
+
+        //check if mono/stereo conversion is necessary
+        if(ulNumChannels < pWaveCaps->ulMinChannels) {
+                if(ulNumChannels == 1) {
+                        if(ulOperation == OPERATION_PLAY)
+                                 usConversion |= CONVERT_MONO_STEREO;
+                        else usConversion |= CONVERT_STEREO_MONO;
+                }
+                else DebugInt3();
+        }
+        else
+        if(ulNumChannels > pWaveCaps->ulMaxChannels) {
+                if(ulNumChannels == 2) {
+                        if(ulOperation == OPERATION_PLAY)
+                                 usConversion |= CONVERT_STEREO_MONO;
+                        else usConversion |= CONVERT_MONO_STEREO;
+                }
+                else DebugInt3();
+        }
+
+        //check for sample bit conversion
+        switch(ulDataType) {
+        case DATATYPE_NULL: //Warp 3 buggy data type
+        case DATATYPE_WAVEFORM:
+        case PCM:
+                switch(ulBitsPerSample)
+                {
+                case 8:
+                        if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_8BPS))
+                        {
+                                if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS)) {
+                                        DebugInt3();
+                                        return FALSE;
+                                }
+                                if(ulOperation == OPERATION_PLAY)
+                                         usConversion |= CONVERT_8_16;
+                                else usConversion |= CONVERT_16_8;
+
+                                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED)
+                                {
+                                        if(ulOperation == OPERATION_PLAY) {
+                                                 usConversion |= CONVERT_UNSIGNED_TO_SIGNED;
+                                        }
+                                        else usConversion |= CONVERT_SIGNED_TO_UNSIGNED;
+                                }
+                                else usConversion |= CONVERT_UNSIGNED;  //unsigned to unsigned
+                        }
+                        else
+                        if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8) &&
+                                (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_S8))
+                        {
+                                if(ulOperation == OPERATION_PLAY)
+                                         usConversion |= (CONVERT_UNSIGNED_TO_SIGNED | CONVERT_8BPS);
+                                else usConversion |= (CONVERT_SIGNED_TO_UNSIGNED | CONVERT_8BPS);
+                        }
+                        else {
+                                if(usConversion != CONVERT_NONE) {
+                                        usConversion |= (CONVERT_8BPS | CONVERT_UNSIGNED);
+                                }
+                        }
+                        break;
+
+                case 16:
+                        if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS))
+                        {
+                                if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_8BPS)) {
+                                        DebugInt3();
+                                        return FALSE;
+                                }
+                                if(ulOperation == OPERATION_PLAY)
+                                         usConversion |= CONVERT_16_8;
+                                else usConversion |= CONVERT_8_16;
+
+                                if(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_U8)
+                                {
+                                        if(ulOperation == OPERATION_PLAY) {
+                                                 usConversion |= CONVERT_SIGNED_TO_UNSIGNED;
+                                        }
+                                        else usConversion |= CONVERT_UNSIGNED_TO_SIGNED;
+                                }
+                                else usConversion |= CONVERT_SIGNED;  //signed to signed
+                        }
+                        else
+                        if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_SIGNED) &&
+                                (pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_16BPS_UNSIGNED))
+                        {
+                                if(ulOperation == OPERATION_PLAY)
+                                         usConversion |= (CONVERT_SIGNED_TO_UNSIGNED | CONVERT_16BPS);
+                                else usConversion |= (CONVERT_UNSIGNED_TO_SIGNED | CONVERT_16BPS);
+                        }
+                        else {
+                                if(usConversion != CONVERT_NONE) {
+                                        usConversion |= (CONVERT_16BPS | CONVERT_SIGNED);
+                                }
+                        }
+                        break;
+                }
+                break;
+
+        case DATATYPE_ALAW:
+        case DATATYPE_RIFF_ALAW:
+        case A_LAW:
+        case DATATYPE_MULAW:
+        case DATATYPE_RIFF_MULAW:
+        case MU_LAW:
+        case DATATYPE_ADPCM_AVC:
+        case DATATYPE_CT_ADPCM:
+        default:
+                DebugInt3();
+                return FALSE;
+        }
+
+        pConfigInfo->usConversion = usConversion;
+
+        switch(usConversion) {
+        case CONVERT_NONE:
+                pConfigInfo->usConversion = CONVERT_NONE;
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = ConvertNone;
+//                dprintf(("CNV_NONE"));
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_8_SIGNED:
+        case CONVERT_8_SIGNED_TO_8_UNSIGNED:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = Convert8To8SignChange;
+//                dprintf(("CNV_8_U_TO_8_S/CNV_8_S_TO_8_U"));
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_8_UNSIGNED_MONO_STEREO:
+        case CONVERT_8_SIGNED_TO_8_SIGNED_MONO_STEREO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);       //factor 2
+                pConfigInfo->pfnConvert = Convert8MonoTo8Stereo;
+//                dprintf(("CNV_8_U_TO_8_U_MN_ST/CNV_8_S_TO_8_S_MN_ST"));
+                break;
+
+        case CONVERT_8_SIGNED_TO_8_UNSIGNED_MONO_STEREO:
+        case CONVERT_8_UNSIGNED_TO_8_SIGNED_MONO_STEREO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);       //factor 2
+                pConfigInfo->pfnConvert = Convert8MonoTo8StereoSignChange;
+//                dprintf(("CNV_8_S_TO_8_U_MN_ST/CNV_8_U_TO_8_S_MN_ST"));
+                break;
+
+        case CONVERT_8_SIGNED_TO_16_SIGNED:
+        case CONVERT_8_UNSIGNED_TO_16_UNSIGNED:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);       //factor 2
+                pConfigInfo->pfnConvert = Convert8To16;
+//                dprintf(("CNV_8_S_TO_16_S/CNV_8_U_TO_16_U"));
+                break;
+
+        case CONVERT_8_SIGNED_TO_16_UNSIGNED:
+        case CONVERT_8_UNSIGNED_TO_16_SIGNED:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);       //factor 2
+                pConfigInfo->pfnConvert = Convert8To16SignChange;
+                //dprintf(("CNV_8_S_TO_16_U/CNV_8_U_TO_16_S"));
+                break;
+
+        case CONVERT_8_SIGNED_TO_16_SIGNED_MONO_STEREO:
+        case CONVERT_8_UNSIGNED_TO_16_UNSIGNED_MONO_STEREO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(2,0);       //factor 4
+                pConfigInfo->pfnConvert = Convert8MonoTo16Stereo;
+                //dprintf(("CNV_8_S_TO_16_S_MN_ST/CNV_8_U_TO_16_U_MN_ST"));
+                break;
+
+        case CONVERT_8_SIGNED_TO_16_UNSIGNED_MONO_STEREO:
+        case CONVERT_8_UNSIGNED_TO_16_SIGNED_MONO_STEREO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(2,0);       //factor 4
+                pConfigInfo->pfnConvert = Convert8MonoTo16StereoSignChange;
+                //dprintf(("CNV_8_S_TO_16_U_MN_ST/CNV_8_U_TO_16_S_MN_ST"));
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_8_UNSIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert8UnsignedTo8UnsignedStereoMono;
+                //dprintf(("CNV_8_U_TO_8_U_ST_MN"));
+                break;
+
+        case CONVERT_8_SIGNED_TO_8_SIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert8SignedTo8SignedStereoMono;
+                //dprintf(("CNV_8_S_TO_8_S_ST_MN"));
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_8_SIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert8UnsignedTo8SignedStereoMono;
+                //dprintf(("CNV_8_U_TO_8_S_ST_MN"));
+                break;
+
+        case CONVERT_8_SIGNED_TO_8_UNSIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert8SignedTo8UnsignedStereoMono;
+                //dprintf(("CNV_8_S_TO_8_U_ST_MN"));
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_16_UNSIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = Convert8UnsignedTo16UnsignedStereoMono;
+                //dprintf(("CNV_8_U_TO_16_U_ST_MN"));
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_16_SIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = Convert8UnsignedTo16SignedStereoMono;
+                //dprintf(("CNV_8_U_TO_16_S_ST_MN"));
+                break;
+
+        case CONVERT_8_SIGNED_TO_16_SIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = Convert8SignedTo16SignedStereoMono;
+                //dprintf(("CNV_8_S_TO_16_S_ST_MN"));
+                break;
+
+        case CONVERT_8_SIGNED_TO_16_UNSIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = Convert8SignedTo16UnsignedStereoMono;
+                //dprintf(("CNV_8_S_TO_16_U_ST_MN"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_16_SIGNED:
+        case CONVERT_16_SIGNED_TO_16_UNSIGNED:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = Convert16To16SignChange;
+                //dprintf(("CNV_16_U_TO_16_S/CNV_16_S_TO_16_U"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_8_UNSIGNED:
+        case CONVERT_16_SIGNED_TO_8_SIGNED:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert16To8;
+                //dprintf(("CNV_16_U_TO_8_U/CNV_16_S_TO_8_S"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_8_SIGNED:
+        case CONVERT_16_SIGNED_TO_8_UNSIGNED:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert16To8SignChange;
+                //dprintf(("CNV_16_U_TO_8_S/CNV_16_S_TO_8_U"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_16_UNSIGNED_MONO_STEREO:
+        case CONVERT_16_SIGNED_TO_16_SIGNED_MONO_STEREO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);       //factor 2
+                pConfigInfo->pfnConvert = Convert16MonoTo16Stereo;
+                //dprintf(("CNV_16_U_TO_16_U_MN_ST/CNV_16_S_TO_16_S_MN_ST"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_16_SIGNED_MONO_STEREO:
+        case CONVERT_16_SIGNED_TO_16_UNSIGNED_MONO_STEREO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(1,0);       //factor 2
+                pConfigInfo->pfnConvert = Convert16MonoTo16StereoSignChange;
+                //dprintf(("CNV_16_U_TO_16_S_MN_ST/CNV_16_S_TO_16_U_MN_ST"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_8_UNSIGNED_MONO_STEREO:
+        case CONVERT_16_SIGNED_TO_8_UNSIGNED_MONO_STEREO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = Convert16MonoTo8Stereo;
+                //dprintf(("CNV_16_U_TO_8_U_MONO_ST/CNV_16_S_TO_8_U_MN_ST"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_8_SIGNED_MONO_STEREO:
+        case CONVERT_16_SIGNED_TO_8_SIGNED_MONO_STEREO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = Convert16MonoTo8StereoSignChange;
+                //dprintf(("CNV_16_U_TO_8_S_MN_ST/CNV_16_S_TO_8_S_MN_ST"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_16_SIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert16UnsignedTo16SignedStereoMono;
+                //dprintf(("CNV_16_U_TO_16_S_ST_MN"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_16_UNSIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert16UnsignedTo16UnsignedStereoMono;
+                //dprintf(("CNV_16_U_TO_16_U_ST_MN"));
+                break;
+
+        case CONVERT_16_SIGNED_TO_16_SIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert16SignedTo16SignedStereoMono;
+                //dprintf(("CNV_16_S_TO_16_S_ST_MN"));
+                break;
+
+        case CONVERT_16_SIGNED_TO_16_UNSIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,1);       //factor 0.5
+                pConfigInfo->pfnConvert = Convert16SignedTo16UnsignedStereoMono;
+                //dprintf(("CNV_16_S_TO_16_U_ST_MN"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_8_UNSIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,2);       //factor 0.25
+                pConfigInfo->pfnConvert = Convert16UnsignedTo8UnsignedStereoMono;
+                //dprintf(("CNV_16_U_TO_8_U_ST_MN"));
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_8_SIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,2);       //factor 0.25
+                pConfigInfo->pfnConvert = Convert16UnsignedTo8SignedStereoMono;
+                //dprintf(("CNV_16_U_TO_8_S_ST_MN"));
+                break;
+
+        case CONVERT_16_SIGNED_TO_8_SIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,2);       //factor 0.25
+                pConfigInfo->pfnConvert = Convert16SignedTo8SignedStereoMono;
+                //dprintf(("CNV_16_S_TO_8_S_ST_MN"));
+                break;
+
+        case CONVERT_16_SIGNED_TO_8_UNSIGNED_STEREO_MONO:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,2);       //factor 0.25
+                pConfigInfo->pfnConvert = Convert16SignedTo8UnsignedStereoMono;
+                //dprintf(("CNV_16_S_TO_8_U_ST_MN"));
+                break;
+
+        default:
+                pConfigInfo->ulConversionFactor = CONVERSION_FACTOR(0,0);       //factor 1
+                pConfigInfo->pfnConvert = NULL;
+                DebugInt3();
+                return FALSE;
+        }
+
+        dprintf(("Cnv factor %lx", pConfigInfo->ulConversionFactor));
+
+        //Some hardware can't do full duplex with different sample rates (e.g. ALS4000)
+        //NOTE: This isn't going to be pretty if the other active stream has a much lower
+        //              sample rate...
+        if(pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_HALFDUPLEX) {
+                WAVESTREAM *pWaveStream;
+
+                pWaveStream = (WAVESTREAM *)FindActiveStream((ulOperation == OPERATION_PLAY) ? STREAM_WAVE_CAPTURE : STREAM_WAVE_PLAY);
+                if(pWaveStream != NULL) {
+                        pConfigInfo->ulFixedSampleRate     = pWaveStream->GetProperty(PROPERTY_FREQUENCY);
+                        pConfigInfo->fSampleRateConversion = TRUE;
+                        dprintf(("Force sample rate cnv for legacy hardware -> %d", pConfigInfo->ulFixedSampleRate));
+                }
+        }
+
+        if(pConfigInfo->fSampleRateConversion)
+        {
+                if(QuerySampleFormat(ulOperation, pConfigInfo) == TRUE)
+                {
+                        if(pConfigInfo->ulHwBitsPerSample == 8) {
+                                if(pConfigInfo->ulHwNumChannels == 2) {
+                                         pConfigInfo->pfnSRateConv = SRateConvert8Stereo;
+                                }
+                                else pConfigInfo->pfnSRateConv = SRateConvert8Mono;
+                        }
+                        else
+                        if(pConfigInfo->ulHwBitsPerSample == 16) {
+                                if(pConfigInfo->ulHwNumChannels == 2) {
+                                         pConfigInfo->pfnSRateConv = SRateConvert16Stereo;
+                                }
+                                else pConfigInfo->pfnSRateConv = SRateConvert16Mono;
+                        }
+                        else {
+                                pConfigInfo->pfnSRateConv = NULL;
+                                DebugInt3();
+                        }
+                        pConfigInfo->ulSRatePosition  = 0;
+                        if(ulOperation == OPERATION_PLAY) {
+                                 pConfigInfo->ulSRateIncrement = SRATE_CALC_INCREMENT(pConfigInfo->ulFixedSampleRate, pConfigInfo->ulSampleRate);
+                        }
+                        else pConfigInfo->ulSRateIncrement = SRATE_CALC_INCREMENT_INVERT(pConfigInfo->ulFixedSampleRate, pConfigInfo->ulSampleRate);
+
+                        dprintf(("Sample rate cnv: increment %ld", pConfigInfo->ulSRateIncrement));
+                }
+                else {
+                        pConfigInfo->pfnSRateConv = NULL;
+                        DebugInt3();
+                        return FALSE;
+                }
+        }
+        return TRUE;
 }
 //******************************************************************************
@@ -822 +822 @@
 BOOL WAVEAUDIO::QuerySampleFormat(ULONG ulOperation, PWAVECONFIGINFO pConfigInfo)
 {
-    if(pConfigInfo->ulHwBitsPerSample) {
-        //already determined;
-        return TRUE;
-    }
-    if(pConfigInfo->fSampleRateConversion)
-    {
-        pConfigInfo->ulHwSampleRate = pConfigInfo->ulFixedSampleRate;
-#ifdef DEBUG
-        dprintf(("WA::QuerySampleFormat: SampleRate1 %d", pConfigInfo->ulHwSampleRate));
-#endif
-    }
-    else
-    {
-        pConfigInfo->ulHwSampleRate = pConfigInfo->ulSampleRate;
-#ifdef DEBUG
-        dprintf(("WA::QuerySampleFormat: SampleRate2 %d", pConfigInfo->ulHwSampleRate));
-#endif
-    }
-
-    pConfigInfo->ulHwBitsPerSample = pConfigInfo->ulBitsPerSample;
-    pConfigInfo->ulHwNumChannels   = pConfigInfo->ulNumChannels;
-
-    switch(pConfigInfo->usConversion) {
-    case CONVERT_NONE:
-    case CONVERT_8_UNSIGNED_TO_8_SIGNED:
-    case CONVERT_8_SIGNED_TO_8_UNSIGNED:
-    case CONVERT_16_UNSIGNED_TO_16_SIGNED:
-    case CONVERT_16_SIGNED_TO_16_UNSIGNED:
-        //no change
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_8_SIGNED_MONO_STEREO:
-    case CONVERT_8_SIGNED_TO_8_UNSIGNED_MONO_STEREO:
-    case CONVERT_8_UNSIGNED_TO_8_UNSIGNED_MONO_STEREO:
-    case CONVERT_8_SIGNED_TO_8_SIGNED_MONO_STEREO:
-    case CONVERT_16_UNSIGNED_TO_16_SIGNED_MONO_STEREO:
-    case CONVERT_16_SIGNED_TO_16_UNSIGNED_MONO_STEREO:
-    case CONVERT_16_UNSIGNED_TO_16_UNSIGNED_MONO_STEREO:
-    case CONVERT_16_SIGNED_TO_16_SIGNED_MONO_STEREO:
-        if(ulOperation == OPERATION_PLAY) {
-             pConfigInfo->ulHwNumChannels = 2;
-        }
-        else pConfigInfo->ulHwNumChannels = 1;
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_8_SIGNED_STEREO_MONO:
-    case CONVERT_8_SIGNED_TO_8_UNSIGNED_STEREO_MONO:
-    case CONVERT_8_UNSIGNED_TO_8_UNSIGNED_STEREO_MONO:
-    case CONVERT_8_SIGNED_TO_8_SIGNED_STEREO_MONO:
-    case CONVERT_16_UNSIGNED_TO_16_UNSIGNED_STEREO_MONO:
-    case CONVERT_16_SIGNED_TO_16_SIGNED_STEREO_MONO:
-    case CONVERT_16_UNSIGNED_TO_16_SIGNED_STEREO_MONO:
-    case CONVERT_16_SIGNED_TO_16_UNSIGNED_STEREO_MONO:
-        if(ulOperation == OPERATION_PLAY) {
-             pConfigInfo->ulHwNumChannels = 1;
-        }
-        else pConfigInfo->ulHwNumChannels = 2;
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_16_UNSIGNED:
-    case CONVERT_8_UNSIGNED_TO_16_SIGNED:
-    case CONVERT_8_SIGNED_TO_16_SIGNED:
-    case CONVERT_8_SIGNED_TO_16_UNSIGNED:
-        if(ulOperation == OPERATION_PLAY) {
-             pConfigInfo->ulHwBitsPerSample = 16;
-        }
-        else pConfigInfo->ulHwBitsPerSample = 8;
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_16_UNSIGNED_STEREO_MONO:
-    case CONVERT_8_UNSIGNED_TO_16_SIGNED_STEREO_MONO:
-    case CONVERT_8_SIGNED_TO_16_SIGNED_STEREO_MONO:
-    case CONVERT_8_SIGNED_TO_16_UNSIGNED_STEREO_MONO:
-        if(ulOperation == OPERATION_PLAY) {
-            pConfigInfo->ulHwBitsPerSample = 16;
-            pConfigInfo->ulHwNumChannels   = 1;
-        }
-        else {
-            pConfigInfo->ulHwBitsPerSample = 8;
-            pConfigInfo->ulHwNumChannels   = 2;
-        }
-        break;
-
-    case CONVERT_8_UNSIGNED_TO_16_UNSIGNED_MONO_STEREO:
-    case CONVERT_8_UNSIGNED_TO_16_SIGNED_MONO_STEREO:
-    case CONVERT_8_SIGNED_TO_16_SIGNED_MONO_STEREO:
-    case CONVERT_8_SIGNED_TO_16_UNSIGNED_MONO_STEREO:
-        if(ulOperation == OPERATION_PLAY) {
-            pConfigInfo->ulHwBitsPerSample = 16;
-            pConfigInfo->ulHwNumChannels   = 2;
-        }
-        else {
-            pConfigInfo->ulHwBitsPerSample = 8;
-            pConfigInfo->ulHwNumChannels   = 1;
-        }
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_8_UNSIGNED:
-    case CONVERT_16_UNSIGNED_TO_8_SIGNED:
-    case CONVERT_16_SIGNED_TO_8_SIGNED:
-    case CONVERT_16_SIGNED_TO_8_UNSIGNED:
-        if(ulOperation == OPERATION_PLAY) {
-             pConfigInfo->ulHwBitsPerSample = 8;
-        }
-        else pConfigInfo->ulHwBitsPerSample = 16;
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_8_UNSIGNED_MONO_STEREO:
-    case CONVERT_16_UNSIGNED_TO_8_SIGNED_MONO_STEREO:
-    case CONVERT_16_SIGNED_TO_8_SIGNED_MONO_STEREO:
-    case CONVERT_16_SIGNED_TO_8_UNSIGNED_MONO_STEREO:
-        if(ulOperation == OPERATION_PLAY) {
-            pConfigInfo->ulHwBitsPerSample = 8;
-            pConfigInfo->ulHwNumChannels   = 2;
-        }
-        else {
-            pConfigInfo->ulHwBitsPerSample = 16;
-            pConfigInfo->ulHwNumChannels   = 1;
-        }
-        break;
-
-    case CONVERT_16_UNSIGNED_TO_8_UNSIGNED_STEREO_MONO:
-    case CONVERT_16_UNSIGNED_TO_8_SIGNED_STEREO_MONO:
-    case CONVERT_16_SIGNED_TO_8_SIGNED_STEREO_MONO:
-    case CONVERT_16_SIGNED_TO_8_UNSIGNED_STEREO_MONO:
-        if(ulOperation == OPERATION_PLAY) {
-            pConfigInfo->ulHwBitsPerSample = 8;
-            pConfigInfo->ulHwNumChannels   = 1;
-        }
-        else {
-            pConfigInfo->ulHwBitsPerSample = 16;
-            pConfigInfo->ulHwNumChannels   = 2;
-        }
-        break;
-
-    default:
-        DebugInt3();
-        return FALSE;
-    }
-
-    pConfigInfo->ulHwSampleSize = (pConfigInfo->ulHwBitsPerSample * pConfigInfo->ulHwNumChannels) / 8;
-    return TRUE;
+        if(pConfigInfo->ulHwBitsPerSample) {
+                //already determined;
+                return TRUE;
+        }
+        if(pConfigInfo->fSampleRateConversion)
+        {
+                pConfigInfo->ulHwSampleRate = pConfigInfo->ulFixedSampleRate;
+                dprintf(("WA::QuerySampleFormat: SampleRate1 %d", pConfigInfo->ulHwSampleRate));
+        }
+        else
+        {
+                pConfigInfo->ulHwSampleRate = pConfigInfo->ulSampleRate;
+                dprintf(("WA::QuerySampleFormat: SampleRate2 %d", pConfigInfo->ulHwSampleRate));
+        }
+
+        pConfigInfo->ulHwBitsPerSample = pConfigInfo->ulBitsPerSample;
+        pConfigInfo->ulHwNumChannels   = pConfigInfo->ulNumChannels;
+
+        switch(pConfigInfo->usConversion) {
+        case CONVERT_NONE:
+        case CONVERT_8_UNSIGNED_TO_8_SIGNED:
+        case CONVERT_8_SIGNED_TO_8_UNSIGNED:
+        case CONVERT_16_UNSIGNED_TO_16_SIGNED:
+        case CONVERT_16_SIGNED_TO_16_UNSIGNED:
+                //no change
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_8_SIGNED_MONO_STEREO:
+        case CONVERT_8_SIGNED_TO_8_UNSIGNED_MONO_STEREO:
+        case CONVERT_8_UNSIGNED_TO_8_UNSIGNED_MONO_STEREO:
+        case CONVERT_8_SIGNED_TO_8_SIGNED_MONO_STEREO:
+        case CONVERT_16_UNSIGNED_TO_16_SIGNED_MONO_STEREO:
+        case CONVERT_16_SIGNED_TO_16_UNSIGNED_MONO_STEREO:
+        case CONVERT_16_UNSIGNED_TO_16_UNSIGNED_MONO_STEREO:
+        case CONVERT_16_SIGNED_TO_16_SIGNED_MONO_STEREO:
+                if(ulOperation == OPERATION_PLAY) {
+                         pConfigInfo->ulHwNumChannels = 2;
+                }
+                else pConfigInfo->ulHwNumChannels = 1;
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_8_SIGNED_STEREO_MONO:
+        case CONVERT_8_SIGNED_TO_8_UNSIGNED_STEREO_MONO:
+        case CONVERT_8_UNSIGNED_TO_8_UNSIGNED_STEREO_MONO:
+        case CONVERT_8_SIGNED_TO_8_SIGNED_STEREO_MONO:
+        case CONVERT_16_UNSIGNED_TO_16_UNSIGNED_STEREO_MONO:
+        case CONVERT_16_SIGNED_TO_16_SIGNED_STEREO_MONO:
+        case CONVERT_16_UNSIGNED_TO_16_SIGNED_STEREO_MONO:
+        case CONVERT_16_SIGNED_TO_16_UNSIGNED_STEREO_MONO:
+                if(ulOperation == OPERATION_PLAY) {
+                         pConfigInfo->ulHwNumChannels = 1;
+                }
+                else pConfigInfo->ulHwNumChannels = 2;
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_16_UNSIGNED:
+        case CONVERT_8_UNSIGNED_TO_16_SIGNED:
+        case CONVERT_8_SIGNED_TO_16_SIGNED:
+        case CONVERT_8_SIGNED_TO_16_UNSIGNED:
+                if(ulOperation == OPERATION_PLAY) {
+                         pConfigInfo->ulHwBitsPerSample = 16;
+                }
+                else pConfigInfo->ulHwBitsPerSample = 8;
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_16_UNSIGNED_STEREO_MONO:
+        case CONVERT_8_UNSIGNED_TO_16_SIGNED_STEREO_MONO:
+        case CONVERT_8_SIGNED_TO_16_SIGNED_STEREO_MONO:
+        case CONVERT_8_SIGNED_TO_16_UNSIGNED_STEREO_MONO:
+                if(ulOperation == OPERATION_PLAY) {
+                        pConfigInfo->ulHwBitsPerSample = 16;
+                        pConfigInfo->ulHwNumChannels   = 1;
+                }
+                else {
+                        pConfigInfo->ulHwBitsPerSample = 8;
+                        pConfigInfo->ulHwNumChannels   = 2;
+                }
+                break;
+
+        case CONVERT_8_UNSIGNED_TO_16_UNSIGNED_MONO_STEREO:
+        case CONVERT_8_UNSIGNED_TO_16_SIGNED_MONO_STEREO:
+        case CONVERT_8_SIGNED_TO_16_SIGNED_MONO_STEREO:
+        case CONVERT_8_SIGNED_TO_16_UNSIGNED_MONO_STEREO:
+                if(ulOperation == OPERATION_PLAY) {
+                        pConfigInfo->ulHwBitsPerSample = 16;
+                        pConfigInfo->ulHwNumChannels   = 2;
+                }
+                else {
+                        pConfigInfo->ulHwBitsPerSample = 8;
+                        pConfigInfo->ulHwNumChannels   = 1;
+                }
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_8_UNSIGNED:
+        case CONVERT_16_UNSIGNED_TO_8_SIGNED:
+        case CONVERT_16_SIGNED_TO_8_SIGNED:
+        case CONVERT_16_SIGNED_TO_8_UNSIGNED:
+                if(ulOperation == OPERATION_PLAY) {
+                         pConfigInfo->ulHwBitsPerSample = 8;
+                }
+                else pConfigInfo->ulHwBitsPerSample = 16;
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_8_UNSIGNED_MONO_STEREO:
+        case CONVERT_16_UNSIGNED_TO_8_SIGNED_MONO_STEREO:
+        case CONVERT_16_SIGNED_TO_8_SIGNED_MONO_STEREO:
+        case CONVERT_16_SIGNED_TO_8_UNSIGNED_MONO_STEREO:
+                if(ulOperation == OPERATION_PLAY) {
+                        pConfigInfo->ulHwBitsPerSample = 8;
+                        pConfigInfo->ulHwNumChannels   = 2;
+                }
+                else {
+                        pConfigInfo->ulHwBitsPerSample = 16;
+                        pConfigInfo->ulHwNumChannels   = 1;
+                }
+                break;
+
+        case CONVERT_16_UNSIGNED_TO_8_UNSIGNED_STEREO_MONO:
+        case CONVERT_16_UNSIGNED_TO_8_SIGNED_STEREO_MONO:
+        case CONVERT_16_SIGNED_TO_8_SIGNED_STEREO_MONO:
+        case CONVERT_16_SIGNED_TO_8_UNSIGNED_STEREO_MONO:
+                if(ulOperation == OPERATION_PLAY) {
+                        pConfigInfo->ulHwBitsPerSample = 8;
+                        pConfigInfo->ulHwNumChannels   = 1;
+                }
+                else {
+                        pConfigInfo->ulHwBitsPerSample = 16;
+                        pConfigInfo->ulHwNumChannels   = 2;
+                }
+                break;
+
+        default:
+                DebugInt3();
+                return FALSE;
+        }
+
+        pConfigInfo->ulHwSampleSize = (pConfigInfo->ulHwBitsPerSample * pConfigInfo->ulHwNumChannels) / 8;
+        return TRUE;
 }
 //******************************************************************************
@@ -969 +965 @@
 //******************************************************************************
 ULONG WAVEAUDIO::FindMatchingSampleRate(ULONG ulSampleRate, ULONG ulOSSSRateFlags,
-                                        ULONG FAR *pulNrSampleRates, ULONG FAR *pulFixedSampleRate)
-{
-    ULONG sampleRates[31];
-    int   nrSampleRates = 0;
-
-    if(pulFixedSampleRate) {
-        *pulFixedSampleRate = -1;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_5512) {
-        sampleRates[nrSampleRates++] = 5512;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_8000) {
-        sampleRates[nrSampleRates++] = 8000;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_11025) {
-        sampleRates[nrSampleRates++] = 11025;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_16000) {
-        sampleRates[nrSampleRates++] = 16000;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_22050) {
-        sampleRates[nrSampleRates++] = 22050;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_32000) {
-        sampleRates[nrSampleRates++] = 32000;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_44100) {
-        sampleRates[nrSampleRates++] = 44100;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_48000) {
-        sampleRates[nrSampleRates++] = 48000;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_64000) {
-        sampleRates[nrSampleRates++] = 64000;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_88200) {
-        sampleRates[nrSampleRates++] = 88200;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_96000) {
-        sampleRates[nrSampleRates++] = 96000;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_176400) {
-        sampleRates[nrSampleRates++] = 176400;
-    }
-    if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_192000) {
-        sampleRates[nrSampleRates++] = 192000;
-    }
-    if(nrSampleRates > 2) {
-        _usfind_matching_sample_rate(&ulSampleRate, nrSampleRates, (ULONG FAR *)sampleRates);
-    }
-    else {
-        //fixed rate -> we support all sample rates by manually performing sample rate conversion
-        if(nrSampleRates <= 2 && pulFixedSampleRate) {
-            //sampleRates[0] = 44100; /* hardware set to 44100 */
-            *pulFixedSampleRate = sampleRates[0];
-            nrSampleRates = 1;
-        }
-    }
-
-    *pulNrSampleRates = nrSampleRates;
-    return ulSampleRate;
+                                                                                ULONG FAR *pulNrSampleRates, ULONG FAR *pulFixedSampleRate)
+{
+        ULONG sampleRates[31];
+        int   nrSampleRates = 0;
+
+        if(pulFixedSampleRate) {
+                *pulFixedSampleRate = -1;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_5512) {
+                sampleRates[nrSampleRates++] = 5512;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_8000) {
+                sampleRates[nrSampleRates++] = 8000;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_11025) {
+                sampleRates[nrSampleRates++] = 11025;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_16000) {
+                sampleRates[nrSampleRates++] = 16000;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_22050) {
+                sampleRates[nrSampleRates++] = 22050;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_32000) {
+                sampleRates[nrSampleRates++] = 32000;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_44100) {
+                sampleRates[nrSampleRates++] = 44100;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_48000) {
+                sampleRates[nrSampleRates++] = 48000;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_64000) {
+                sampleRates[nrSampleRates++] = 64000;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_88200) {
+                sampleRates[nrSampleRates++] = 88200;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_96000) {
+                sampleRates[nrSampleRates++] = 96000;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_176400) {
+                sampleRates[nrSampleRates++] = 176400;
+        }
+        if(ulOSSSRateFlags & OSS32_CAPS_PCM_RATE_192000) {
+                sampleRates[nrSampleRates++] = 192000;
+        }
+        if(nrSampleRates > 2) {
+                _usfind_matching_sample_rate(&ulSampleRate, nrSampleRates, (ULONG FAR *)sampleRates);
+        }
+        else {
+                //fixed rate -> we support all sample rates by manually performing sample rate conversion
+                if(nrSampleRates <= 2 && pulFixedSampleRate) {
+                        //sampleRates[0] = 44100; /* hardware set to 44100 */
+                        *pulFixedSampleRate = sampleRates[0];
+                        nrSampleRates = 1;
+                }
+        }
+
+        *pulNrSampleRates = nrSampleRates;
+        return ulSampleRate;
 }
 
@@ -1040 +1036 @@
 void WAVEAUDIO::DevCaps(PAUDIO_CAPS pCaps)
 {
-    USHORT     usSampleRateIndex;
-    ULONG      ulSampleRate;
-    PWAVE_CAPS pWaveCaps;
-
+        USHORT     usSampleRateIndex;
+        ULONG      ulSampleRate;
+        PWAVE_CAPS pWaveCaps;
+
+        dprintf(("WAVEAUDIO::DevCaps1"));
+
+        pCaps->ulFlags = 0;
+
+        // This device driver supports Playback or Record Operations
+        // anything else makes no sence. Note: This a per stream operation so
+        // even if this sevice can do full-duplex, it can not do PLAY_AND_RECORD
+
+        if ( pCaps->ulOperation != OPERATION_PLAY &&
+                 pCaps->ulOperation != OPERATION_RECORD )
+        {
+                dprintf(("DevCaps1 not play/record"));
+                pCaps->ulSupport = UNSUPPORTED_OPERATION;
+                return;
+        }
+
+        if(pCaps->ulOperation == OPERATION_PLAY)
+        {
+                 pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
+        }
+        else pWaveCaps = &devCaps[ulDeviceNr].waveInCaps;
+
+        // We always support stereo and mono
+        if (pCaps->ulChannels != 1 && pCaps->ulChannels != 2)
+        {
+                if(pCaps->ulChannels > pWaveCaps->ulMaxChannels)
+                {
+                        dprintf(("DevCaps1 not channel"));
+                        pCaps->ulSupport = UNSUPPORTED_CHANNELS;
+                        return;
+                }
+        }
+        if (pCaps->ulSamplingRate == 0)
+        {
+                dprintf(("DevCaps1 not rate"));
+                pCaps->ulSupport = UNSUPPORTED_RATE;
+                return;
+        }
+
+        //Determine supported rates
+        ulSampleRate = pCaps->ulSamplingRate; //save the sampling rate called with
+
+        if(pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_CONTINUOUS)
+        {//supports all sample rates from min to max
+                if (ulSampleRate < pWaveCaps->ulMinRate) {
+                        ulSampleRate = pWaveCaps->ulMinRate;
+                }
+                else
+                if(ulSampleRate > pWaveCaps->ulMaxRate) {
+                        ulSampleRate = pWaveCaps->ulMaxRate;
+                }
+        }
+        else {
+                ULONG ulNrSampleRates;
+
+                ulSampleRate = FindMatchingSampleRate(ulSampleRate, pWaveCaps->ulRateFlags, &ulNrSampleRates);
+        }
+
+        // If we don't support the requested samplerate, then fill in the best fit flag.
+        if (ulSampleRate != pCaps->ulSamplingRate)
+                pCaps->ulFlags |= BESTFIT_PROVIDED;
+
+        // find out the closest sampling rate (may or may not be the same )
+        // from one of the following: 11025Hz, 22050Hz, 44100Hz and 8000Hz
+        // _usfind_matching_sample_rate will update  pCaps->ulSamplingRate if there
+        // is not an exact match.
+        usSampleRateIndex = _usfind_matching_sample_rate(&pCaps->ulSamplingRate);
+
+        //query flags for this wave data format
+        pCaps->ulFlags |= QueryDataFlags(pCaps->ulOperation, pCaps->ulDataType, pCaps->ulBitsPerSample);
+
+        // Determine the ulDataSubType and update any format specific flags
+        // Note: All data types have more than one value.
+        switch ( pCaps->ulDataType )
+        {
+        case DATATYPE_NULL: //Warp 3 buggy data type
+        case DATATYPE_WAVEFORM:
+        case PCM:
+                // supported bits per sample are 8 (for unsigned PCM, u-law or A-law )
+                // and 16 (for 2's complement PCM)
+                switch(pCaps->ulBitsPerSample) {
+                case 8:
+                case 16:
+                        //NOTE: We always support 8 & 16 bits playback & recording; if the card
+                        //              can't handle one of these formats, then we'll convert the
+                        //              wave data ourselves (same for mono/stereo).
+                        break;
+                case 24:
+                        if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS))
+                        {
+                                dprintf(("DevCaps1 not 24BPS"));
+                                pCaps->ulSupport = UNSUPPORTED_BPS;
+                                return;
+                        }
+                        break;
+                case 32:
+                        if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS))
+                        {
+                                pCaps->ulSupport = UNSUPPORTED_BPS;
+                                dprintf(("DevCaps1 not 32BPS"));
+                                return;
+                        }
+                        break;
+                default:
+                        dprintf(("DevCaps1 not BPS %d",(USHORT)pCaps->ulBitsPerSample));
+                        pCaps->ulSupport = UNSUPPORTED_BPS;
+                        return;
+                }
+
+                // determine subtype for PCM:
+                pCaps->ulDataSubType = aaulWave[usSampleRateIndex]
+                                                                                [(pCaps->ulBitsPerSample-8)/8]
+                                                                                [pCaps->ulChannels-1];
+                break;
+
+        case DATATYPE_ALAW:
+        case DATATYPE_RIFF_ALAW:
+        case A_LAW:
+                if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_ALAW))
+                {
+                        dprintf(("DevCaps1 not ALAW"));
+                        pCaps->ulSupport = UNSUPPORTED_DATATYPE;
+                        return;
+                }
+                // supported bits per sample are 8 (for unsigned PCM, u-law or A-law )
+                if (pCaps->ulBitsPerSample != 8)
+                {
+                        dprintf(("DevCaps1 not ALAW BPS8"));
+                        pCaps->ulSupport = UNSUPPORTED_BPS;
+                        return;
+                }
+                // determine subtype for A_LAW
+                pCaps->ulDataSubType = aaulAlaw[usSampleRateIndex][pCaps->ulChannels-1];
+                break;
+
+        case DATATYPE_MULAW:
+        case DATATYPE_RIFF_MULAW:
+        case MU_LAW:
+                if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_MULAW))
+                {
+                        dprintf(("DevCaps1 not MULAW"));
+                        pCaps->ulSupport = UNSUPPORTED_DATATYPE;
+                        return;
+                }
+                // supported bits per sample are 8 (for unsigned PCM, u-law or A-law )
+                if (pCaps->ulBitsPerSample != 8)
+                {
+                        dprintf(("DevCaps1 not MULAW BPS8"));
+                        pCaps->ulSupport = UNSUPPORTED_BPS;
+                        return;
+                }
+                // determine subtype for MU_LAW
+                pCaps->ulDataSubType = aaulMulaw[usSampleRateIndex][pCaps->ulChannels-1];
+                break;
+
+        case DATATYPE_ADPCM_AVC:
+        case DATATYPE_CT_ADPCM:
+                if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_ADPCM))
+                {
+                        dprintf(("DevCaps1 not ADPCM"));
+                        pCaps->ulSupport = UNSUPPORTED_DATATYPE;
+                        return;
+                }
+                // supported bits per sample are 4
+                if (pCaps->ulBitsPerSample != 4)
+                {
+                        dprintf(("DevCaps1 not ADPCM BPS4"));
+                        pCaps->ulSupport = UNSUPPORTED_BPS;
+                        return;
+                }
+                // determine subtype for ADPCM
+                pCaps->ulDataSubType = aaulMulaw[usSampleRateIndex][pCaps->ulChannels-1];
+                break;
+
+        default:
+                dprintf(("DevCaps1 not dattype"));
+                pCaps->ulSupport = UNSUPPORTED_DATATYPE;
+                return;
+        } // end switch
+
+        pCaps->ulFlags |= FIXED            |    // Fixed length data
+                                          LEFT_ALIGNED |        // Left align bits on byte bndry
+                                          INPUT            |    // Input select is supported
+                                          OUTPUT           |    // Output select is supported
+                                          MONITOR          |    // Monitor is supported
+                                          VOLUME;                       // Volume control is supported
+
+        // Full Duplex Enabling Stuff here !!
+        // The number of resource units is described in the MMPM2.INI
+        // This can be thought of the number of active streams the
+        // driver can manage at one time. We list this number as 2.
+        // we tell MMPM here how many of these units THIS stream will consume.
+        // The answer is so simple it's brilliant, (Thanks to Joe Nord at Crystal
+        // Semi) If we are enabled to do full-duplex this stream will consume 1
+        // unit, If we are not enabled to do full-duplex this stream will consume 2
+        // (or all the available units)
+        // Along with the resource units, we defined 2 resources classes,
+        // one for playback and one for capture. We tell MMPM (in the MMPM2.INI)
+        // that we can handle doing 1 playback and 1 capture stream or 1 capture and
+        // one playback stream at the same time. (Valid Resource combos in the
+        // MMPM2.INI) check if we are a playback or capture and set the correct
+        // resource class (Playback = 1, Capture = 2)
+
+        if(pCaps->ulOperation == OPERATION_PLAY)
+        {
+                if(pWaveCaps->nrStreams) {
+                        pCaps->ulResourceUnits = OSS32_MAX_WAVE_PLAYBACK_STREAMS/pWaveCaps->nrStreams;
+                }
+                else {
+                        DebugInt3(); //should never happen!
+                        pCaps->ulResourceUnits = OSS32_MAX_WAVE_PLAYBACK_STREAMS;
+                }
+                dprintf(("RU used by playback stream: %d", (int)pCaps->ulResourceUnits));
+        }
+        else {
+                if(pWaveCaps->nrStreams < OSS32_MAX_WAVE_CAPTURE_STREAMS) {
+                        DebugInt3();
+                }
+                pCaps->ulResourceUnits = 1;
+        }
+
+        if ( pCaps->ulOperation == OPERATION_PLAY)
+                pCaps->ulResourceClass = 1;
+        else
+                pCaps->ulResourceClass = 2;
+        pCaps->fCanRecord       = 1;                    //      Yes Virgina we can record
+        pCaps->ulBlockAlign = 1;                        //      Block alignment for this mode
+
+        //return success
+        pCaps->ulSupport = SUPPORT_SUCCESS;
+        dprintf(("WAVEAUDIO::DevCaps %ld %ld %ld ", pCaps->ulBitsPerSample, pCaps->ulSamplingRate, pCaps->ulChannels));
+        dprintf(("Op %ld ResourceClass %ld ResourceUnits %ld", pCaps->ulOperation, pCaps->ulResourceClass, pCaps->ulResourceUnits));
+        dprintf(("Data type %ld, data subtype %ld", pCaps->ulDataType, pCaps->ulDataSubType));
 #ifdef DEBUG
-    dprintf(("WAVEAUDIO::DevCaps1"));
-#endif
-
-    pCaps->ulFlags = 0;
-
-    // This device driver supports Playback or Record Operations
-    // anything else makes no sence. Note: This a per stream operation so
-    // even if this sevice can do full-duplex, it can not do PLAY_AND_RECORD
-
-    if ( pCaps->ulOperation != OPERATION_PLAY &&
-         pCaps->ulOperation != OPERATION_RECORD )
-    {
-        dprintf(("DevCaps1 not play/record"));
-        pCaps->ulSupport = UNSUPPORTED_OPERATION;
-        return;
-    }
-
-    if(pCaps->ulOperation == OPERATION_PLAY)
-    {
-         pWaveCaps = &devCaps[ulDeviceNr].waveOutCaps;
-    }
-    else pWaveCaps = &devCaps[ulDeviceNr].waveInCaps;
-
-    // We always support stereo and mono
-    if (pCaps->ulChannels != 1 && pCaps->ulChannels != 2)
-    {
-        if(pCaps->ulChannels > pWaveCaps->ulMaxChannels)
-        {
-            dprintf(("DevCaps1 not channel"));
-            pCaps->ulSupport = UNSUPPORTED_CHANNELS;
-            return;
-        }
-    }
-    if (pCaps->ulSamplingRate == 0)
-    {
-        dprintf(("DevCaps1 not rate"));
-        pCaps->ulSupport = UNSUPPORTED_RATE;
-        return;
-    }
-
-    //Determine supported rates
-    ulSampleRate = pCaps->ulSamplingRate; //save the sampling rate called with
-
-    if(pWaveCaps->ulRateFlags & OSS32_CAPS_PCM_RATE_CONTINUOUS)
-    {//supports all sample rates from min to max
-        if (ulSampleRate < pWaveCaps->ulMinRate) {
-            ulSampleRate = pWaveCaps->ulMinRate;
-        }
-        else
-        if(ulSampleRate > pWaveCaps->ulMaxRate) {
-            ulSampleRate = pWaveCaps->ulMaxRate;
-        }
-    }
-    else {
-        ULONG ulNrSampleRates;
-
-        ulSampleRate = FindMatchingSampleRate(ulSampleRate, pWaveCaps->ulRateFlags, &ulNrSampleRates);
-    }
-
-    // If we don't support the requested samplerate, then fill in the best fit flag.
-    if (ulSampleRate != pCaps->ulSamplingRate)
-        pCaps->ulFlags |= BESTFIT_PROVIDED;
-
-    // find out the closest sampling rate (may or may not be the same )
-    // from one of the following: 11025Hz, 22050Hz, 44100Hz and 8000Hz
-    // _usfind_matching_sample_rate will update  pCaps->ulSamplingRate if there
-    // is not an exact match.
-    usSampleRateIndex = _usfind_matching_sample_rate(&pCaps->ulSamplingRate);
-
-    //query flags for this wave data format
-    pCaps->ulFlags |= QueryDataFlags(pCaps->ulOperation, pCaps->ulDataType, pCaps->ulBitsPerSample);
-
-    // Determine the ulDataSubType and update any format specific flags
-    // Note: All data types have more than one value.
-    switch ( pCaps->ulDataType )
-    {
-    case DATATYPE_NULL: //Warp 3 buggy data type
-    case DATATYPE_WAVEFORM:
-    case PCM:
-        // supported bits per sample are 8 (for unsigned PCM, u-law or A-law )
-        // and 16 (for 2's complement PCM)
-        switch(pCaps->ulBitsPerSample) {
-        case 8:
-        case 16:
-            //NOTE: We always support 8 & 16 bits playback & recording; if the card
-            //      can't handle one of these formats, then we'll convert the
-            //      wave data ourselves (same for mono/stereo).
-            break;
-        case 24:
-            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_24BPS))
-            {
-                dprintf(("DevCaps1 not 24BPS"));
-                pCaps->ulSupport = UNSUPPORTED_BPS;
-                return;
-            }
-            break;
-        case 32:
-            if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_32BPS))
-            {
-                pCaps->ulSupport = UNSUPPORTED_BPS;
-                dprintf(("DevCaps1 not 32BPS"));
-                return;
-            }
-            break;
-        default:
-            dprintf(("DevCaps1 not BPS %d",(USHORT)pCaps->ulBitsPerSample));
-            pCaps->ulSupport = UNSUPPORTED_BPS;
-            return;
-        }
-
-        // determine subtype for PCM:
-        pCaps->ulDataSubType = aaulWave[usSampleRateIndex]
-                                        [(pCaps->ulBitsPerSample-8)/8]
-                                        [pCaps->ulChannels-1];
-        break;
-
-    case DATATYPE_ALAW:
-    case DATATYPE_RIFF_ALAW:
-    case A_LAW:
-        if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_ALAW))
-        {
-            dprintf(("DevCaps1 not ALAW"));
-            pCaps->ulSupport = UNSUPPORTED_DATATYPE;
-            return;
-        }
-        // supported bits per sample are 8 (for unsigned PCM, u-law or A-law )
-        if (pCaps->ulBitsPerSample != 8)
-        {
-            dprintf(("DevCaps1 not ALAW BPS8"));
-            pCaps->ulSupport = UNSUPPORTED_BPS;
-            return;
-        }
-        // determine subtype for A_LAW
-        pCaps->ulDataSubType = aaulAlaw[usSampleRateIndex][pCaps->ulChannels-1];
-        break;
-
-    case DATATYPE_MULAW:
-    case DATATYPE_RIFF_MULAW:
-    case MU_LAW:
-        if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_MULAW))
-        {
-            dprintf(("DevCaps1 not MULAW"));
-            pCaps->ulSupport = UNSUPPORTED_DATATYPE;
-            return;
-        }
-        // supported bits per sample are 8 (for unsigned PCM, u-law or A-law )
-        if (pCaps->ulBitsPerSample != 8)
-        {
-            dprintf(("DevCaps1 not MULAW BPS8"));
-            pCaps->ulSupport = UNSUPPORTED_BPS;
-            return;
-        }
-        // determine subtype for MU_LAW
-        pCaps->ulDataSubType = aaulMulaw[usSampleRateIndex][pCaps->ulChannels-1];
-        break;
-
-    case DATATYPE_ADPCM_AVC:
-    case DATATYPE_CT_ADPCM:
-        if(!(pWaveCaps->ulDataFormats & OSS32_CAPS_PCM_FORMAT_ADPCM))
-        {
-            dprintf(("DevCaps1 not ADPCM"));
-            pCaps->ulSupport = UNSUPPORTED_DATATYPE;
-            return;
-        }
-        // supported bits per sample are 4
-        if (pCaps->ulBitsPerSample != 4)
-        {
-            dprintf(("DevCaps1 not ADPCM BPS4"));
-            pCaps->ulSupport = UNSUPPORTED_BPS;
-            return;
-        }
-        // determine subtype for ADPCM
-        pCaps->ulDataSubType = aaulMulaw[usSampleRateIndex][pCaps->ulChannels-1];
-        break;
-
-    default:
-        dprintf(("DevCaps1 not dattype"));
-        pCaps->ulSupport = UNSUPPORTED_DATATYPE;
-        return;
-    } // end switch
-
-    pCaps->ulFlags |= FIXED        |    // Fixed length data
-                      LEFT_ALIGNED |    // Left align bits on byte bndry
-                      INPUT        |    // Input select is supported
-                      OUTPUT       |    // Output select is supported
-                      MONITOR      |    // Monitor is supported
-                      VOLUME;           // Volume control is supported
-
-    // Full Duplex Enabling Stuff here !!
-    // The number of resource units is described in the MMPM2.INI
-    // This can be thought of the number of active streams the
-    // driver can manage at one time. We list this number as 2.
-    // we tell MMPM here how many of these units THIS stream will consume.
-    // The answer is so simple it's brilliant, (Thanks to Joe Nord at Crystal
-    // Semi) If we are enabled to do full-duplex this stream will consume 1
-    // unit, If we are not enabled to do full-duplex this stream will consume 2
-    // (or all the available units)
-    // Along with the resource units, we defined 2 resources classes,
-    // one for playback and one for capture. We tell MMPM (in the MMPM2.INI)
-    // that we can handle doing 1 playback and 1 capture stream or 1 capture and
-    // one playback stream at the same time. (Valid Resource combos in the
-    // MMPM2.INI) check if we are a playback or capture and set the correct
-    // resource class (Playback = 1, Capture = 2)
-
-    if(pCaps->ulOperation == OPERATION_PLAY)
-    {
-        if(pWaveCaps->nrStreams) {
-            pCaps->ulResourceUnits = OSS32_MAX_WAVE_PLAYBACK_STREAMS/pWaveCaps->nrStreams;
-        }
-        else {
-            DebugInt3(); //should never happen!
-            pCaps->ulResourceUnits = OSS32_MAX_WAVE_PLAYBACK_STREAMS;
-        }
-        dprintf(("RU used by playback stream: %d", (int)pCaps->ulResourceUnits));
-    }
-    else {
-        if(pWaveCaps->nrStreams < OSS32_MAX_WAVE_CAPTURE_STREAMS) {
-            DebugInt3();
-        }
-        pCaps->ulResourceUnits = 1;
-    }
-
-    if ( pCaps->ulOperation == OPERATION_PLAY)
-        pCaps->ulResourceClass = 1;
-    else
-        pCaps->ulResourceClass = 2;
-    pCaps->fCanRecord   = 1;            //  Yes Virgina we can record
-    pCaps->ulBlockAlign = 1;            //  Block alignment for this mode
-
-    //return success
-    pCaps->ulSupport = SUPPORT_SUCCESS;
-    dprintf(("WAVEAUDIO::DevCaps %ld %ld %ld ", pCaps->ulBitsPerSample, pCaps->ulSamplingRate, pCaps->ulChannels));
-    dprintf(("Op %ld ResourceClass %ld ResourceUnits %ld", pCaps->ulOperation, pCaps->ulResourceClass, pCaps->ulResourceUnits));
-    dprintf(("Data type %ld, data subtype %ld", pCaps->ulDataType, pCaps->ulDataSubType));
-#ifdef DEBUG
-    dprintf(("Flags:"));
-
-    for(int i=0;i<32;i++) {
-        if(pCaps->ulFlags & (1UL << (ULONG)i)) {
-            dprintf(("%s", szCapsFlags[i]));
-        }
-    }
+        dprintf(("Flags:"));
+
+        for(int i=0;i<32;i++) {
+                if(pCaps->ulFlags & (1UL << (ULONG)i)) {
+                        dprintf(("%s", szCapsFlags[i]));
+                }
+        }
 #endif
 }
@@ -1297 +1291 @@
 void WAVEAUDIO::DevCaps(LPOSS32_DEVCAPS lpCaps)
 {
-#ifdef DEBUG
-    dprintf(("WAVEAUDIO::DevCaps"));
-#endif
-    ddmemmov(lpCaps, &devCaps[current_device], sizeof(OSS32_DEVCAPS));
+        //dprintf(("WAVEAUDIO::DevCaps"));
+        ddmemmov(lpCaps, &devCaps[current_device], sizeof(OSS32_DEVCAPS));
 }
 
@@ -1313 +1305 @@
 #pragma on (unreferenced)
 {
-         ULONG  ulBytesPerIRQ;
-
-#ifdef DEBUG
-    //dprintf(("WAVEAUDIO::ConfigDev"));
-#endif
-    //Reset sample rate conversion position
-    pConfigInfo->ulSRatePosition = 0;
-
-    // Set the clock select bits (_ucClockData)
-
-    // Set up _ucFormatData and write usSilence for the WAVESTREAM
-    switch (pConfigInfo->ulDataType) {
-    case DATATYPE_NULL: //Warp 3 buggy data type
-    case DATATYPE_WAVEFORM:
-    case PCM:
-        if (pConfigInfo->ulBitsPerSample == 16) {
-            pConfigInfo->usSilence = 0x0000;
-        }
-        else {
-            pConfigInfo->usSilence = 0x8080;
-        }
-        break;
-
-    case DATATYPE_ALAW:
-    case DATATYPE_RIFF_ALAW:
-    case A_LAW:
-        pConfigInfo->usSilence = 0x5555;
-        break;
-
-    case DATATYPE_MULAW:
-    case DATATYPE_RIFF_MULAW:
-    case MU_LAW:
-        pConfigInfo->usSilence = 0x7F7F;
-        break;
-    } /* endswitch */
-
-    // Calculate the PCMConsumeRate
-    // The consume rate is the number of bytes consumed by this data format
-    // per second. It calculated by taking the following equation:
-    //          sampling rate * (BitsPerSample/8) * NumChannels
-    // This info is returned to the WAVESTREAM and used to calculate stream time
-
-    pConfigInfo->ulSampleSize     = (pConfigInfo->ulBitsPerSample*pConfigInfo->ulNumChannels)/8;
-    pConfigInfo->ulPCMConsumeRate = pConfigInfo->ulSampleRate * pConfigInfo->ulSampleSize;
-
-    // Calculate the BytesPerIRQ
-    // The BytesPerIRQ is the number of bytes consumed by this data format
-    // for every interrupt generated by the codec.
-    // This information is returned to the WAVESTREAM which uses it in
-    // buffer management decisions....
-    // basic formula is  (sampling rate * ((BitsPerSample * NumChannels) /8) / Number of Interrupts per Second
-    // or pConfigInfo->ulPCMConsumeRate / Number of Interrupts Per Second
-    // rjj Fix for Bug #18 28082008
-
-    //ulBytesPerIRQ = pConfigInfo->ulPCMConsumeRate >> 5;  // 32 interrupts per second
-    ulBytesPerIRQ = pConfigInfo->ulPCMConsumeRate >> 6;  // 64 interrupts per second
-                                                         // we can tweak this as needed but generally this should do rjj
-    // make sure it's an even multiple of 64
-    ulBytesPerIRQ += 0x00000040;
-    ulBytesPerIRQ &= 0xFFFFFFC0;
-
-    if (ulBytesPerIRQ > 0x800) {
-          ulBytesPerIRQ = 0x800;
-    }
-    pConfigInfo->ulBytesPerIRQ = ulBytesPerIRQ;
-    dprintf4(("WAVEAUDIO::ConfigDev BytesPerIRQ:%ld",ulBytesPerIRQ));
-
-
-    return TRUE;
+         ULONG  ulBytesPerIRQ;
+
+        //dprintf(("WAVEAUDIO::ConfigDev"));
+        //Reset sample rate conversion position
+        pConfigInfo->ulSRatePosition = 0;
+
+        // Set the clock select bits (_ucClockData)
+
+        // Set up _ucFormatData and write usSilence for the WAVESTREAM
+        switch (pConfigInfo->ulDataType) {
+        case DATATYPE_NULL: //Warp 3 buggy data type
+        case DATATYPE_WAVEFORM:
+        case PCM:
+                if (pConfigInfo->ulBitsPerSample == 16) {
+                        pConfigInfo->usSilence = 0x0000;
+                }
+                else {
+                        pConfigInfo->usSilence = 0x8080;
+                }
+                break;
+
+        case DATATYPE_ALAW:
+        case DATATYPE_RIFF_ALAW:
+        case A_LAW:
+                pConfigInfo->usSilence = 0x5555;
+                break;
+
+        case DATATYPE_MULAW:
+        case DATATYPE_RIFF_MULAW:
+        case MU_LAW:
+                pConfigInfo->usSilence = 0x7F7F;
+                break;
+        } /* endswitch */
+
+        // Calculate the PCMConsumeRate
+        // The consume rate is the number of bytes consumed by this data format
+        // per second. It calculated by taking the following equation:
+        //                      sampling rate * (BitsPerSample/8) * NumChannels
+        // This info is returned to the WAVESTREAM and used to calculate stream time
+
+        pConfigInfo->ulSampleSize         = (pConfigInfo->ulBitsPerSample*pConfigInfo->ulNumChannels)/8;
+        pConfigInfo->ulPCMConsumeRate = pConfigInfo->ulSampleRate * pConfigInfo->ulSampleSize;
+
+        // Calculate the BytesPerIRQ
+        // The BytesPerIRQ is the number of bytes consumed by this data format
+        // for every interrupt generated by the codec.
+        // This information is returned to the WAVESTREAM which uses it in
+        // buffer management decisions....
+        // basic formula is  (sampling rate * ((BitsPerSample * NumChannels) /8) / Number of Interrupts per Second
+        // or pConfigInfo->ulPCMConsumeRate / Number of Interrupts Per Second
+        // rjj Fix for Bug #18 28082008
+
+        //ulBytesPerIRQ = pConfigInfo->ulPCMConsumeRate >> 5;  // 32 interrupts per second
+        ulBytesPerIRQ = pConfigInfo->ulPCMConsumeRate >> 6;  // 64 interrupts per second
+                                                                                                                 // we can tweak this as needed but generally this should do rjj
+        // make sure it's an even multiple of 64
+        ulBytesPerIRQ += 0x00000040;
+        ulBytesPerIRQ &= 0xFFFFFFC0;
+
+        if (ulBytesPerIRQ > 0x800) {
+                  ulBytesPerIRQ = 0x800;
+        }
+        pConfigInfo->ulBytesPerIRQ = ulBytesPerIRQ;
+        dprintf4(("WAVEAUDIO::ConfigDev BytesPerIRQ:%ld",ulBytesPerIRQ));
+
+
+        return TRUE;
 }
 /**@internal Pause
- * @param    None
- * @return   int 1
+ * @param        None
+ * @return       int 1
  * @notes
  * stub function pause is implemented as a stop by the stream
@@ -1396 +1386 @@
 }
 /**@internal Resume
- * @param    None
- * @return   int 1
+ * @param        None
+ * @return       int 1
  * @notes
  * stub function resume is implemented as a start by the stream
@@ -1405 +1395 @@
 #pragma on (unreferenced)
 {
-    return 1;
+        return 1;
 }
 /******************************************************************************/
-/* WAVEAUDIO::Start(void)                                                     */
-/*                                                                            */
+/* WAVEAUDIO::Start(void)                                                                                                         */
+/*                                                                                                                                                        */
 /******************************************************************************/
 int WAVEAUDIO::Start(OSSSTREAMID StreamId)
 {
-#ifdef DEBUG
-//    dprintf(("WAVEAUDIO::Start"));
-#endif
-
-    return OSS16_WaveStart(StreamId) == OSSERR_SUCCESS;
+        //dprintf(("WAVEAUDIO::Start"));
+
+        return OSS16_WaveStart(StreamId) == OSSERR_SUCCESS;
 }
 
 /******************************************************************************/
-/* WAVEAUDIO::Stop(void)                                                      */
-/*                                                                            */
+/* WAVEAUDIO::Stop(void)                                                                                                          */
+/*                                                                                                                                                        */
 /******************************************************************************/
 int WAVEAUDIO::Stop(OSSSTREAMID StreamId)
 {
-#ifdef DEBUG
-//    dprintf(("WAVEAUDIO::Stop"));
-#endif
-
-    if(OSS16_WaveStop(StreamId) != OSSERR_SUCCESS)
-    {
-        DebugInt3();
-        return FALSE;
-    }
-    //Reset cleans up waveout instance
-    if(OSS16_WaveReset(StreamId) != OSSERR_SUCCESS)
-    {
-        DebugInt3();
-        return FALSE;
-    }
-    return TRUE;
+        //dprintf(("WAVEAUDIO::Stop"));
+
+        if(OSS16_WaveStop(StreamId) != OSSERR_SUCCESS)
+        {
+                DebugInt3();
+                return FALSE;
+        }
+        //Reset cleans up waveout instance
+        if(OSS16_WaveReset(StreamId) != OSSERR_SUCCESS)
+        {
+                DebugInt3();
+                return FALSE;
+        }
+        return TRUE;
 }
 /******************************************************************************/
-/* WAVEAUDIO::Prepare(void)                                                   */
-/*                                                                            */
+/* WAVEAUDIO::Prepare(void)                                                                                               */
+/*                                                                                                                                                        */
 /******************************************************************************/
 int WAVEAUDIO::Prepare(OSSSTREAMID StreamId)
 {
-#ifdef DEBUG
-//    dprintf(("WAVEAUDIO::Prepare"));
-#endif
-
-    if(OSS16_WavePrepare(StreamId) != OSSERR_SUCCESS) {
-        DebugInt3();
-        return FALSE;
-    }
-    return TRUE;
+        //dprintf(("WAVEAUDIO::Prepare"));
+
+        if(OSS16_WavePrepare(StreamId) != OSSERR_SUCCESS) {
+                DebugInt3();
+                return FALSE;
+        }
+        return TRUE;
 }
 //******************************************************************************
@@ -1463 +1447 @@
 ULONG WAVEAUDIO::ConvertPosition(ULONG length, PWAVECONFIGINFO pConfigInfo)
 {
-    ULONG newlen;
-
-    newlen = CONVERT_LENGTH(length, pConfigInfo->ulConversionFactor);
-
-    if(newlen && pConfigInfo->fSampleRateConversion) {
-        newlen = SRATE_CONVERT_POSITION(newlen, pConfigInfo->ulSampleRate, pConfigInfo->ulHwSampleRate);
-    }
-    return newlen;
+        ULONG newlen;
+
+        newlen = CONVERT_LENGTH(length, pConfigInfo->ulConversionFactor);
+
+        if(newlen && pConfigInfo->fSampleRateConversion) {
+                newlen = SRATE_CONVERT_POSITION(newlen, pConfigInfo->ulSampleRate, pConfigInfo->ulHwSampleRate);
+        }
+        return newlen;
 }
 //******************************************************************************
@@ -1476 +1460 @@
 ULONG WAVEAUDIO::ConvertPositionInvert(ULONG length, PWAVECONFIGINFO pConfigInfo)
 {
-    ULONG newlen;
-
-    newlen = CONVERT_LENGTH(length, CONVERSION_INVERT(pConfigInfo->ulConversionFactor));
-
-    if(newlen && pConfigInfo->fSampleRateConversion) {
-        newlen = SRATE_CONVERT_POSITION(newlen, pConfigInfo->ulSampleRate, pConfigInfo->ulHwSampleRate);
-    }
-    return newlen;
+        ULONG newlen;
+
+        newlen = CONVERT_LENGTH(length, CONVERSION_INVERT(pConfigInfo->ulConversionFactor));
+
+        if(newlen && pConfigInfo->fSampleRateConversion) {
+                newlen = SRATE_CONVERT_POSITION(newlen, pConfigInfo->ulSampleRate, pConfigInfo->ulHwSampleRate);
+        }
+        return newlen;
 }
 //******************************************************************************
@@ -1490 +1474 @@
 ULONG WAVEAUDIO::ConvertLength(ULONG length, PWAVECONFIGINFO pConfigInfo)
 {
-    ULONG newlen;
-
-    newlen = CONVERT_LENGTH(length, pConfigInfo->ulConversionFactor);
+        ULONG newlen;
+
+        newlen = CONVERT_LENGTH(length, pConfigInfo->ulConversionFactor);
 
 //PS+++
 #ifdef WhatIsIt
-    if(newlen >= 4UL*1024UL*1024UL) {
-        //oh, oh
-        DebugInt3();    //this shouldn't happen!!
-        return newlen;
-    }
+        if(newlen >= 4UL*1024UL*1024UL) {
+                //oh, oh
+                DebugInt3();    //this shouldn't happen!!
+                return newlen;
+        }
 #endif
-    if(newlen && pConfigInfo->fSampleRateConversion) {
-        newlen = SRATE_CONVERT_LENGTH(newlen, pConfigInfo->ulSRatePosition,
-                                      pConfigInfo->ulSRateIncrement);
-    }
-    return newlen;
-}
-
-#define CONVERT_POSITION_INVERT(pos, ulFactor)  ( ( pos << CONVERSION_RSHIFT(ulFactor)) >> CONVERSION_LSHIFT(ulFactor) )
-#define CONVERT_LENGTH_INVERT(pos, ulFactor)    CONVERT_POSITION_INVERT(pos, ulFactor)
+        if(newlen && pConfigInfo->fSampleRateConversion) {
+                newlen = SRATE_CONVERT_LENGTH(newlen, pConfigInfo->ulSRatePosition,
+                                                                          pConfigInfo->ulSRateIncrement);
+        }
+        return newlen;
+}
+
+#define CONVERT_POSITION_INVERT(pos, ulFactor)  ( ( pos << CONVERSION_RSHIFT(ulFactor)) >> CONVERSION_LSHIFT(ulFactor) )
+#define CONVERT_LENGTH_INVERT(pos, ulFactor)    CONVERT_POSITION_INVERT(pos, ulFactor)
 //******************************************************************************
 //NOTE: Can only be used for small numbers (up to about 4mb)!! (overflow)
@@ -1516 +1500 @@
 ULONG WAVEAUDIO::ConvertLengthInvert(ULONG length, PWAVECONFIGINFO pConfigInfo)
 {
-    ULONG newlen,tmp,len;
-
-    if (!length) return 0;
-
-    len = length;
-
-    if (pConfigInfo->fSampleRateConversion)
-    {
-        tmp =  SRATE_CONVERT_LENGTH_INVERT(len, pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement);
-        if (tmp && (len != SRATE_CONVERT_LENGTH (tmp, pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement)))
-            tmp--;
-    }
-    else
-        tmp = len;
-
-    if (!tmp) return 0;
-
-    if (pConfigInfo->usConversion != CONVERT_NONE)
-    {
-        newlen =  CONVERT_LENGTH_INVERT (tmp, pConfigInfo->ulConversionFactor);
-        if (newlen && (tmp != CONVERT_LENGTH (newlen, pConfigInfo->ulConversionFactor)) )
-           newlen--;
-    }
-    else
-        newlen = tmp;
-
-//   if ( newlen > length ) dprintf(("!!!!Back len %ld tmp %ld new %ld",length,tmp,newlen ));
-
-//  dprintf(("Overflow len %ld in:%ld inc:%ld pos:%lx",length, len, pConfigInfo->ulSRateIncrement, pConfigInfo->ulSRatePosition));
-    return newlen;
-}
-//******************************************************************************
-//******************************************************************************
-
+        ULONG newlen,tmp,len;
+
+        if (!length) return 0;
+
+        len = length;
+
+        if (pConfigInfo->fSampleRateConversion)
+        {
+                tmp =  SRATE_CONVERT_LENGTH_INVERT(len, pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement);
+                if (tmp && (len != SRATE_CONVERT_LENGTH (tmp, pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement)))
+                        tmp--;
+        }
+        else
+                tmp = len;
+
+        if (!tmp) return 0;
+
+        if (pConfigInfo->usConversion != CONVERT_NONE)
+        {
+                newlen =  CONVERT_LENGTH_INVERT (tmp, pConfigInfo->ulConversionFactor);
+                if (newlen && (tmp != CONVERT_LENGTH (newlen, pConfigInfo->ulConversionFactor)) )
+                   newlen--;
+        }
+        else
+                newlen = tmp;
+
+//       if ( newlen > length ) dprintf(("!!!!Back len %ld tmp %ld new %ld",length,tmp,newlen ));
+
+//      dprintf(("Overflow len %ld in:%ld inc:%ld pos:%lx",length, len, pConfigInfo->ulSRateIncrement, pConfigInfo->ulSRatePosition));
+        return newlen;
+}
+//******************************************************************************
+//******************************************************************************
+

OCO/trunk/drv16/waveplay.cpp

@@ -2 +2 @@
 /* SCCSID = %W% %E% */
 /****************************************************************************
- *                                                                          *
- * Copyright (c) IBM Corporation 1994 - 1997.                               *
- *                                                                          *
- * The following IBM OS/2 source code is provided to you solely for the     *
+ *                                                                                                                                                      *
+ * Copyright (c) IBM Corporation 1994 - 1997.                                                           *
+ *                                                                                                                                                      *
+ * The following IBM OS/2 source code is provided to you solely for the         *
  * the purpose of assisting you in your development of OS/2 device drivers. *
- * You may use this code in accordance with the IBM License Agreement       *
- * provided in the IBM Device Driver Source Kit for OS/2.                   *
- *                                                                          *
+ * You may use this code in accordance with the IBM License Agreement           *
+ * provided in the IBM Device Driver Source Kit for OS/2.                                       *
+ *                                                                                                                                                      *
  ****************************************************************************/
 /**@internal %W%
@@ -15 +15 @@
  * @version %I%
  * @context Unless otherwise noted, all interfaces are Ring-0, 16-bit,
- *  <stack context>.
+ *      <stack context>.
  * @history
  *
@@ -44 +44 @@
 extern "C"
 {
-    ULONG open_strategy = 0UL;
-    ULONG LastSpace=0;
+        ULONG open_strategy = 0UL;
+        ULONG LastSpace=0;
         //int force_close(void);
 }
@@ -59 +59 @@
 BOOL WAVEPLAY::Open(ULONG ulDevice, ULONG ulStreamType, ULONG ulSysFileNum, OSSSTREAMID FAR *pStreamId)
 {
-    ULONG ret;
+        ULONG ret;
         //dprintf(("WAVEPLAY::Open %lx",StreamId));
-    if (fAPMSuspend)
-    {
+        if (fAPMSuspend)
+        {
                 //dprintf(("WAVEPLAY::Open. Suspend state"));
-        apm_resume();
-    }
-
-    if(StreamId == 0UL)
-    {
-        if((ret = OSS16_WaveOpen(ulDevice, ulStreamType, ulSysFileNum, pStreamId)) != OSSERR_SUCCESS)
-        {
-            dprintf(("OSS16_WaveOpen failed!!"));
-            DebugInt3();
+                apm_resume();
+        }
+
+        if(StreamId == 0UL)
+        {
+                if((ret = OSS16_WaveOpen(ulDevice, ulStreamType, ulSysFileNum, pStreamId)) != OSSERR_SUCCESS)
+                {
+                        rprintf(("OSS16_WaveOpen failed!!"));
+                        DebugInt3();
                         //StreamId = 0;
                         //waveOpened = 0;
-            return FALSE;
-        } else
-            waveOpened++;
-        //if the device only supports one active stream, then it is shared by
-        //all wave stream instances. MMPM/2 takes care of proper sharing for us
-        //if the device supports multiple active streams, then we always open
-        //a new ALSA stream
-        //if(devCaps[ulDevice].waveOutCaps.nrStreams == 1) {
-            StreamId = *pStreamId;
-        //}
-        ulDeviceSave = ulDevice;
-        ulStreamTypeSave = ulStreamType;
-        ulSysFileNumSave = ulSysFileNum;
-    }
-    else {
-        *pStreamId = StreamId;
-    }
-    return TRUE;
+                        return FALSE;
+                } else
+                        waveOpened++;
+                //if the device only supports one active stream, then it is shared by
+                //all wave stream instances. MMPM/2 takes care of proper sharing for us
+                //if the device supports multiple active streams, then we always open
+                //a new ALSA stream
+                //if(devCaps[ulDevice].waveOutCaps.nrStreams == 1) {
+                        StreamId = *pStreamId;
+                //}
+                ulDeviceSave = ulDevice;
+                ulStreamTypeSave = ulStreamType;
+                ulSysFileNumSave = ulSysFileNum;
+        }
+        else {
+                *pStreamId = StreamId;
+        }
+        return TRUE;
 }
 
@@ -101 +101 @@
         //dprintf(("WAVEPLAY::Close stream: %lx, %lx, os: %lx", StreamId, waveOpened,open_strategy));
 #if 0 // fixme to be gone?
-    //if ((open_strategy & 1))
-    //if (waveOpened == 1)
-    if (force_closed)
-    {
-        waveOpened--;
-        StreamId = 0UL;
-        open_strategy = 0UL;
-        force_closed = 0;
+        //if ((open_strategy & 1))
+        //if (waveOpened == 1)
+        if (force_closed)
+        {
+                waveOpened--;
+                StreamId = 0UL;
+                open_strategy = 0UL;
+                force_closed = 0;
                 //dprintf(("WAVEPLAY::Closed stream: %lx, %lx, os: %lx", StreamId, waveOpened,open_strategy));
-        return TRUE;
-    }
-    else
+                return TRUE;
+        }
+        else
 #endif // fixme to be gone?
-    {
-/* Setting DISABLE_STREAM_REUSE will close the open stream here.      */
+        {
+/* Setting DISABLE_STREAM_REUSE will close the open stream here.          */
 /* If left unset, the idea is the open stream will be reused instead. */
-/* FIXME: Does it make sense that a Close function does not close     */
-/* anything?                                                          */
+/* FIXME: Does it make sense that a Close function does not close         */
+/* anything?                                                                                                              */
 #ifdef DISABLE_STREAM_REUSE
-        if(devCaps[ulDeviceNr].waveOutCaps.nrStreams > 1)
-        {
-            if (OSS16_WaveClose(StreamIdl) == OSSERR_SUCCESS)
-            {
-                waveOpened--;
-                StreamId = 0UL;
-                open_strategy = 0UL;
+                if(devCaps[ulDeviceNr].waveOutCaps.nrStreams > 1)
+                {
+                        if (OSS16_WaveClose(StreamIdl) == OSSERR_SUCCESS)
+                        {
+                                waveOpened--;
+                                StreamId = 0UL;
+                                open_strategy = 0UL;
                                 dprintf(("OSS16_WAVECLOSE: Success"));
-                return TRUE;
-            } else {
-                dprintf(("OSS16_WAVECLOSE: Error"));
-                return FALSE;
-                        }
-        }
-        else
+                                return TRUE;
+                        } else {
+                                dprintf(("OSS16_WAVECLOSE: Error"));
+                                return FALSE;
+                        }
+                }
+                else
 #else /* !DISABLE_STREAM_REUSE */
                 if (StreamIdl == NULL) return FALSE;
 #endif /* DISABLE_STREAM_REUSE */
-        return TRUE;
-    }
+                return TRUE;
+        }
 }
 //******************************************************************************
@@ -145 +145 @@
 BOOL WAVEPLAY::ConfigDev(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG ulFirstBufSize)
 {
-    OSS32_HWPARAMS hwparam;
-    ULONG          fragsize;
-    int            samplesize;
-    ULONG          ulPCMConsumeRate;
-    USHORT         rc;
-
-
-    if (fAPMSuspend)
-    {
+        OSS32_HWPARAMS hwparam;
+        ULONG              fragsize;
+        int                samplesize;
+        ULONG              ulPCMConsumeRate;
+        USHORT             rc;
+
+
+        if (fAPMSuspend)
+        {
                 //dprintf(("WAVEPLAY::ConfigDev. Suspend state"));
-        apm_resume();
-    }
-
-    if (StreamId == NULL)
-    {
-        WAVEPLAY::Open(ulDeviceSave, ulStreamTypeSave, ulSysFileNumSave, &StreamId);
-        if (StreamId == NULL)
-        {
-            dprintf(("WAVEPLAY::ConfigDev. Error reopening stream"));
-            return FALSE;
-        }
-    }
-    dprintf4(("WAVEPLAY::ConfigDev SampleRate %ld", pConfigInfo->ulHwSampleRate));
-    dprintf4(("WAVEPLAY::ConfigDev ulFirstBufSize=%lx ulFragsize=%lx", ulFirstBufSize, pConfigInfo->ulFragsize));
-
-    if(ulFirstBufSize == 0)
-    {
-        ulFirstBufSize = pConfigInfo->ulFragsize; //no conversion required (see below)
-        if (ulFirstBufSize == 0)
-        {
-            DebugInt3();
-            ulFirstBufSize = 8192; //should never happen!
-            dprintf(("Arg - shouldn't happen"));
-        }
-    }
-    else
-    {
-        //convert size of first buffer
-        ulFirstBufSize = ConvertLength(ulFirstBufSize, pConfigInfo);
-        dprintf4(("ulFirstBufSize %lx", ulFirstBufSize));
-    }
-    //Must call this method (i.e. resets sample rate conversion position)
-    WAVEAUDIO::ConfigDev(StreamId, pConfigInfo, ulFirstBufSize);
-
-    //get real sample format used to program the audio hardware (taking conversion into account)
-    QuerySampleFormat(OPERATION_PLAY, pConfigInfo);
-
-    //convert consume rate
-    ulPCMConsumeRate = ConvertLength(pConfigInfo->ulPCMConsumeRate, pConfigInfo);
-    dprintf4(("cons rate %lx buf size %lx init rate %ld", ulPCMConsumeRate, ulFirstBufSize, pConfigInfo->ulHwSampleRate));
-
-    fragsize = ulPCMConsumeRate/64; //start with 64 irqs/sec   2756
-
-    //if the buffer is smaller than our predefined fragmentsize (*2), then correct it
-    //I assume here that buffers sizes don't radically change (except the last one)
-    //while playing a stream. If they do get a lot smaller, then we'll run into problems.
-    //There's nothing we can do about it as the fragment size can't be changed
-    //while the stream is playing.
-    ULONG minimumsize = ulFirstBufSize/2;  //650
-    if(minimumsize && minimumsize < fragsize)
-    {
-        while(minimumsize < fragsize) fragsize = fragsize / 2; //
-
-            if(fragsize < ulPCMConsumeRate/256)
-            {//lower limit; don't accept extremely small buffers
-                fragsize = ulPCMConsumeRate/256;
-            }
-    }
-    samplesize = (int)pConfigInfo->ulHwSampleSize;
-
-    //round to nearest 64 byte boundary
-    fragsize = (fragsize + 63) & ~(63);
-
-    hwparam.ulPeriodSize    = fragsize;
-    pConfigInfo->ulFragsize = fragsize;
-
-    dprintf4(("fragsize %lx", fragsize));
-    hwparam.ulSampleRate    = pConfigInfo->ulHwSampleRate;
-    hwparam.ulBitsPerSample = pConfigInfo->ulHwBitsPerSample;
-    hwparam.ulNumChannels   = pConfigInfo->ulHwNumChannels;
-    hwparam.ulDataType      = QueryOSSDataFormat(OPERATION_PLAY, pConfigInfo->ulDataType, pConfigInfo->ulHwBitsPerSample);
-    rc = (USHORT)OSS16_WaveSetFormat(StreamId, &hwparam);
-        dprintf4(("WAVEPLAY:ConfigDev:OSS16_WaveSetFormat . rc = %d",rc));
-        dprintf4(("samp rate=%ld bps=%ld channels=%ld type=%ld", hwparam.ulSampleRate, hwparam.ulBitsPerSample, hwparam.ulNumChannels, hwparam.ulDataType));
-
-    if( rc != OSSERR_SUCCESS) {
-        dprintf(("WAVEPLAY:ConfigDev: rc %d",rc));
-        DebugInt3();
-        // vladest
-//        OSS16_WaveClose(StreamId);
-//        StreamId = 0;
-//        waveOpened = 0;
-        return FALSE;
-    }
-    return TRUE;
+                apm_resume();
+        }
+
+        if (StreamId == NULL)
+        {
+                WAVEPLAY::Open(ulDeviceSave, ulStreamTypeSave, ulSysFileNumSave, &StreamId);
+                if (StreamId == NULL)
+                {
+                        rprintf(("WAVEPLAY::ConfigDev. Error reopening stream"));
+                        return FALSE;
+                }
+        }
+        dprintf4(("WAVEPLAY::ConfigDev SampleRate %ld", pConfigInfo->ulHwSampleRate));
+        dprintf4(("WAVEPLAY::ConfigDev ulFirstBufSize=%lx ulFragsize=%lx", ulFirstBufSize, pConfigInfo->ulFragsize));
+
+        if(ulFirstBufSize == 0)
+        {
+                ulFirstBufSize = pConfigInfo->ulFragsize; //no conversion required (see below)
+                if (ulFirstBufSize == 0)
+                {
+                        DebugInt3();
+                        ulFirstBufSize = 8192; //should never happen!
+                        rprintf(("Arg - shouldn't happen"));
+                }
+        }
+        else
+        {
+                //convert size of first buffer
+                ulFirstBufSize = ConvertLength(ulFirstBufSize, pConfigInfo);
+                dprintf4(("ulFirstBufSize %lx", ulFirstBufSize));
+        }
+        //Must call this method (i.e. resets sample rate conversion position)
+        WAVEAUDIO::ConfigDev(StreamId, pConfigInfo, ulFirstBufSize);
+
+        //get real sample format used to program the audio hardware (taking conversion into account)
+        QuerySampleFormat(OPERATION_PLAY, pConfigInfo);
+
+        //convert consume rate
+        ulPCMConsumeRate = ConvertLength(pConfigInfo->ulPCMConsumeRate, pConfigInfo);
+        dprintf4(("cons rate %lx buf size %lx init rate %ld", ulPCMConsumeRate, ulFirstBufSize, pConfigInfo->ulHwSampleRate));
+
+        fragsize = ulPCMConsumeRate/64; //start with 64 irqs/sec   2756
+
+        //if the buffer is smaller than our predefined fragmentsize (*2), then correct it
+        //I assume here that buffers sizes don't radically change (except the last one)
+        //while playing a stream. If they do get a lot smaller, then we'll run into problems.
+        //There's nothing we can do about it as the fragment size can't be changed
+        //while the stream is playing.
+        ULONG minimumsize = ulFirstBufSize/2;  //650
+        if(minimumsize && minimumsize < fragsize)
+        {
+                while(minimumsize < fragsize) fragsize = fragsize / 2; //
+
+                if(fragsize < ulPCMConsumeRate/256)
+                {//lower limit; don't accept extremely small buffers
+                        fragsize = ulPCMConsumeRate/256;
+                }
+        }
+        samplesize = (int)pConfigInfo->ulHwSampleSize;
+
+        //round to nearest 64 byte boundary
+        fragsize = (fragsize + 63) & ~(63);
+
+        hwparam.ulPeriodSize    = fragsize;
+        pConfigInfo->ulFragsize = fragsize;
+
+        dprintf4(("fragsize %lx", fragsize));
+        hwparam.ulSampleRate    = pConfigInfo->ulHwSampleRate;
+        hwparam.ulBitsPerSample = pConfigInfo->ulHwBitsPerSample;
+        hwparam.ulNumChannels   = pConfigInfo->ulHwNumChannels;
+        hwparam.ulDataType              = QueryOSSDataFormat(OPERATION_PLAY, pConfigInfo->ulDataType, pConfigInfo->ulHwBitsPerSample);
+        rc = (USHORT)OSS16_WaveSetFormat(StreamId, &hwparam);
+                dprintf4(("WAVEPLAY:ConfigDev:OSS16_WaveSetFormat . rc = %d",rc));
+                dprintf4(("samp rate=%ld bps=%ld channels=%ld type=%ld", hwparam.ulSampleRate, hwparam.ulBitsPerSample, hwparam.ulNumChannels, hwparam.ulDataType));
+
+        if( rc != OSSERR_SUCCESS) {
+                dprintf(("WAVEPLAY:ConfigDev: rc %d",rc));
+                DebugInt3();
+                // vladest
+//                OSS16_WaveClose(StreamId);
+//                StreamId = 0;
+//                waveOpened = 0;
+                return FALSE;
+        }
+        return TRUE;
 }
 //******************************************************************************
@@ -246 +246 @@
 //******************************************************************************
 BOOL WAVEPLAY::Transfer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo,
-                        LINEAR pUserBuffer, ULONG ulBytesToTransfer,
-                        ULONG FAR *pulBytesTransferred)
-{
-    *pulBytesTransferred = 0;
-
-    //dprintf(("WAVEPLAY::Transfer %ld",ulBytesToTransfer));
-
-    if (fAPMSuspend) {
+                                                LINEAR pUserBuffer, ULONG ulBytesToTransfer,
+                                                ULONG FAR *pulBytesTransferred)
+{
+        *pulBytesTransferred = 0;
+
+        //dprintf(("WAVEPLAY::Transfer %ld",ulBytesToTransfer));
+
+        if (fAPMSuspend) {
                 //dprintf(("WAVEPLAY::Transfer. Suspend state"));
-        apm_resume();
-    }
-
-    if (!ulBytesToTransfer) {
-        return TRUE;
-    }
+                apm_resume();
+        }
+
+        if (!ulBytesToTransfer) {
+                return TRUE;
+        }
 
         //if (!waveOpened) return TRUE;
 
-    if(pConfigInfo->usConversion == CONVERT_NONE)
-    {
-        if (AddBuffer(StreamId, pConfigInfo, pUserBuffer, ulBytesToTransfer, pulBytesTransferred) == FALSE)
-        {
-            dprintf(("Transfer.False. NoConv ulB %ld tr:%ld",ulBytesToTransfer,*pulBytesTransferred));
-            *pulBytesTransferred = 0;
-            return FALSE;
-        }
-    }
-    else
-    {
-        if(pConfigInfo->pfnConvert)
-        {
-            ULONG ulCvtBufferSize;
-
-            //bytes to convert is bounded by bytes to transfer & max conversion buffer size
-            ulCvtBufferSize = CONVERT_LENGTH(ulBytesToTransfer, pConfigInfo->ulConversionFactor);
-            ulCvtBufferSize = min(CONVERSION_BUFFER_SIZE, ulCvtBufferSize);
-
-            //convert back from conversion to 'real'
-            ulBytesToTransfer = CONVERT_LENGTH(ulCvtBufferSize, CONVERSION_INVERT(pConfigInfo->ulConversionFactor));
-
-            if(ulBytesToTransfer & (pConfigInfo->ulSampleSize-1))
-            {
-                dprintf(("Transfer New ulBr %ld" , ulBytesToTransfer));
+        if(pConfigInfo->usConversion == CONVERT_NONE)
+        {
+                if (AddBuffer(StreamId, pConfigInfo, pUserBuffer, ulBytesToTransfer, pulBytesTransferred) == FALSE)
+                {
+                        rprintf(("Transfer failed. NoConv ulB %ld tr:%ld",ulBytesToTransfer,*pulBytesTransferred));
+                        *pulBytesTransferred = 0;
+                        return FALSE;
+                }
+        }
+        else
+        {
+                if(pConfigInfo->pfnConvert)
+                {
+                        ULONG ulCvtBufferSize;
+
+                        //bytes to convert is bounded by bytes to transfer & max conversion buffer size
+                        ulCvtBufferSize = CONVERT_LENGTH(ulBytesToTransfer, pConfigInfo->ulConversionFactor);
+                        ulCvtBufferSize = min(CONVERSION_BUFFER_SIZE, ulCvtBufferSize);
+
+                        //convert back from conversion to 'real'
+                        ulBytesToTransfer = CONVERT_LENGTH(ulCvtBufferSize, CONVERSION_INVERT(pConfigInfo->ulConversionFactor));
+
+                        if(ulBytesToTransfer & (pConfigInfo->ulSampleSize-1))
+                        {
+                                dprintf(("Transfer New ulBr %ld" , ulBytesToTransfer));
                                 //DebugInt3();
-                ulBytesToTransfer = ulBytesToTransfer & ~(pConfigInfo->ulSampleSize-1);
-                dprintf(("Transfer New ulBr %ld" , ulBytesToTransfer));
-            }
-            pConfigInfo->pfnConvert(pUserBuffer, ulBytesToTransfer, pConfigInfo->pConversionBuffer);
-            if(AddBuffer(StreamId, pConfigInfo, pConfigInfo->pConversionBuffer, ulCvtBufferSize, pulBytesTransferred) == FALSE)
-            {
-                *pulBytesTransferred = 0;
-                return FALSE;
-            }
-            //convert back from conversion to 'real'
-            *pulBytesTransferred = CONVERT_LENGTH(*pulBytesTransferred, CONVERSION_INVERT(pConfigInfo->ulConversionFactor));
-            if(*pulBytesTransferred & (pConfigInfo->ulSampleSize-1))
-            {
-                dprintf(("Transfer New pulBr %ld" , pulBytesTransferred));
+                                ulBytesToTransfer = ulBytesToTransfer & ~(pConfigInfo->ulSampleSize-1);
+                                dprintf(("Transfer New ulBr %ld" , ulBytesToTransfer));
+                        }
+                        pConfigInfo->pfnConvert(pUserBuffer, ulBytesToTransfer, pConfigInfo->pConversionBuffer);
+                        if(AddBuffer(StreamId, pConfigInfo, pConfigInfo->pConversionBuffer, ulCvtBufferSize, pulBytesTransferred) == FALSE)
+                        {
+                                *pulBytesTransferred = 0;
+                                return FALSE;
+                        }
+                        //convert back from conversion to 'real'
+                        *pulBytesTransferred = CONVERT_LENGTH(*pulBytesTransferred, CONVERSION_INVERT(pConfigInfo->ulConversionFactor));
+                        if(*pulBytesTransferred & (pConfigInfo->ulSampleSize-1))
+                        {
+                                dprintf(("Transfer New pulBr %ld" , pulBytesTransferred));
                                 //DebugInt3();
-            }
-        }
-        else
-        {
-            dprintf(("Transfer Zero pConfigInfo->pfnConvert"));
+                        }
+                }
+                else
+                {
+                        rprintf(("Transfer Zero pConfigInfo->pfnConvert"));
                         //DebugInt3();
-            return FALSE;
-        }
-    }
-    return TRUE;
+                        return FALSE;
+                }
+        }
+        return TRUE;
 }
 //******************************************************************************
@@ -320 +320 @@
 //******************************************************************************
 BOOL WAVEPLAY::AddBuffer(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, LINEAR pUserBuffer,
-                         ULONG ulBytesToTransfer, ULONG FAR *pulBytesTransferred)
-{
-    OSSRET rc;
-    ULONG  Space;
+                                                 ULONG ulBytesToTransfer, ULONG FAR *pulBytesTransferred)
+{
+        OSSRET rc;
+        ULONG  Space;
         //if (!waveOpened) return TRUE;
 
         //PS Here is inrerrupt time....
-    if (fAPMSuspend) {
+        if (fAPMSuspend) {
                 //dprintf(("WAVEPLAY::AddBuffer. Suspend state"));
-        apm_resume();
-        //return FALSE;
-    }
-
-    if (pConfigInfo->fSampleRateConversion)
-    {
-        ULONG  ulCvtBufferSize, ulSampleCount, ulHwSampleCount;
-        LONG   lSRatePosition;
-
-        //bytes to convert is bounded by bytes to transfer & max conversion buffer size
-        ulCvtBufferSize = SRATE_CONVERT_LENGTH(ulBytesToTransfer, pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement);
-        ulCvtBufferSize = min(CONVERSION_BUFFER_SIZE, ulCvtBufferSize);
-        //round to sample boundary
-        ulCvtBufferSize &= ~(pConfigInfo->ulHwSampleSize - 1);
-
-        if(ulCvtBufferSize == 0)
-        {
-            *pulBytesTransferred = ulBytesToTransfer;
-            if(pConfigInfo->ulSRatePosition >= pConfigInfo->ulSRateIncrement)
-            {
-                pConfigInfo->ulSRatePosition -= pConfigInfo->ulSRateIncrement;
-            }
-            return TRUE;
-        }
-        pConfigInfo->pfnSRateConv(pUserBuffer, ulCvtBufferSize, pConfigInfo->pSRateConvBuffer,
-                                  pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement);
-        OSS16_WaveGetSpace(StreamId, &Space);
-        if (ulCvtBufferSize > Space)
-        {
-            dprintf(("WPLAY::AddBuffer need %ld space:%ld", ulCvtBufferSize, Space));
-            if (Space < pConfigInfo->ulBytesPerIRQ)
-            {
-               return TRUE;
-            }
-
-            if (ulCvtBufferSize > Space)
-                ulCvtBufferSize = Space & ~(pConfigInfo->ulHwSampleSize - 1);
-        }
-        if ((rc = OSS16_WaveAddBuffer(StreamId, pConfigInfo->pSRateConvBuffer, ulCvtBufferSize, pulBytesTransferred)) != OSSERR_SUCCESS
-             ||  *pulBytesTransferred == 0)
-        {
-            if(rc == OSSERR_BUFFER_FULL)
-            {
-                 GetSpace(StreamId, pConfigInfo, &Space);
-                 dprintf(("WPLAY::AddBuffer; %ld %x failed due to full buffer free space:%ld", ulCvtBufferSize, (USHORT)rc,Space));
-            }
-#ifdef DEBUG
-            else
-                dprintf(("WPLAY::AddBuffer; %ld rc=%x failed", ulCvtBufferSize, (USHORT)rc));
-#endif
-            *pulBytesTransferred = 0;
-            return FALSE;
-        }
-        ulHwSampleCount = *pulBytesTransferred/pConfigInfo->ulHwSampleSize;
-
-        //convert back from conversion to 'real'
-        ulSampleCount   = SRATE_CONVERT_LENGTH_INVERT(ulHwSampleCount,
-                                                      pConfigInfo->ulSRatePosition,
-                                                      pConfigInfo->ulSRateIncrement);
-
-        //update sample rate position
-
-        lSRatePosition = (LONG)(pConfigInfo->ulSRatePosition + ulHwSampleCount * pConfigInfo->ulSRateIncrement);
-        lSRatePosition = lSRatePosition - (LONG)ulSampleCount*(LONG)SRATE_SHIFT_VALUE;
-
-        // if the last sample is still needed for the next run, then adjust sample count and
-        // sample rate conversion position
-        if(lSRatePosition < 0)
-        {
-            dprintf4(("WAVEPLAY::AddBuffer; sratepos < 0"));
-            dprintf4(("ulHwSampleCount %lx pConfigInfo->ulSRateIncrement %lx ulSampleCount %lx", ulHwSampleCount, pConfigInfo->ulSRateIncrement, ulSampleCount));
-            pConfigInfo->ulSRatePosition = 0;
-        }
-        else
-        {
-            pConfigInfo->ulSRatePosition = (ULONG)lSRatePosition;
-        }
-        *pulBytesTransferred = ulSampleCount*pConfigInfo->ulHwSampleSize;
-    }
-    else
-    {
-       if( (rc=OSS16_WaveAddBuffer(StreamId, pUserBuffer, ulBytesToTransfer, pulBytesTransferred)) != OSSERR_SUCCESS)
-       {
-            *pulBytesTransferred = 0;
-            dprintf(("WPLAY::AddBuffer; OSS16_WaveAddBuffer failed due to an error rc=%x",(USHORT)rc));
-            dprintf(("StreamID:%x PUB:%lx BtTr:%ld",(USHORT)StreamId, pUserBuffer, ulBytesToTransfer));
-            return FALSE;
-       }
-    }
-    return TRUE;
+                apm_resume();
+                //return FALSE;
+        }
+
+        if (pConfigInfo->fSampleRateConversion)
+        {
+                ULONG  ulCvtBufferSize, ulSampleCount, ulHwSampleCount;
+                LONG   lSRatePosition;
+
+                //bytes to convert is bounded by bytes to transfer & max conversion buffer size
+                ulCvtBufferSize = SRATE_CONVERT_LENGTH(ulBytesToTransfer, pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement);
+                ulCvtBufferSize = min(CONVERSION_BUFFER_SIZE, ulCvtBufferSize);
+                //round to sample boundary
+                ulCvtBufferSize &= ~(pConfigInfo->ulHwSampleSize - 1);
+
+                if(ulCvtBufferSize == 0)
+                {
+                        *pulBytesTransferred = ulBytesToTransfer;
+                        if(pConfigInfo->ulSRatePosition >= pConfigInfo->ulSRateIncrement)
+                        {
+                                pConfigInfo->ulSRatePosition -= pConfigInfo->ulSRateIncrement;
+                        }
+                        return TRUE;
+                }
+                pConfigInfo->pfnSRateConv(pUserBuffer, ulCvtBufferSize, pConfigInfo->pSRateConvBuffer,
+                                                                  pConfigInfo->ulSRatePosition, pConfigInfo->ulSRateIncrement);
+                OSS16_WaveGetSpace(StreamId, &Space);
+                if (ulCvtBufferSize > Space)
+                {
+                        dprintf(("WPLAY::AddBuffer need %ld space:%ld", ulCvtBufferSize, Space));
+                        if (Space < pConfigInfo->ulBytesPerIRQ)
+                        {
+                           return TRUE;
+                        }
+
+                        if (ulCvtBufferSize > Space)
+                                ulCvtBufferSize = Space & ~(pConfigInfo->ulHwSampleSize - 1);
+                }
+                if ((rc = OSS16_WaveAddBuffer(StreamId, pConfigInfo->pSRateConvBuffer, ulCvtBufferSize, pulBytesTransferred)) != OSSERR_SUCCESS
+                         ||  *pulBytesTransferred == 0)
+                {
+                        if(rc == OSSERR_BUFFER_FULL) {
+                                 GetSpace(StreamId, pConfigInfo, &Space);
+                                 rprintf(("WPLAY::AddBuffer; %ld %x failed due to full buffer free space:%ld", ulCvtBufferSize, (USHORT)rc,Space));
+                        } else {
+                                rprintf(("WPLAY::AddBuffer; %ld rc=%x failed", ulCvtBufferSize, (USHORT)rc));
+                        }
+                        *pulBytesTransferred = 0;
+                        return FALSE;
+                }
+                ulHwSampleCount = *pulBytesTransferred/pConfigInfo->ulHwSampleSize;
+
+                //convert back from conversion to 'real'
+                ulSampleCount   = SRATE_CONVERT_LENGTH_INVERT(ulHwSampleCount,
+                                                                                                          pConfigInfo->ulSRatePosition,
+                                                                                                          pConfigInfo->ulSRateIncrement);
+
+                //update sample rate position
+
+                lSRatePosition = (LONG)(pConfigInfo->ulSRatePosition + ulHwSampleCount * pConfigInfo->ulSRateIncrement);
+                lSRatePosition = lSRatePosition - (LONG)ulSampleCount*(LONG)SRATE_SHIFT_VALUE;
+
+                // if the last sample is still needed for the next run, then adjust sample count and
+                // sample rate conversion position
+                if(lSRatePosition < 0)
+                {
+                        dprintf4(("WAVEPLAY::AddBuffer; sratepos < 0"));
+                        dprintf4(("ulHwSampleCount %lx pConfigInfo->ulSRateIncrement %lx ulSampleCount %lx", ulHwSampleCount, pConfigInfo->ulSRateIncrement, ulSampleCount));
+                        pConfigInfo->ulSRatePosition = 0;
+                }
+                else
+                {
+                        pConfigInfo->ulSRatePosition = (ULONG)lSRatePosition;
+                }
+                *pulBytesTransferred = ulSampleCount*pConfigInfo->ulHwSampleSize;
+        }
+        else
+        {
+           if( (rc=OSS16_WaveAddBuffer(StreamId, pUserBuffer, ulBytesToTransfer, pulBytesTransferred)) != OSSERR_SUCCESS)
+           {
+                        *pulBytesTransferred = 0;
+                        rprintf(("WPLAY::AddBuffer; OSS16_WaveAddBuffer failed due to an error rc=%x",(USHORT)rc));
+                        dprintf(("StreamID:%x PUB:%lx BtTr:%ld",(USHORT)StreamId, pUserBuffer, ulBytesToTransfer));
+                        return FALSE;
+           }
+        }
+        return TRUE;
 }
 //******************************************************************************
@@ -425 +422 @@
 BOOL WAVEPLAY::GetPosition(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulStreamPosition)
 {
-    ULONG ulCurBytesProcessed;
-
-//    if (!waveOpened) return TRUE;
-
-    if(OSS16_WaveGetPos(StreamId, &ulCurBytesProcessed) != OSSERR_SUCCESS) {
-        *pulStreamPosition = 0;
-        dprintf(("WAVEPLAY::GetPosition: Failed"));
-        return FALSE;
-    }
-
-    *pulStreamPosition  = ConvertPositionInvert(ulCurBytesProcessed, pConfigInfo);
-     //round to sample boundary
-    *pulStreamPosition &= ~(pConfigInfo->ulSampleSize - 1);
-    return TRUE;
+        ULONG ulCurBytesProcessed;
+
+        //if (!waveOpened) return TRUE;
+
+        if(OSS16_WaveGetPos(StreamId, &ulCurBytesProcessed) != OSSERR_SUCCESS) {
+                *pulStreamPosition = 0;
+                rprintf(("WAVEPLAY::GetPosition: Failed"));
+                return FALSE;
+        }
+
+        *pulStreamPosition      = ConvertPositionInvert(ulCurBytesProcessed, pConfigInfo);
+         //round to sample boundary
+        *pulStreamPosition &= ~(pConfigInfo->ulSampleSize - 1);
+        return TRUE;
 }
 //******************************************************************************
@@ -445 +442 @@
 BOOL WAVEPLAY::GetSpace(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulStreamSpace)
 {
-    ULONG space,cvt;
-
-//    if (!waveOpened) return TRUE;
-
-    if(OSS16_WaveGetSpace(StreamId, &space) != OSSERR_SUCCESS)
-    {
-        *pulStreamSpace = 0;
-        dprintf(("WAVEPLAY::GetSpace: Failed"));
-        return FALSE;
-    }
-
-//    dprintf(("GetSpace: len %ld",space));
-    cvt  = ConvertLengthInvert(space, pConfigInfo);
-    //round to sample boundary
-    *pulStreamSpace =cvt & ( ~(pConfigInfo->ulSampleSize - 1));
-    return TRUE;
+        ULONG space,cvt;
+
+        //if (!waveOpened) return TRUE;
+
+        if(OSS16_WaveGetSpace(StreamId, &space) != OSSERR_SUCCESS)
+        {
+                *pulStreamSpace = 0;
+                rprintf(("WAVEPLAY::GetSpace: Failed"));
+                return FALSE;
+        }
+
+        //dprintf(("GetSpace: len %ld",space));
+        cvt  = ConvertLengthInvert(space, pConfigInfo);
+        //round to sample boundary
+        *pulStreamSpace =cvt & ( ~(pConfigInfo->ulSampleSize - 1));
+        return TRUE;
 }
 //******************************************************************************
@@ -467 +464 @@
 BOOL WAVEPLAY::GetHwPtr(OSSSTREAMID StreamId, PWAVECONFIGINFO pConfigInfo, ULONG FAR *pulHwPtr)
 {
-    ULONG space,cvt;
-
-    if(OSS16_WaveGetHwPtr(StreamId, &space) != OSSERR_SUCCESS)
-    {
-        *pulHwPtr = 0;
-        dprintf(("WAVEPLAY::WaveGetHwPtr: Failed"));
-        return FALSE;
-    }
-
-    cvt  = ConvertLengthInvert(space, pConfigInfo);
-    //round to sample boundary
-    *pulHwPtr = cvt & (~(pConfigInfo->ulSampleSize - 1));
-    return TRUE;
+        ULONG space,cvt;
+
+        if(OSS16_WaveGetHwPtr(StreamId, &space) != OSSERR_SUCCESS)
+        {
+                *pulHwPtr = 0;
+                rprintf(("WAVEPLAY::WaveGetHwPtr: Failed"));
+                return FALSE;
+        }
+
+        cvt  = ConvertLengthInvert(space, pConfigInfo);
+        //round to sample boundary
+        *pulHwPtr = cvt & (~(pConfigInfo->ulSampleSize - 1));
+        return TRUE;
 }
 //******************************************************************************
@@ -486 +483 @@
 BOOL WAVEPLAY::SetVolume(OSSSTREAMID StreamId, OSSSTREAMID mixerStreamId, ULONG ulVolume)
 {
-    return MixerSetWaveVolume(mixerStreamId, StreamId, ulVolume);
+        return MixerSetWaveVolume(mixerStreamId, StreamId, ulVolume);
 }
 //******************************************************************************
@@ -494 +491 @@
 #pragma on (unreferenced)
 {
-    return MixerQueryVolume(mixerStreamId, OSS32_MIX_VOLUME_CAPTURE);
+        return MixerQueryVolume(mixerStreamId, OSS32_MIX_VOLUME_CAPTURE);
 }
 //******************************************************************************
@@ -502 +499 @@
 #pragma on (unreferenced)
 {
-    DebugInt3();
-    return FALSE;
+        DebugInt3();
+        return FALSE;
 }
 
@@ -509 +506 @@
 #pragma data_seg ("_initdata","endds");
 /******************************************************************************/
-/* WAVEPLAY::WAVEPLAY(USHORT PrimeDma, USHORT SecDma, USHORT Irq)             */
-/* The constructor, basicly passes the resources info up the stream to the    */
-/* "parent classes" and calles _vSetup which constructs all the resource      */
-/* class objects we need to run.                                              */
-/*                                                                            */
+/* WAVEPLAY::WAVEPLAY(USHORT PrimeDma, USHORT SecDma, USHORT Irq)                         */
+/* The constructor, basicly passes the resources info up the stream to the        */
+/* "parent classes" and calles _vSetup which constructs all the resource          */
+/* class objects we need to run.                                                                                          */
+/*                                                                                                                                                        */
 /******************************************************************************/
 

OCO/trunk/drv16/waverec.cpp

@@ -45 +45 @@
         if(OSS16_WaveOpen(ulDevice, ulStreamType, ulSysFileNum, pStreamId) != OSSERR_SUCCESS)
         {
-            dprintf(("OSS16_WaveOpen failed!!"));
+            rprintf(("OSS16_WaveOpen failed!!"));
             DebugInt3();
             StreamId = 0;
@@ -139 +139 @@
     hwparam.ulDataType      = QueryOSSDataFormat(OPERATION_RECORD, pConfigInfo->ulDataType, pConfigInfo->ulHwBitsPerSample);
     if(OSS16_WaveSetFormat(StreamId, &hwparam) != OSSERR_SUCCESS) {
-                dprintf(("WAVEREC::ConfigDev: WaveSetFormat failed"));
+                rprintf(("WAVEREC::ConfigDev: WaveSetFormat failed"));
         DebugInt3();
         return FALSE;
@@ -152 +152 @@
                        ULONG FAR *pulBytesTransferred)
 {
-#ifdef DEBUG
     //dprintf(("WAVEREC::Transfer %lx bytes", ulBytesToTransfer));
-#endif
     if(pConfigInfo->usConversion == CONVERT_NONE)
     {
@@ -308 +306 @@
     if(OSS16_WaveGetHwPtr(StreamId, &space) != OSSERR_SUCCESS) {
         *pulHwPtr = 0;
-        #ifdef DEBUG
-        dprintf(("OSS16_WAVEREC::WaveGetHwPtr: Failed"));
-        #endif /* DEBUG */
+        rprintf(("OSS16_WAVEREC::WaveGetHwPtr: Failed"));
         return FALSE;
     }

OCO/trunk/drv16/wavestrm.cpp

@@ -1 +1 @@
 /* SCCSID = %W% %E% */
 /****************************************************************************
- *                                                                          *
- * Copyright (c) IBM Corporation 1994 - 1997.                               *
- *                                                                          *
- * The following IBM OS/2 source code is provided to you solely for the     *
+ *                                                                                                                                                      *
+ * Copyright (c) IBM Corporation 1994 - 1997.                                                           *
+ *                                                                                                                                                      *
+ * The following IBM OS/2 source code is provided to you solely for the         *
  * the purpose of assisting you in your development of OS/2 device drivers. *
- * You may use this code in accordance with the IBM License Agreement       *
- * provided in the IBM Device Driver Source Kit for OS/2.                   *
- *                                                                          *
+ * You may use this code in accordance with the IBM License Agreement           *
+ * provided in the IBM Device Driver Source Kit for OS/2.                                       *
+ *                                                                                                                                                      *
  ****************************************************************************/
 /**@internal %W%
@@ -14 +14 @@
  * @version %I%
  * @context Unless otherwise noted, all interfaces are Ring-0, 16-bit,
- *  <stack context>.
+ *      <stack context>.
  * @history
  *
  */
 #define INCL_NOPMAPI
-#define INCL_DOSERRORS            // for ERROR_INVALID_FUNCTION
+#define INCL_DOSERRORS                    // for ERROR_INVALID_FUNCTION
 #include <os2.h>
 #include <os2me.h>
-#include <audio.h>                // for #define MIDI
+#include <audio.h>                                // for #define MIDI
 #include <string.h>
 #include <include.h>
@@ -42 +42 @@
 extern "C" ULONG  __cdecl __saveregs OSSIDC_EntryPoint(ULONG cmd, ULONG param1, ULONG param2);
 
-
-//******************************************************************************
-//  _vRealignBuffer
-//  called just after a wave stream pause on a playback.
-//  Gets the end position of the stream when paused and a pointer to a
-//  STREAMBUFFER. Basicly this function looks at the streambuffer and if
+#define SNDRV_PCM_STATE_XRUN 4 /* stream reached an xrun */
+
+//******************************************************************************
+//      _vRealignBuffer
+//      called just after a wave stream pause on a playback.
+//      Gets the end position of the stream when paused and a pointer to a
+//      STREAMBUFFER. Basicly this function looks at the streambuffer and if
 // there is any unplayed data in it it adjusts the bufpos counter.
 // the donepos counter is ALWAYS set to zero. It will return 0 if all
 // the data has been played and 1 if there is still some data left.
 //******************************************************************************
-USHORT  WAVESTREAM::_vRealignBuffer(ULONG ulEndPos, PSTREAMBUFFER pBuffer)
+USHORT  WAVESTREAM::_vRealignBuffer(ULONG ulEndPos, PSTREAMBUFFER pBuffer)
 {
         if (ulEndPos >= pBuffer->ulDonepos) { /* all of the data has been consumed */
@@ -115 +116 @@
                 }
 
-                // if there are buffere on the done queue, pop them off the head and
+                // if there are buffers on the done queue, pop them off the head and
                 // push them on the head of qhTempHead.  This will reorder them so
                 // that the more recently used ones will be in the front of the queue.
@@ -122 +123 @@
                 // be returned) so put it on the Tail of the done queue.
                 // If the rc is 1 then put it on the head of the InProcess queue.
-
                 while (qhDone.IsElements()) {
                         pTempHead->PushOnHead(qhDone.PopHead());
@@ -130 +130 @@
                 {
                         usRC = _vRealignBuffer(ulEndPos, (PSTREAMBUFFER)pTempHead->Head());
-                        if (usRC)
+                        if (usRC) {
                                 qhInProcess.PushOnHead(pTempHead->PopHead());
-                        else
-                                qhDone.PushOnTail(pTempHead->PopHead());
+                        } else {
+                                qhDone.PushOnHead(pTempHead->PopHead());
+                        }
                 }
                 while (qhDone.IsElements()) {
@@ -142 +143 @@
                 break;
         } /* endswitch */
+        delete pTempHead; // free the memory
+}
+
+void WAVESTREAM::_vUnderrunStop(PCHAR pchStr)
+{
+        if (ulStreamState == STREAM_STOPPED) return;
+        rprintf(("%s: Underrun-stop", pchStr));
+        //pahw->SetVolume(StreamId, getMixerStreamId(), 0);
+        pahw->Stop(StreamId);
+        ulStreamState = STREAM_STOPPED;
+        fUnderrun = TRUE;
+        _ulBytesProcessed = 0;
+        _ulBytesWritten = 0;
+}
+
+ULONG WAVESTREAM::_vUnderrunStart(void)
+{
+        if (ulStreamState == STREAM_STREAMING) return 0;
+        rprintf(("Underrun-start"));
+        PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
+//      if(pahw->ConfigDev(StreamId, &_configinfo, (pTemp) ? pTemp->ulBuffsz : 0) == FALSE) {
+//              rprintf(("WS::Write: ConfigDev failed"));
+//              return ERROR_INSUFF_BUFFER;
+//      }
+        _configinfo.ulSRatePosition = 0;
+        // prepare wave device for playback/recording
+        if(pahw->Prepare(StreamId) == FALSE) {
+                rprintf(("WS::UR Start: Prepare failed"));
+                return ERROR_START_STREAM;
+        }
+
+        _ulBytesProcessed = 0;
+        _ulBytesWritten = 0;
+        ulStreamState = STREAM_STREAMING;
+        fUnderrun = FALSE;
+        //if (ulStreamType == STREAM_WAVE_PLAY) pahw->SetVolume(StreamId, getMixerStreamId(), volume);
+        return 0;
 }
 
@@ -150 +188 @@
 // if this is a write stream call _vFillAudioBuf
 //******************************************************************************
+static short sAddBuffersInProcess = 0;
+static short sDbgSave;
 #pragma off (unreferenced)
-void WAVESTREAM::AddBuffers(BOOL fFirst)
+void WAVESTREAM::AddBuffers(SHORT sFirst)
 #pragma on (unreferenced)
 {
-    ULONG ulSpace, ulBytesWritten;
+        ULONG ulSpace, ulBytesWritten;
         ULONG ulDAZ;
-
-        //dgprintf(("WS:AddBuffers First=%d, SampleSize=%lx", fFirst, _configinfo.ulSampleSize));
-
-    ulBytesWritten = 0;
-    if (ulStreamType & STREAM_WRITE)
-    {
-        // get the space available in the hardware buffer
-        // only call GetSpace once because the amount of free space in
-        // the hardware buffer is a moving target and calling it more than once
-        // could keep us in this loop writing 4 or 8 bytes at a time.
-        // In extream cases we will stay stuck in this loop long enough to casue a trap rjj
-                if (pahw->GetSpace(StreamId, &_configinfo, &ulSpace) == FALSE)
-        {
-                        dgprintf(("WAVESTREAM::AddBuffers GetSpace failed"));
-            return;
-        }
-        ulSpace &= (~(_configinfo.ulSampleSize - 1));
+        ULONG ulStatus;
+
+        //dprintf(("WS:AddBuffers First=%d, SampleSize=%lx", sFirst, _configinfo.ulSampleSize));
+
+        if (sAddBuffersInProcess) {
+                // This routine cannot be reentered
+                // Some systems generate an extra interrupt causing this routine to be reentered
+                // so we ignore the call that causes us to be reentered
+                rprintf(("WS::ABS InProcess Now=%x Save=%x", sFirst, sDbgSave));
+                return;
+        }
+        sAddBuffersInProcess++;
+        sDbgSave = sFirst;
+
+        ulBytesWritten = 0;
+        if (ulStreamType & STREAM_WRITE)
+        {
+                // get the space available in the hardware buffer
+                // only call GetSpace once because the amount of free space in
+                // the hardware buffer is a moving target and calling it more than once
+                // could keep us in this loop writing 4 or 8 bytes at a time.
+                // In extream cases we will stay stuck in this loop long enough to casue a trap rjj
+                if (pahw->GetSpace(StreamId, &_configinfo, &ulSpace) == FALSE) {
+                        rprintf(("WS::ABS GetSpace failed"));
+                        return;
+                }
+                ulSpace &= (~(_configinfo.ulSampleSize - 1));
+#if 1
+                /* DAZ testing -- underrun detection */
+                if (ulSpace == 0) {
+                        OSS16_WaveGetStatus(StreamId, &ulStatus);
+                        rprintf(("WS::ABS ulSpace=0 state=%lx u32status=%lx", ulStreamState, ulStatus));
+
+                        _vUnderrunStop("WS:ABS");
+                        _vUnderrunStart();
+
+                        if (pahw->GetSpace(StreamId, &_configinfo, &ulSpace) == FALSE) {
+                                rprintf(("WS::ABS GetSpace failed"));
+                                return;
+                        }
+                        ulSpace &= (~(_configinfo.ulSampleSize - 1));
+                        if (ulSpace ==0) rprintf(("WS::ABS still no space"));
+                }
+#endif
                 ulDAZ = 0;
-        while (ulSpace && qhInProcess.IsElements())
-        {
+                while (ulSpace && qhInProcess.IsElements())
+                {
                         if (ulDAZ++ > 20) {
-                                dgprintf(("WAVESTREAM::AddBuffers DAZ break")); // Temporary hack to prevent lockups when uniaud32 stops (underrun)
+                                rprintf(("WS::ABS DAZ break")); // Temporary hack to prevent lockups when uniaud32 stops (underrun)
+                                int3(); /* should never happen */
                                 break;
                         }
-                // First time is in task time. For I7 need to give time for interrupt time
-                if (fFirst == TRUE)  //PS+++
-            {
-                                //cli();
-                    DevHelp_ProcBlock (0x5541, 20, 0); // ok since the first call is at task time
-                ulBytesWritten = AddBuffer(ulSpace);
-                                return;
+                        ulBytesWritten = AddBuffer(ulSpace);
+                        if (ulBytesWritten == (ULONG)-1) {
+                                OSS16_WaveGetStatus(StreamId, &ulStatus);
+                                rprintf(("WS::ABS AddBuffer returns -1 u32Status=%lx", ulStatus));
+                                break;
                         }
-            ulBytesWritten = AddBuffer(ulSpace);
-            if (ulBytesWritten == (ULONG)-1) break;
-            ulSpace -= ulBytesWritten;
-            ulSpace &= ( ~(_configinfo.ulSampleSize - 1));
-        }
-
-    }
-}
-
-//******************************************************************************
-// write one buffer to the audio buffer                                           1
-// the caller of this function MUST make sure it ok to write the audio buffer..
-// _AudioBufWrite will not check if there is room in the audio buffer of if
-// there are buffers on pHead... BEWARE
+                        ulSpace -= ulBytesWritten;
+                        ulSpace &= ( ~(_configinfo.ulSampleSize - 1));
+                }
+//              if (ulSpace) {
+//                      dprintf(("WAVESTREAM::AddBuffers done. ulSpace=%lx", ulSpace));
+//              }
+        }
+        sAddBuffersInProcess--;
+}
+
+//******************************************************************************
+// write one buffer to the audio buffer in uniaud32
 //******************************************************************************
 ULONG WAVESTREAM::AddBuffer(ULONG ulSpace)
 {
-    PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
-    ULONG pDataBuf;
-    ULONG ulBuffLeft;
+        PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
+        ULONG pDataBuf;
+        ULONG ulBuffLeft;
         ULONG ulBytesWritten;
-//DAZ   ULONG ulStartPos;
-
-    /* make sure we have a buffer to copy from */
-    if (!pTemp)
-    {
-        return (ULONG)-1;
-    }
+
+        /* make sure we have a buffer to copy from */
+        if (!pTemp) return (ULONG)-1;
 
         /* make sure there is space in the output buffer */
-    if (!ulSpace)
-    {
-        return (ULONG)-1;
-    }
+        if (!ulSpace) return (ULONG)-1;
 
         /* PS+++ if input buffer is ZERO do nothing and ask for give new buffer, See REMARK in mmpm2.inf */
-    if (!pTemp->ulBuffsz)
-    {
-        qhDone.PushOnTail(qhInProcess.PopHead());
-        return (ULONG)-1;
-    }
-
-/* DAZ */
-#if 0
-    // get the starting position. Call WaveGetHwPtr. if we get a bad rc then we bail out.
-    if(pahw->GetHwPtr(StreamId, &_configinfo, &ulStartPos) == FALSE)
-    {
-        dgprintf(("WAVESTREAM::AddBuffer Err in GetHwPtr"));
-        DebugInt3();
-        return (ULONG)-1;
-    }
-#endif
-
-    // get the buffer pointer and amount of data remaining
-    pDataBuf  = (ULONG)pTemp->pBuffptr + pTemp->ulBuffpos; /* points to the beginning of data in src buffer */
-    ulBuffLeft = pTemp->ulBuffsz - pTemp->ulBuffpos; /* amount of src data left to transfer */
-    //dgprintf(("WS::AddBuffer buf=%lx remain=%lx, space=%lx bp=%lx dp=%lx size=%lx", pTemp->pBuffptr, ulBuffLeft, ulSpace, pTemp->ulBuffpos, pTemp->ulDonepos, pTemp->ulBuffsz));
-    ulBuffLeft = min(ulBuffLeft, ulSpace); /* the smaller of src data left or dst space available */
-
-    if (pahw->Transfer(StreamId, &_configinfo, pDataBuf, ulBuffLeft, &ulBytesWritten) == FALSE)
-    {
+        if (!pTemp->ulBuffsz) {
+                qhDone.PushOnTail(qhInProcess.PopHead());
+                return 0;
+        }
+        if (pTemp->ulBuffsz < (_configinfo.ulBytesPerIRQ*2)) {
+                rprintf(("WS::AB: BufferMode=1"));
+                usBufferMode = 1;
+        }
+
+        // get the buffer pointer and amount of data remaining
+        pDataBuf  = (ULONG)pTemp->pBuffptr + pTemp->ulBuffpos; /* points to the beginning of data in src buffer */
+        ulBuffLeft = pTemp->ulBuffsz - pTemp->ulBuffpos; /* amount of src data left to transfer */
+        //dprintf(("WS::AddBuffer buf=%lx remain=%lx, space=%lx bp=%lx dp=%lx size=%lx", pTemp->pBuffptr, ulBuffLeft, ulSpace, pTemp->ulBuffpos, pTemp->ulDonepos, pTemp->ulBuffsz));
+        ulBuffLeft = min(ulBuffLeft, ulSpace); /* the smaller of src data left or dst space available */
+
+        if (!ulBuffLeft) {
+                qhDone.PushOnTail(qhInProcess.PopHead());
+                return 0;
+        }
+
+        if (pahw->Transfer(StreamId, &_configinfo, pDataBuf, ulBuffLeft, &ulBytesWritten) == FALSE) {
                 // This could mean that the hardware has underrun TODO: implement underrun logic
-        dgprintf(("WS::AddBuffer: pahw->Transfer failed"));
-        return (ULONG)-1;
-    }
-    if (ulBytesWritten == 0)
-    {
+                rprintf(("WS::AB: pahw->Transfer failed"));
+                return (ULONG)-1;
+        }
+        //dprintf(("WS::AB: %lx of %lx bytes written", ulBytesWritten, ulBuffLeft));
+        if (ulBytesWritten == 0) {
                 // This could mean that the hardware has underrun TODO: implement underrun logic
-        dgprintf(("WS::AddBuffer: 0 of %lx bytes written by transfer", ulBuffLeft));
-                return (ULONG)-1; /* DAZ check into returning zero, returning 0 may cause lockup */
-    }
-        //dgprintf(("WS::AddBuffer added %lx from %lx BuffPos=%lx sz=%lx bw=%lx dp=%lx", ulBytesWritten, pTemp->pBuffptr, pTemp->ulBuffpos, pTemp->ulBuffsz, _ulBytesWritten, pTemp->ulDonepos));
+                //rprintf(("WS::AddBuffer: 0 of %lx bytes written by transfer", ulBuffLeft));
+                return (ULONG)-1;
+        }
+        //dprintf(("WS::AddBuffer added %lx from %lx BuffPos=%lx sz=%lx bw=%lx dp=%lx", ulBytesWritten, pTemp->pBuffptr, pTemp->ulBuffpos, pTemp->ulBuffsz, _ulBytesWritten, pTemp->ulDonepos));
 
         _ulBytesWritten += ulBytesWritten; /* update the running counter */
-    pTemp->ulBuffpos += ulBytesWritten; /* update the buffer pos counter */
-    pTemp->ulDonepos = _ulBytesWritten; /* update the done Position for returning the buffer */
-
-    // check to see if the whole buffer has been copied and needs to be put on the done queue
-    if (pTemp->ulBuffpos >= (pTemp->ulBuffsz /* & 0xFFFFFFFC*/)) /* DAZ */
-    {
-                //dgprintf(("WS::AddBuffer done with buffer %lx dp=%lx", pTemp->pBuffptr, pTemp->ulDonepos));
-        qhDone.PushOnTail(qhInProcess.PopHead());
-    }
-    return ulBytesWritten;
+        pTemp->ulBuffpos += ulBytesWritten; /* update the buffer pos counter */
+        pTemp->ulDonepos = _ulBytesWritten; /* update the done Position for returning the buffer */
+
+        // check to see if the whole buffer has been copied and needs to be put on the done queue
+        if (pTemp->ulBuffpos >= (pTemp->ulBuffsz /* & 0xFFFFFFFC*/)) /* DAZ */
+        {
+                //dprintf(("WS::AddBuffer done with buffer %lx dp=%lx", pTemp->pBuffptr, pTemp->ulDonepos));
+                qhDone.PushOnTail(qhInProcess.PopHead());
+        }
+        return ulBytesWritten;
 }
 //******************************************************************************
@@ -279 +332 @@
 BOOL WAVESTREAM::_vReadAudioBuf(void)
 {
-    PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
-    ULONG pDataBuf;
-    ULONG ulBuffLeft, ulBytesRead;
-
-    if(!pTemp) return FALSE;
-
-    // get the buffer pointer and amount of data remaining
-    pDataBuf  = (ULONG)pTemp->pBuffptr + pTemp->ulBuffpos;
-    ulBuffLeft = pTemp->ulBuffsz - pTemp->ulBuffpos;
-
-    // read wave data
-    if(pahw->Transfer(StreamId, &_configinfo, pDataBuf, ulBuffLeft, &ulBytesRead) == FALSE)
-    {
-       return FALSE; /* No more data */
-    }
-    if(ulBytesRead == 0) {
-       return FALSE; /* No more data */
-    }
+        PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
+        ULONG pDataBuf;
+        ULONG ulBuffLeft, ulBytesRead;
+
+        if(!pTemp) return FALSE;
+
+        // get the buffer pointer and amount of data remaining
+        pDataBuf  = (ULONG)pTemp->pBuffptr + pTemp->ulBuffpos;
+        ulBuffLeft = pTemp->ulBuffsz - pTemp->ulBuffpos;
+
+        // read wave data
+        if(pahw->Transfer(StreamId, &_configinfo, pDataBuf, ulBuffLeft, &ulBytesRead) == FALSE)
+        {
+           return FALSE; /* No more data */
+        }
+        if(ulBytesRead == 0) {
+           return FALSE; /* No more data */
+        }
         if (ulBytesRead > ulBuffLeft) {
-       return FALSE; /* Internal error */
-        }
-
-    // update the buffer pos counter
-    pTemp->ulBuffpos  += ulBytesRead;
-    _ulBytesProcessed += ulBytesRead;
+           return FALSE; /* Internal error */
+        }
+
+        // update the buffer pos counter
+        pTemp->ulBuffpos  += ulBytesRead;
+        _ulBytesProcessed += ulBytesRead;
 
         //dprintf(("_vReadAudioBuf %lx Requested=%lx Read=%lx Remain=%lx Processed=%lx", pDataBuf, ulBuffLeft, ulBytesRead, pTemp->ulBuffsz-pTemp->ulBuffpos, _ulBytesProcessed));
 
-    if(pTemp->ulBuffpos == pTemp->ulBuffsz) {
-        qhDone.PushOnTail(qhInProcess.PopHead());
-            ReturnBuffer();
-    }
-
-    return TRUE;
+        if(pTemp->ulBuffpos == pTemp->ulBuffsz) {
+                qhDone.PushOnTail(qhInProcess.PopHead());
+                ReturnBuffer();
+        }
+
+        return TRUE;
 }
 //******************************************************************************
@@ -327 +380 @@
         ULONG ulDAZ;
 
-        //ddprintf(("WAVESTREAM::Process Start"));
-
-    // get the stream position. if we get a bad rc or the position is 0
-    // then we bail out. Hopefully this will be better next time.
-    // GetPostiion returns the adjusted hw pointer from the ALSA status ioctl
-    // This is really a running total of bytes consumed by the hardware.
+        //dprintf(("WAVESTREAM::Process Start"));
+
+        // get the stream position. if we get a bad rc or the position is 0
+        // then we bail out. Hopefully this will be better next time.
+        // GetPostiion returns the adjusted hw pointer from the ALSA status ioctl
+        // This is really a running total of bytes consumed by the hardware.
         // DAZ - Note that this is a 32 bit counter and will wrap at sometime. ALSA
         // attempts to wrap this counter intelligently. I haven't determined what
         // effect, if any, the wrapping of this counter will have playing a stream.
-    if(pahw->GetPosition(StreamId, &_configinfo, &ulBytes) == FALSE)
-    {
-        ddprintf(("Error No bytes processed"));
-        DebugInt3();
-        return;
-    }
-    _ulBytesProcessed = ulBytes;
-
-    switch (ulStreamType & STREAM_WRITE)
-    {
-        case STREAM_WRITE:
-            if (qhInProcess.IsElements())
-            {
-                                AddBuffers(FALSE);
-            }
-                // Return any buffers that have been completely written to uniaud32
+        if(pahw->GetPosition(StreamId, &_configinfo, &ulBytes) == FALSE)
+        {
+                //dprintf(("Error No bytes processed"));
+                DebugInt3();
+                return;
+        }
+        _ulBytesProcessed = ulBytes;
+
+        switch (ulStreamType & STREAM_WRITE)
+        {
+                case STREAM_WRITE:
+                        if(!qhInProcess.IsElements() && !qhDone.IsElements()) {
+                                _vUnderrunStop("WS:Process");
+                                break;
+                        }
+                        if (qhInProcess.IsElements()) AddBuffers(1);
+                        // Return any buffers that have been completely written to uniaud32
+                        //dprintf(("WS::Process usBufferMode=%x", usBufferMode));
                         while (qhDone.IsElements()) {
-                pTemp = (PSTREAMBUFFER)qhDone.Head(); /* get a pointer to the first completed buffer */
+                                pTemp = (PSTREAMBUFFER)qhDone.Head(); /* get a pointer to the first completed buffer */
                                 // Hang on to the last buffer until the hardware is done writing the data
                                 // We do this because MMPM uses the return of the last buffer to determine when we are
                                 // done playing the stream
-                                if ((qhDone.Head() == qhDone.Tail()) && !qhInProcess.IsElements() && (_ulBytesProcessed < pTemp->ulDonepos)) break; /* only one buffer left */
+                                if ((qhDone.Head() == qhDone.Tail()) && !qhInProcess.IsElements()) {  /* only one buffer left */
+                                        if (_ulBytesProcessed < pTemp->ulDonepos) break;
+                                } else { /* not the last buffer */
+                                        /* if the buffer is bigger than BytesPerIRQ and it's not finished yet, hang on to it */
+                                        if (!usBufferMode && (_ulBytesProcessed < pTemp->ulDonepos)) break;
+                                        //if ((_ulBytesProcessed + _configinfo.ulBytesPerIRQ) < pTemp->ulDonepos) break;
+                                }
                                 ReturnBuffer();
                         }
-                break;
-        case STREAM_READ:
+                        break;
+                case STREAM_READ:
                         ulDAZ = 0;
-                    while(_vReadAudioBuf()) {
+                        while(_vReadAudioBuf()) {
                                 if (ulDAZ++ > 20) { /* temporary hack to prevent hangs when uniaud32 stops (overruns) */
-                                ddprintf(("WAVESTREAM::Process Read DAZ Break"));
+                                        rprintf(("WS::Process Read DAZ Break"));
                                         break;
                                 }
                         }
-                    break;
-        default:
-            break;
-    } /* endswitch */
-
-    ProcessEvents();
-    //ddprintf(("WAVESTREAM::Process End"));
+                        break;
+                default:
+                        break;
+        } /* endswitch */
+
+        ProcessEvents();
+        //dprintf(("WAVESTREAM::Process End"));
 }
 //******************************************************************************
@@ -383 +444 @@
 #pragma on (unreferenced)
 {
-    PSTREAMBUFFER pStreamBuf = new STREAMBUFFER(uLength, pbuf);
-
-    return Write(pStreamBuf);
+        PSTREAMBUFFER pStreamBuf = new STREAMBUFFER(uLength, pbuf);
+
+        return Write(pStreamBuf);
 }
 //******************************************************************************
@@ -391 +452 @@
 ULONG WAVESTREAM::Write(PSTREAMBUFFER pStreamBuf)
 {
-    qhInProcess.PushOnTail((PQUEUEELEMENT)pStreamBuf);
-    //    dprintf2(("WAVESTREAM::Write: Push on tail %lx %ld", ((PSTREAMBUFFER)qhInProcess.Tail())->pBuffptr, ((PSTREAMBUFFER)qhInProcess.Tail())->ulBuffsz));
-    return 0;
+
+#if 1
+        ULONG ulStatus;
+
+        ulStatus = 0;
+        if (OSS16_WaveGetStatus(StreamId, &ulStatus) != OSSERR_SUCCESS) ulStatus = SNDRV_PCM_STATE_XRUN;
+        //dprintf(("WS::Write: status=%lx", ulStatus));
+        if (ulStatus == SNDRV_PCM_STATE_XRUN) {
+                rprintf(("WS::Write: Xrun detect"));
+                _vUnderrunStop("WS:Write");
+                fUnderrun = TRUE;
+        }
+#endif
+        qhInProcess.PushOnTail((PQUEUEELEMENT)pStreamBuf);
+        if (fUnderrun) {
+                _vUnderrunStart();
+                AddBuffers(2);
+        }
+        return 0;
 }
 //******************************************************************************
@@ -399 +476 @@
 ULONG WAVESTREAM::Read(PSTREAMBUF pbuf, unsigned uLength)
 {
-    qhInProcess.PushOnTail((PQUEUEELEMENT)new STREAMBUFFER(uLength, pbuf));
-    //dprintf2(("WAVESTREAM::Read: Push on tail %lx %lx", pbuf, uLength));
-    return 0;
+        qhInProcess.PushOnTail((PQUEUEELEMENT)new STREAMBUFFER(uLength, pbuf));
+        //dprintf2(("WAVESTREAM::Read: Push on tail %lx %lx", pbuf, uLength));
+        return 0;
 }
 //******************************************************************************
@@ -419 +496 @@
 ULONG WAVESTREAM::GetCurrentTime()
 {
-    ULONG Seconds, MilliSeconds, Overflow, Processed;
-
-        //PS++ optimize code
-    Processed = _ulBytesProcessed;
-    if (ulStreamState == STREAM_STREAMING)  // if the stream is active
-    {
-       if (ulStreamType & STREAM_WRITE)
-       {
-           if (pahw->GetPosition(StreamId, &_configinfo, &Processed) == FALSE)
-           {
-                                //DebugInt3();
-                Processed = _ulBytesProcessed; //last known position
-           }
-        }
-    }
-
-    // if we haven't processed anything then just return _ulTimeBase
-    if(Processed == 0)
-        return(_ulTimeBase);
-
-    Seconds  = Processed / _configinfo.ulPCMConsumeRate;
-    Overflow = Processed - (Seconds * _configinfo.ulPCMConsumeRate);
-    MilliSeconds = (Overflow * 1000) / _configinfo.ulPCMConsumeRate;
-    MilliSeconds += (Seconds * 1000);
-    return (MilliSeconds + _ulTimeBase);
-}
-//******************************************************************************
-//******************************************************************************
-ULONG WAVESTREAM::GetCurrentPos(void)
-{
-        ULONG Processed;
+        ULONG Seconds, MilliSeconds, Overflow, Processed;
 
         //PS++ optimize code
         Processed = _ulBytesProcessed;
-        if (ulStreamState == STREAM_STREAMING)  // if the stream is active
+        if (ulStreamState == STREAM_STREAMING)  // if the stream is active
+        {
+           if (ulStreamType & STREAM_WRITE)
+           {
+                   if (pahw->GetPosition(StreamId, &_configinfo, &Processed) == FALSE)
+                   {
+                                //DebugInt3();
+                                Processed = _ulBytesProcessed; //last known position
+                   }
+                }
+        }
+
+        // if we haven't processed anything then just return _ulTimeBase
+        if(Processed == 0)
+                return(_ulTimeBase);
+
+        Seconds  = Processed / _configinfo.ulPCMConsumeRate;
+        Overflow = Processed - (Seconds * _configinfo.ulPCMConsumeRate);
+        MilliSeconds = (Overflow * 1000) / _configinfo.ulPCMConsumeRate;
+        MilliSeconds += (Seconds * 1000);
+        return (MilliSeconds + _ulTimeBase);
+}
+//******************************************************************************
+//******************************************************************************
+ULONG WAVESTREAM::GetCurrentPos(void)
+{
+        ULONG Processed;
+
+        //PS++ optimize code
+        Processed = _ulBytesProcessed;
+        if (ulStreamState == STREAM_STREAMING)  // if the stream is active
         {
                 if (ulStreamType & STREAM_WRITE)
@@ -478 +555 @@
    if(!pTemp)
    {
-       pTemp = (PSTREAMBUFFER)qhInProcess.Head();
+           pTemp = (PSTREAMBUFFER)qhInProcess.Head();
    }
    if(pTemp)
    {
-       writepos = pTemp->ulBuffpos;
+           writepos = pTemp->ulBuffpos;
    }
    sti();
@@ -495 +572 @@
 void  WAVESTREAM::SetCurrentTime(ULONG time)
 {
-        //ddprintf(("SetCurrentTime: %lx", time));
-    _ulTimeBase = time;
+        //dprintf(("SetCurrentTime: %lx", time));
+        _ulTimeBase = time;
 }
 //******************************************************************************
@@ -502 +579 @@
 ULONG WAVESTREAM::StartStream()
 {
-    PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
-
-    if(ulStreamState == STREAM_STREAMING)
-    {
-        ddprintf(("StartStream: already playing!!"));
-        return NO_ERROR;
-    }
-
-    // configure the wave device
-    // (NOTE: Must call this function; sample rate position is reset there)
-    if(pahw->ConfigDev(StreamId, &_configinfo, (pTemp) ? pTemp->ulBuffsz : 0) == FALSE)
-    {
-        ddprintf(("StartStream: ConfigDev failed!!"));
-        return ERROR_INSUFF_BUFFER;
+        PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
+
+        if(ulStreamState == STREAM_STREAMING)
+        {
+                //dprintf(("StartStream: already playing!!"));
+                return NO_ERROR;
+        }
+
+        // configure the wave device
+        // (NOTE: Must call this function; sample rate position is reset there)
+        if(pahw->ConfigDev(StreamId, &_configinfo, (pTemp) ? pTemp->ulBuffsz : 0) == FALSE)
+        {
+                rprintf(("StartStream: ConfigDev failed!!"));
+                return ERROR_INSUFF_BUFFER;
                 //goto fail;
-    }
-    // prepare wave device for playback/recording
-    if(pahw->Prepare(StreamId) == FALSE)
-    {
-        ddprintf(("StartStream: Prepare failed!!"));
-        goto fail;
-    }
-
-    _ulBytesProcessed = 0;
+        }
+        // prepare wave device for playback/recording
+        if(pahw->Prepare(StreamId) == FALSE)
+        {
+                rprintf(("StartStream: Prepare failed!!"));
+                goto fail;
+        }
+
+        _ulBytesProcessed = 0;
         _ulBytesWritten = 0;
-
-    ulStreamState = STREAM_STREAMING;
-    //Adding the first buffer also starts playback
-    if (ulStreamType == STREAM_WAVE_PLAY)
-    {
-                pahw->SetVolume(StreamId, getMixerStreamId(), volume);    //PS
-                AddBuffers(TRUE);
-        //Must set volume after adding buffers (voices inside sblive driver might not
-        //be allocated otherwise (first start) )
-//        dprintf(("SetVolume %lx",volume));
-// PS, removing to high
-//      pahw->SetVolume(StreamId, getMixerStreamId(), volume);
-    }
-    else
-    {
-        //dprintf(("Starting Rec Stream"));
-        ulSavedInputGain = pahw->QueryVolume(StreamId, getMixerStreamId());
-        pahw->SetInputSrc(StreamId, getMixerStreamId(), inputsrc);
-        pahw->SetVolume(StreamId, getMixerStreamId(), inputgain);
+        fUnderrun = FALSE;
+        usBufferMode = 0;
+
+        ulStreamState = STREAM_STREAMING;
+        //Adding the first buffer also starts playback
+        if (ulStreamType == STREAM_WAVE_PLAY)
+        {
+                //DAZ moved from AddBuffers, for I7, might not be needed
+                //DevHelp_ProcBlock (0x5541, 20, 0);
+                pahw->SetVolume(StreamId, getMixerStreamId(), volume);    //PS
+                AddBuffers(3);
+        }
+        else
+        {
+                //dprintf(("Starting Rec Stream"));
+                ulSavedInputGain = pahw->QueryVolume(StreamId, getMixerStreamId());
+                pahw->SetInputSrc(StreamId, getMixerStreamId(), inputsrc);
+                pahw->SetVolume(StreamId, getMixerStreamId(), inputgain);
 
                 if(pahw->Start(StreamId) != TRUE)
                 {
-            dprintf(("pahw->Start failed!!"));
-            goto fail;
-        }
-    }
-    return NO_ERROR;
+                        rprintf(("pahw->Start failed!!"));
+                        goto fail;
+                }
+        }
+        return NO_ERROR;
 
 fail:
-    DebugInt3();
-    return ERROR_START_STREAM;
+        DebugInt3();
+        return ERROR_START_STREAM;
 }
 //******************************************************************************
@@ -563 +639 @@
 ULONG WAVESTREAM::StopStream(PCONTROL_PARM pControl)
 {
-    if(ulStreamState == STREAM_STOPPED) {
-        dprintf(("WAVESTREAM::StopStream %lx (already stopped)", StreamId));
-            pControl->ulTime = GetCurrentTime();
-            return NO_ERROR;
-    }
-    //silence wave stream before stopping it (removes clicks)
-    if(ulStreamType == STREAM_WAVE_PLAY) {
-        pahw->SetVolume(StreamId, getMixerStreamId(), 0);
-    }
-    else {
-        pahw->SetVolume(StreamId, getMixerStreamId(), ulSavedInputGain);
-    }
-    pahw->Stop(StreamId);
-
-    ulStreamState = STREAM_STOPPED;
-        //ddprintf(("WAVESTREAM::StopStream %lx", StreamId));
-
-    ReturnBuffers();
-    pControl->ulTime = GetCurrentTime();
-
-    // We need to set _ulBytesProcessed to 0 here. if we do not
-    // and MMPM restarts the stream by sending a DDCMD_SETUP followed By
-    // DDCMD_ENABLE_EVENT the event time will get screwed up. rjj
-    _ulBytesProcessed = 0;
+        if(ulStreamState == STREAM_STOPPED) {
+                //dprintf(("WS::StopStream %lx (already stopped)", StreamId));
+                fUnderrun = FALSE;
+                pControl->ulTime = GetCurrentTime();
+                return NO_ERROR;
+        }
+        //silence wave stream before stopping it (removes clicks)
+        if(ulStreamType == STREAM_WAVE_PLAY) {
+                pahw->SetVolume(StreamId, getMixerStreamId(), 0);
+        }
+        else {
+                pahw->SetVolume(StreamId, getMixerStreamId(), ulSavedInputGain);
+        }
+        pahw->Stop(StreamId);
+
+        ulStreamState = STREAM_STOPPED;
+        fUnderrun = FALSE;
+        //dprintf(("WAVESTREAM::StopStream %lx", StreamId));
+
+        ReturnBuffers();
+        pControl->ulTime = GetCurrentTime();
+
+        // We need to set _ulBytesProcessed to 0 here. if we do not
+        // and MMPM restarts the stream by sending a DDCMD_SETUP followed By
+        // DDCMD_ENABLE_EVENT the event time will get screwed up. rjj
+        _ulBytesProcessed = 0;
         _ulBytesWritten = 0;
-    return NO_ERROR;
+        return NO_ERROR;
 }
 //******************************************************************************
@@ -594 +672 @@
 ULONG  WAVESTREAM::PauseStream(PCONTROL_PARM pControl)
 {
-    ULONG ulEndPos, ulEndPos2;
-
-    if(ulStreamState == STREAM_PAUSED) {
-        dprintf(("WAVESTREAM::PauseStream %lx (already paused)", StreamId));
-            pControl->ulTime = GetCurrentTime();
-            return NO_ERROR;
-    }
-
-    pahw->GetPosition(StreamId, &_configinfo, &ulEndPos);
-    //silence wave stream before stopping it (removes clicks)
-    pahw->SetVolume(StreamId, getMixerStreamId(), 0);
-    pahw->Stop(StreamId);
-
+        ULONG ulEndPos;
+
+        if(ulStreamState == STREAM_PAUSED) {
+                dprintf(("WS::PauseStream %lx (already paused)", StreamId));
+                fUnderrun = FALSE;
+                pControl->ulTime = GetCurrentTime();
+                return NO_ERROR;
+        }
+
+        pahw->GetPosition(StreamId, &_configinfo, &ulEndPos);
+        //silence wave stream before stopping it (removes clicks)
+        pahw->SetVolume(StreamId, getMixerStreamId(), 0);
+        pahw->Stop(StreamId);
+
+#if 0
         /* DAZ test code begin */
-    if (pahw->GetPosition(StreamId, &_configinfo, &ulEndPos2) == FALSE) ulEndPos2 = 0;
+        if (pahw->GetPosition(StreamId, &_configinfo, &ulEndPos2) == FALSE) ulEndPos2 = 0;
         if (ulEndPos2 != ulEndPos) {
-            ddprintf(("WAVESTREAM::PauseStream %lx!=%lx", ulEndPos, ulEndPos2));
+                dprintf(("WS::PauseStream %lx!=%lx", ulEndPos, ulEndPos2));
                 if (ulEndPos2) ulEndPos = ulEndPos2;
         }
         /* DAZ test code end */
-
-    ulStreamState = STREAM_PAUSED;
-
-    ddprintf(("WAVESTREAM::PauseStream %lx", StreamId));
-
-    _ulBytesProcessed = ulEndPos;
-
-    _vRealignPausedBuffers(ulEndPos);
-
-    pControl->ulTime = GetCurrentTime();
-
-    _ulBytesProcessed = 0;
+#endif
+
+        ulStreamState = STREAM_PAUSED;
+
+        dprintf(("WS::PauseStream %lx", StreamId));
+
+        _ulBytesProcessed = ulEndPos;
+
+        _vRealignPausedBuffers(ulEndPos);
+
+        pControl->ulTime = GetCurrentTime();
+
+        _ulBytesProcessed = 0;
         _ulBytesWritten = 0;
-
-    return NO_ERROR;
+        fUnderrun = FALSE;
+
+        return NO_ERROR;
 }
 //******************************************************************************
@@ -634 +716 @@
 ULONG  WAVESTREAM::ResumeStream(void)
 {
-#ifdef DEBUG
-    //dprintf(("WAVESTREAM::ResumeStream %lx", StreamId));
-#endif
-    return StartStream();
+        //dprintf(("WAVESTREAM::ResumeStream %lx", StreamId));
+        return StartStream();
 }
 //******************************************************************************
@@ -643 +723 @@
 BOOL WAVESTREAM::SetProperty(int type, ULONG value, ULONG reserved)
 {
-    switch(type) {
-    case PROPERTY_VOLUME:
-        volume = value;
-        dprintf(("WAVESTREAM::SetProperty() Vol: %0lx",value));
-        if(ulStreamState == STREAM_STREAMING && ulStreamType == STREAM_WAVE_PLAY) {
-            MixerSetWaveVolume(getMixerStreamId(), StreamId, volume);
-        }
-        break;
-
-    case PROPERTY_INPUTSRC:
-        inputsrc = value;
-        break;
-
-    case PROPERTY_INPUTGAIN:
-        inputgain = value;
-        break;
-
-    default:
-        return STREAM::SetProperty(type, value, reserved);
-    }
-    return TRUE;
+        switch(type) {
+        case PROPERTY_VOLUME:
+                volume = value;
+                dprintf(("WS::SetProperty() Vol: %0lx",value));
+                if(ulStreamState == STREAM_STREAMING && ulStreamType == STREAM_WAVE_PLAY) {
+                        MixerSetWaveVolume(getMixerStreamId(), StreamId, volume);
+                }
+                break;
+
+        case PROPERTY_INPUTSRC:
+                inputsrc = value;
+                break;
+
+        case PROPERTY_INPUTGAIN:
+                inputgain = value;
+                break;
+
+        default:
+                return STREAM::SetProperty(type, value, reserved);
+        }
+        return TRUE;
 }
 //******************************************************************************
@@ -669 +749 @@
 ULONG WAVESTREAM::GetProperty(int type)
 {
-    switch(type) {
-    case PROPERTY_FREQUENCY:
-       return _configinfo.ulSampleRate;
-
-    case PROPERTY_INPUTSRC:
-       return inputsrc;
-
-    case PROPERTY_INPUTGAIN:
-       return inputgain;
-
-    default:
-       return STREAM::GetProperty(type);
-    }
+        switch(type) {
+        case PROPERTY_FREQUENCY:
+           return _configinfo.ulSampleRate;
+
+        case PROPERTY_INPUTSRC:
+           return inputsrc;
+
+        case PROPERTY_INPUTGAIN:
+           return inputgain;
+
+        default:
+           return STREAM::GetProperty(type);
+        }
 }
 //******************************************************************************
@@ -688 +768 @@
    STREAM(streamtype, filesysnum, mixerStreamId)
 {
-    // get the pointer to the hardware object
-    pahw = (WAVEAUDIO*)GetHardwareDevice(streamtype);
-
-    _fmemset(&_configinfo, 0, sizeof(_configinfo));
-    _configinfo.ulSampleRate    = pinit->lSRate;
-    _configinfo.ulBitsPerSample = pinit->lBitsPerSRate;
-    _configinfo.ulNumChannels   = pinit->sChannels;
-    _configinfo.ulDataType      = pinit->sMode;
-    _ulBytesWritten             = 0;
-    _ulBytesProcessed           = 0;
-    _ulTimeBase                 = 0;
-    ulSavedInputGain            = 0;
-
-    _configinfo.pConversionBuffer  = 0;
-    pahw->SetupConversion(&_configinfo, pinit->ulOperation, pinit->sMode, pinit->sChannels, pinit->lBitsPerSRate);
-
-    if(_configinfo.usConversion != CONVERT_NONE)
-    {//allocate conversion buffer
-        PVOID pSelOff;
-        LIN   linAddr;
-
-        if(DevHelp_VMAlloc((VMDHA_FIXED | VMDHA_CONTIG), CONVERSION_BUFFER_SIZE, (ULONG)-1L, &linAddr, &pSelOff) != 0)
-        {
-             dgprintf(("Error in DevHelp_VMAlloc Conversion Buffer"));
-             DebugInt3(); //should never happen!!
-             _configinfo.usConversion = CONVERT_NONE;
-        }
-        else _configinfo.pConversionBuffer = linAddr;
-    }
-    if(_configinfo.fSampleRateConversion == TRUE)
-    {//allocate buffer for sample rate conversion
-        PVOID pSelOff;
-        LIN   linAddr;
-
-        if (DevHelp_VMAlloc((VMDHA_FIXED | VMDHA_CONTIG), CONVERSION_BUFFER_SIZE, (ULONG)-1L, &linAddr, &pSelOff) != 0)
-        {
-            dgprintf(("Error in DevHelp_VMAlloc SR Conversion Buffer"));
-            DebugInt3(); //should never happen!!
-        }
-        else _configinfo.pSRateConvBuffer = linAddr;
-    }
-
-    pinit->ulFlags |= pahw->QueryDataFlags(pinit->ulOperation, pinit->sMode, pinit->lBitsPerSRate);
-
-    StreamId    = 0;
-
-    if(pahw->Open(current_device, ulStreamType, ulSysFileNum, &StreamId) != TRUE)
-    {
-        dprintf(("pahw->Open failed!!"));
-        DebugInt3();
-    }
+        // get the pointer to the hardware object
+        pahw = (WAVEAUDIO*)GetHardwareDevice(streamtype);
+
+        _fmemset(&_configinfo, 0, sizeof(_configinfo));
+        _configinfo.ulSampleRate        = pinit->lSRate;
+        _configinfo.ulBitsPerSample = pinit->lBitsPerSRate;
+        _configinfo.ulNumChannels       = pinit->sChannels;
+        _configinfo.ulDataType          = pinit->sMode;
+        _ulBytesWritten                         = 0;
+        _ulBytesProcessed                       = 0;
+        _ulTimeBase                             = 0;
+        ulSavedInputGain                        = 0;
+        fUnderrun = FALSE;
+        usBufferMode = 0;
+
+        _configinfo.pConversionBuffer  = 0;
+        pahw->SetupConversion(&_configinfo, pinit->ulOperation, pinit->sMode, pinit->sChannels, pinit->lBitsPerSRate);
+
+        if(_configinfo.usConversion != CONVERT_NONE)
+        {//allocate conversion buffer
+                PVOID pSelOff;
+                LIN   linAddr;
+
+                if(DevHelp_VMAlloc((VMDHA_FIXED | VMDHA_CONTIG), CONVERSION_BUFFER_SIZE, (ULONG)-1L, &linAddr, &pSelOff) != 0)
+                {
+                         rprintf(("Error in DevHelp_VMAlloc Conversion Buffer"));
+                         DebugInt3(); //should never happen!!
+                         _configinfo.usConversion = CONVERT_NONE;
+                }
+                else _configinfo.pConversionBuffer = linAddr;
+        }
+        if(_configinfo.fSampleRateConversion == TRUE)
+        {//allocate buffer for sample rate conversion
+                PVOID pSelOff;
+                LIN   linAddr;
+
+                if (DevHelp_VMAlloc((VMDHA_FIXED | VMDHA_CONTIG), CONVERSION_BUFFER_SIZE, (ULONG)-1L, &linAddr, &pSelOff) != 0)
+                {
+                        rprintf(("Error in DevHelp_VMAlloc SR Conversion Buffer"));
+                        DebugInt3(); //should never happen!!
+                }
+                else _configinfo.pSRateConvBuffer = linAddr;
+        }
+
+        pinit->ulFlags |= pahw->QueryDataFlags(pinit->ulOperation, pinit->sMode, pinit->lBitsPerSRate);
+
+        StreamId        = 0;
+
+        if(pahw->Open(current_device, ulStreamType, ulSysFileNum, &StreamId) != TRUE)
+        {
+                rprintf(("pahw->Open failed!!"));
+                DebugInt3();
+        }
 
         //dprintf(("WAVESTREAM stream %lx ctor %lx: rate %d bps %d numchan %d type %x", hstream, StreamId, (USHORT)_configinfo.ulSampleRate, (USHORT)_configinfo.ulBitsPerSample, (USHORT)_configinfo.ulNumChannels, (USHORT)_configinfo.ulNumChannels, (USHORT)_configinfo.ulDataType));
@@ -747 +829 @@
 {
         //dprintf(("WAVESTREAM stream %x dtor %lx", hstream, StreamId));
-    if(_configinfo.pConversionBuffer) {
-        if(DevHelp_VMFree(_configinfo.pConversionBuffer) != 0) {
-            DebugInt3();
-        }
-    }
-    if(_configinfo.pSRateConvBuffer) {
-        if(DevHelp_VMFree(_configinfo.pSRateConvBuffer) != 0) {
-            DebugInt3();
-        }
-    }
-    if(pahw) {
-        if (ulStreamState == STREAM_STREAMING)
-           pahw->Stop(StreamId);
-
-        pahw->Close(StreamId);
-        StreamId = 0;
-    }
-}
-//******************************************************************************
-//******************************************************************************
-
+        if(_configinfo.pConversionBuffer) {
+                if(DevHelp_VMFree(_configinfo.pConversionBuffer) != 0) {
+                        DebugInt3();
+                }
+        }
+        if(_configinfo.pSRateConvBuffer) {
+                if(DevHelp_VMFree(_configinfo.pSRateConvBuffer) != 0) {
+                        DebugInt3();
+                }
+        }
+        if(pahw) {
+                if (ulStreamState == STREAM_STREAMING)
+                   pahw->Stop(StreamId);
+
+                pahw->Close(StreamId);
+                StreamId = 0;
+        }
+}
+//******************************************************************************
+//******************************************************************************
+

OCO/trunk/drv16/wavestrm.hpp

@@ -58 +58 @@
 protected:
 
-   virtual void    AddBuffers(BOOL fFirst);         // Initialize the audio buffer object
+   virtual void    AddBuffers(SHORT sFirst);                // Initialize the audio buffer object
 
    WaveConfigInfo _configinfo;    // configuration info shared with the hardware
@@ -69 +69 @@
    ULONG   AddBuffer(ULONG space);             // write one buffer to the audio buffer
    BOOL    _vReadAudioBuf(void);    // read data from the audio buffer
+   void    _vUnderrunStop(PCHAR pchStr);
+   ULONG   _vUnderrunStart(void);
 
    ULONG   ulSavedInputGain;
+   BOOL    fUnderrun;
+   USHORT  usBufferMode;
 
    WAVEAUDIO *pahw;            // pointer to the hardware object for this stream

OCO/trunk/drv16/wtsynth.cpp

@@ -42 +42 @@
 {
     if(OSS16_MidiOpen(current_device, WAVETABLE_SEND, pStreamId) != OSSERR_SUCCESS) {
-        dprintf(("WTSYNTH::Open: OSS16_MidiOpen failed!!"));
+        rprintf(("WTSYNTH::Open: OSS16_MidiOpen failed!!"));
         DebugInt3();
         return FALSE;
@@ -53 +53 @@
 {
     if(OSS16_MidiClose(StreamId) != OSSERR_SUCCESS) {
-        dprintf(("WTSYNTH::Close: OSS16_MidiClose failed!!"));
+        rprintf(("WTSYNTH::Close: OSS16_MidiClose failed!!"));
         DebugInt3();
         return FALSE;
@@ -65 +65 @@
 //******************************************************************************
 int WTSYNTH::writeByte(OSSSTREAMID StreamId, BYTE b)
-{ 
-    int dummy = b; 
-    return 0; 
+{
+    int dummy = b;
+    return 0;
 }
 //******************************************************************************
@@ -76 +76 @@
 //******************************************************************************
 int WTSYNTH::readByte(OSSSTREAMID StreamId)
-{ 
+{
     DebugInt3();
-    return -1; 
+    return -1;
 }
 //******************************************************************************
@@ -102 +102 @@
 {
     if(MixerSetVolume(mixerStreamId, OSS32_MIX_VOLUME_MIDI, ulVolume) != TRUE) {
-        dprintf(("WTSYNTH::SetVolume: MixerSetVolume failed!!"));
+        rprintf(("WTSYNTH::SetVolume: MixerSetVolume failed!!"));
         //not necessarily fatal; maybe there is no volume control for midi
     }

OCO/trunk/include/dbgos2.h

@@ -24 +24 @@
 /* dprintf is used to output info into the log for the debug version */
 #ifdef DEBUG
+#define DBGCALLCONV     FAR
+
 #define dprintf(a)  PrintfOut a
 #define dprintf1(a) if(dbglevel >= 1) PrintfOut a
@@ -29 +31 @@
 #define dprintf3(a) if(dbglevel >= 3) PrintfOut a
 #define dprintf4(a) if(dbglevel >= 4) PrintfOut a
+
+#define DebugInt3() //_asm int 3 DAZ temporarily taken out of debug build to prevent traps
+
 #else
+// notdef DEBUG
+#define DBGCALLCONV     NEAR
+
 #define dprintf(a)  //
 #define dprintf1(a) //
@@ -35 +43 @@
 #define dprintf3(a) //
 #define dprintf4(a) //
-#endif
 
-#ifdef DEBUG
-#define DebugInt3() //_asm int 3 DAZ temporarily taken out of debug build to prevent traps
-#else
 #define DebugInt3() //_asm int 3
-#endif
 
-#ifdef DEBUG
-#define DBGCALLCONV     FAR
-#else
-#define DBGCALLCONV     NEAR
 #endif
 

OCO/trunk/install/control.scr

@@ -25 +25 @@
 ssgroup=0
 ssname="mmbase"
-ssversion="1.9.1-SVNr486"
+ssversion="1.9.3-SVNr526"
 sstermdll="ITERM.DLL"
 sstermdllentry="ITermEntry"
@@ -43 +43 @@
 ssgroup=17
 ssname="OS/2 Universal Audio: Wave"
-ssversion="1.9.1-SVNr486"
+ssversion="1.9.3-SVNr526"
 sssize=680
 ssdll="genin.dll"

OCO/trunk/uniaud.inc

@@ -6 +6 @@
 # Full UNIAUD build version
 # BUILDVERSION must be 3 parts, and only numbers like 5.44.108
-# It is best that 2'nd number is always 2 digits, eg at least 10
-BUILDVERSION = 1.9.1
+# It is best that 2nd number is always 2 digits, eg at least 10
+BUILDVERSION = 1.9.3
 
 # Fixpack version
@@ -13 +13 @@
 # ex RC3  GA  FIXPACK2 beta_47
 # Comment out to avoid a fixpack line in bldlevel
-FIXPACK = SVNr486
+FIXPACK = SVNr526
 
 # ALSA BUILD VERSION