Changeset 396 for OCO/trunk/drv16/wavestrm.cpp

Timestamp:

Oct 17, 2008, 5:37:44 PM (17 years ago)

Author:

rjerant

Message:

Update buffer handeling routines. This should allow merging back to a single Uniaud32

File:

• OCO/trunk/drv16/wavestrm.cpp (modified) (23 diffs)

OCO/trunk/drv16/wavestrm.cpp

@@ -1 @@
-
 /* SCCSID = %W% %E% */
 /****************************************************************************
@@ -51 +50 @@
 // the data has been played and 1 if there is still some data left.
 //******************************************************************************
-USHORT WAVESTREAM::_vRealignBuffer(ULONG FAR *bytesinc, PSTREAMBUFFER pbuffer)
-{
-    // if none of the data in this stream buffer has been consumed
-    if (!*bytesinc) {
-        pbuffer->ulDonepos = 0;
-        pbuffer->ulBuffpos = 0;
-        return 1;
-    }
-
-    pbuffer->ulDonepos += *bytesinc;
-    pbuffer->ulBuffpos  = pbuffer->ulDonepos;
-    *bytesinc           = 0;
-    if(pbuffer->ulDonepos >= pbuffer->ulBuffsz) {
-            //calc position in next buffer
-            *bytesinc = pbuffer->ulDonepos - pbuffer->ulBuffsz;
-            return 0; //all of the buffer has been consumed
-    }
-    return 1;
-}
+USHORT  WAVESTREAM::_vRealignBuffer(ULONG endpos, PSTREAMBUFFER pbuffer)
+{
+   ULONG streambuf_start, bufconsumed;
+   USHORT usRC;
+
+   streambuf_start = pbuffer->ulDonepos - pbuffer->ulBuffpos;
+      // if none of the data in this stream buffer has been consumed
+   if (endpos <= streambuf_start) {
+      pbuffer->ulDonepos = 0;
+      pbuffer->ulBuffpos = 0;
+      usRC = 1;
+   }
+     // else some or all of the data has been consumed
+   else {
+      bufconsumed = endpos - streambuf_start;
+        // some of the buffer has been consumed
+      if (bufconsumed <= pbuffer->ulBuffsz) {
+         pbuffer->ulDonepos = 0;
+         pbuffer->ulBuffpos = pbuffer->ulBuffsz - bufconsumed;
+         pbuffer->ulBuffpos &= 0xFFFFFFFC; //keep it on a dword boundary
+         usRC = 1;
+      }
+        // all of the buffer has been consumed
+      else {
+         pbuffer->ulDonepos = 0;
+         pbuffer->ulBuffpos = pbuffer->ulBuffsz;
+         usRC = 0;
+      }
+   }
+   return(usRC);
+}
+
 //******************************************************************************
 // _vRealignPausedBuffers(void)
@@ -89 +101 @@
 void WAVESTREAM::_vRealignPausedBuffers(ULONG endpos)
 {
-    PSTREAMBUFFER ptempbuff;
-
-    switch (ulStreamType & STREAM_WRITE) {
-    case STREAM_READ:
-            //SvL: Don't get the lastest recording data as a read command
-        //     would now restart recording (as it's stopped)
-        //     Just return what we've got or push the buffer on the inprocess queue
-            ptempbuff = (PSTREAMBUFFER)qhDone.Head();
-            if(ptempbuff) {
-                    if(ptempbuff->ulBuffpos) {//if we recorded anything into this buffer, then return it now
-                        ReturnBuffer();
-                            return;
-                    }
-                    ptempbuff->ulBuffpos = 0;
-                    ptempbuff->ulDonepos = 0;
-                    qhInProcess.PushOnHead(qhDone.PopHead());
-            }
-        break;
+   PQUEUEHEAD pTempHead = new QUEUEHEAD;
+   PSTREAMBUFFER ptempbuff;
+   USHORT usRC;
+
+
+   switch (ulStreamType & STREAM_WRITE) {
+   case STREAM_READ:
+      _vReadAudioBuf();
+      break;
 
    case STREAM_WRITE:
-   {
-        PQUEUEHEAD pTempHead = new QUEUEHEAD;
-        ULONG bytesinc;
-        USHORT usRC;
-
-            bytesinc = endpos - _ulBytesProcessed;
-        bytesinc &= 0xFFFFFFFC; //keep it on a dword boundary
-
-        // if there are bufferes 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.
-        // Pass them all to _vRealignBuffer. If the rc from _vRealignBuffer is
-        // 0 then there is no unprocessed data in the buffer (it is ready to
-        // 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->PushOnTail(qhDone.PopHead());
-        } /* endwhile */
-
-        while (qhInProcess.IsElements()) {
-                pTempHead->PushOnTail(qhInProcess.PopHead());
-        } /* endwhile */
-
-        while(pTempHead->IsElements()) {
-                usRC = _vRealignBuffer(&bytesinc, (PSTREAMBUFFER)pTempHead->Head());
-                if (usRC) {
-                        qhInProcess.PushOnTail(pTempHead->PopHead());
-                    }
-                else {
-                        qhDone.PushOnTail(pTempHead->PopHead());
-                    }
-        } /* endwhile */
-            if(qhDone.IsElements())
-                ReturnBuffer();
-
-        delete pTempHead; // free the memory this ain't no Java here !!
-        break;
-    }
-    default:
-        break;
-    } /* endswitch */
-}
+
+      // if there is a buffer on the InProcess Queue
+      // only check the first one as any others are just waiting.....
+      if (qhInProcess.IsElements()) {
+           // if any data has been written from this stream buffer
+         ptempbuff = (PSTREAMBUFFER)qhInProcess.Head();
+         if (ptempbuff->ulDonepos) {
+            _vRealignBuffer(endpos, ptempbuff);
+         } /* end if ulDonepos */
+      }
+
+      // if there are bufferes 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.
+      // Pass them all to _vRealignBuffer. If the rc from _vRealignBuffer is
+      // 0 then there is no unprocessed data in the buffer (it is ready to
+      // 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());
+      } /* endwhile */
+
+      while (pTempHead->IsElements()) {
+         usRC = _vRealignBuffer(endpos, (PSTREAMBUFFER)pTempHead->Head());
+         if (usRC)
+           qhInProcess.PushOnHead(pTempHead->PopHead());
+         else
+           qhDone.PushOnTail(pTempHead->PopHead());
+      } /* endwhile */
+      break;
+   default:
+      break;
+   } /* endswitch */
+   delete pTempHead; // free the memory this ain't no Java here !!
+}
+
 //******************************************************************************
 // get ready to start streaming
@@ -164 +161 @@
     ULONG space, byteswritten;
 
+    dgprintf(("AddBuffers"));
+
+    byteswritten = 0;
     if (ulStreamType & STREAM_WRITE) {
-            if(!qhInProcess.Head() && !qhDone.Head()) {
-                //underrun: stop playback
-//                  dprintf(("underrun: stop playback"));
-
-            //save last known position
-            _ulUnderrunBase = GetCurrentPos();
-            
-            //silence wave stream before stopping it (removes clicks)
-            pahw->SetVolume(StreamId, getMixerStreamId(), 0);
-
-            //and stop it
-                    pahw->Stop(StreamId);
-                    fUnderrun = TRUE;
-                    return;
-            }
-            if(pahw->GetSpace(StreamId, &_configinfo, &space) == FALSE) {
-            dprintf(("pahw->getSpace: No room!"));
+        // 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, &space) == FALSE) {
+            dgprintf(("WAVESTREAM::AddBuffers Error 1"));
             return;
         }
-            while(space) {
-                    byteswritten = AddBuffer(space);
-                    if(byteswritten == (ULONG)-1) break;
-                    space -= byteswritten;
-            }
-    }
-}
-//******************************************************************************
-// write one buffer to the audio buffer
+        space &= ( ~(_configinfo.ulSampleSize - 1));
+        while (space && qhInProcess.IsElements()) {
+            byteswritten = AddBuffer(space);
+            if(byteswritten == (ULONG)-1)
+                break;
+            space -= byteswritten;
+            space &= ( ~(_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
@@ -199 +193 @@
 ULONG WAVESTREAM::AddBuffer(ULONG space)
 {
-    PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhDone.Tail();
+    PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
     ULONG pdataBuf;
-    ULONG Buff_left, byteswritten;
-
-    if(!pTemp || pTemp->ulBuffpos >= (pTemp->ulBuffsz & 0xFFFFFFFC)) {
-            pTemp = (PSTREAMBUFFER)qhInProcess.Head();
-    }
-    if(!pTemp) {
-#ifdef DEBUG
-            dprintf(("AddBuffer: pTemp == NULL"));
-#endif /* DEBUG */
-            return (ULONG)-1;
+    ULONG Buff_left, byteswritten, start_pos;
+
+    ddprintf(("AddBuffer"));
+    // make sure we have a buffer to copy from.....
+    if (!pTemp) {
+        return (ULONG)-1;
+    }
+
+    // get the starting position. Call WaveGetHwPtr. if we get a bad rc
+    // then we bail out.
+    if(pahw->GetHwPtr(StreamId, &_configinfo, &start_pos) == FALSE)
+    {
+        dgprintf(("WAVESTREAM::AddBuffer Error in WaveGetHwPtr"));
+        DebugInt3();
+        return (ULONG)-1;
     }
 
@@ -216 +215 @@
     pdataBuf  = (ULONG)pTemp->pBuffptr + pTemp->ulBuffpos;
     Buff_left = pTemp->ulBuffsz - pTemp->ulBuffpos;
-
-    if(Buff_left) {
-       // write the audio buffer
-       Buff_left = min(Buff_left, space);
-       if(pahw->Transfer(StreamId, &_configinfo, pdataBuf, Buff_left, &byteswritten) == FALSE) {
-           dprintf(("AddBuffer: pahw->Transfer failed!!"));
-           return (ULONG)-1;
-       }
-       if(byteswritten == 0) {
-           return (ULONG)-1; //no more room
-       }
-
-       // update the buffer pos counter
-       pTemp->ulBuffpos += byteswritten;
-    } 
-    else byteswritten = 0;
-
-    if(pTemp == qhInProcess.Head()) {
-        qhDone.PushOnTail(qhInProcess.PopHead());
-    }
-    dprintf(("AddBuffer %lx size %d, bytes written %d", pdataBuf, (USHORT)Buff_left, (USHORT)byteswritten));
+    Buff_left = min(Buff_left, space);
+
+    if(pahw->Transfer(StreamId, &_configinfo, pdataBuf, Buff_left, &byteswritten) == FALSE) {
+        dgprintf(("AddBuffer: pahw->Transfer failed!!"));
+        return (ULONG)-1;
+    }
+    if(byteswritten == 0) {
+        return (ULONG)-1; //no more room
+    }
+    // update the buffer pos counter
+    pTemp->ulBuffpos += byteswritten;
+
+    // update the done Position
+    pTemp->ulDonepos = start_pos + byteswritten;
+
+    // check to see if the buffer has been copied and needs to be put on the done queue
+    if (pTemp->ulBuffpos >= (pTemp->ulBuffsz & 0xFFFFFFFC)) {
+        qhDone.PushOnTail(qhInProcess.PopHead());
+    }
+    dgprintf(("WAVESTREAM::AddBuffer sz %lx, bywr %lx dp %lx", Buff_left, byteswritten,pTemp->ulDonepos));
     return byteswritten;
 }
@@ -249 +247 @@
     ULONG Buff_left, bytesread;
 
-    if(!pTemp) 
+    if(!pTemp)
         return FALSE;
 
@@ -290 +288 @@
  PSTREAMBUFFER ptemp;
  ULONG         ulCurBytesProcessed = 0;
- ULONG         bytesinc;
+// ULONG         bytesinc;
 
 #ifdef DEBUG
-//    dprintf(("WAVESTREAM::Process"));
+    ddprintf(("WAVESTREAM::Process"));
 #endif
 
+    // 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.
+    if(pahw->GetPosition(StreamId, &_configinfo, &ulCurBytesProcessed) == FALSE)
+    {
+        ddprintf(("Error No bytes processed"));
+        DebugInt3();
+        return;
+    }
+    ddprintf(("StPos: %lx", ulCurBytesProcessed));
+    // save the bytes processed in the stream object
+    _ulBytesProcessed = ulCurBytesProcessed;
+
     switch (ulStreamType & STREAM_WRITE) {
-    case STREAM_WRITE:
-    {
-        if(pahw->GetPosition(StreamId, &_configinfo, &ulCurBytesProcessed) == FALSE || 
-           ulCurBytesProcessed == 0) 
-        {//shouldn't happen
-            DebugInt3();
-            return;
-        }
-
-        bytesinc  = ulCurBytesProcessed - _ulBytesProcessed;
-        dprintf3(("P: %lx %x", ulCurBytesProcessed, (USHORT)bytesinc));
-
-        if(ulCurBytesProcessed < _ulBytesProcessed) 
+
+        // if there are buffers that have been completly written to the audio buffer
+        // check the first one on the done queue
+        // if it's data has been consumed by the hardware return it.
+        //
+        // Bug #18 Sometimes MMPM gives us really small buffers. If we
+        // wait for the buffer to be completly consumed and there is a tiny buffer
+        // on the queue after this one, the sound part could underrun before we get a
+        // chance to refill it. To fix this we will return the buffer if it will be
+        // consumed before the next call to WAVESTREAM:Process().
+        // rjj Fix for Bug #18 28082008
+        case STREAM_WRITE:
         {
-            ULONG ulCurBytesProcessed, ulStreamPos;
-
-            if(OSS16_WaveGetPos(StreamId, &ulCurBytesProcessed) != OSSERR_SUCCESS) {
-                ulCurBytesProcessed = 0;
+          if(qhDone.IsElements()) {
+                ptemp = (PSTREAMBUFFER)qhDone.Head();
+                while ((_ulBytesProcessed + _configinfo.ulBytesPerIRQ) >= ptemp->ulDonepos)
+                {
+                    ReturnBuffer();
+                    ptemp = (PSTREAMBUFFER)qhDone.Head();
+                }
             }
-
-            ulStreamPos  = pahw->ConvertPositionInvert(ulCurBytesProcessed, &_configinfo);
-            //round to sample boundary
-            ulStreamPos &= ~(_configinfo.ulSampleSize - 1);
-
-#ifdef DEBUG
-            dprintf(("WARNING: Process: Current pos %ld pos %ld incr %d", ulCurBytesProcessed, _ulBytesProcessed, bytesinc));
-            dprintf(("WARNING: hw pos %lx, streampos %lx", ulCurBytesProcessed, ulStreamPos));
-#endif /* DEBUG */
-        }
-        _ulBytesProcessed = ulCurBytesProcessed;
-
-        while(bytesinc) 
-        {
-          if(qhDone.IsElements()) {  // if there are buffers that have been completly written to the audio buffer
-                                       // check the first one on the done queue
-                                       // if it's data has been consumed by the hardware return it.
-                                                         // Bug #18 Sometimes MMPM gives us really small buffers. If we 
-                                                         // wait for the buffer to be completly consumed and there is a tiny buffer
-                                                         // on the queue after this one, the sound part could underrun before we get a 
-                                                         // chance to refill it. To fix this we will return the buffer if it will be  
-                                                         // consumed before the next call to WAVESTREAM:Process(). 
-                                                         // rjj Fix for Bug #18 28082008
-                ptemp = (PSTREAMBUFFER)qhDone.Head();
-                ptemp->ulDonepos += bytesinc;
-                bytesinc          = 0;
-                                  if ((ptemp->ulDonepos + _configinfo.ulBytesPerIRQ) >= ptemp->ulBuffsz)
-                {
-                    //calc position in next buffer
-                    bytesinc = ptemp->ulDonepos - ptemp->ulBuffsz;
-//                  dprintf2(("Process: Return buffer %lx size %d", ptemp->pBuffptr, ptemp->ulBuffsz));
-                    ReturnBuffer();
-                          }
-          }
-            else        break; //shouldn't happen
-        }
-
-        if (qhInProcess.IsElements()){
-            AddBuffers(FALSE);
-        }
+            if (qhInProcess.IsElements()){
+               AddBuffers(FALSE);
+            }
+
         break;
-    }
-    case STREAM_READ:
+
+        }
+        case STREAM_READ:
             while(_vReadAudioBuf());
             break;
-    default:
-        break;
+        default:
+            break;
     } /* endswitch */
 
@@ -382 +361 @@
 {
     qhInProcess.PushOnTail((PQUEUEELEMENT)pStreamBuf);
-//    dprintf2(("WAVESTREAM::Write: Push on tail %lx %ld", ((PSTREAMBUFFER)qhInProcess.Tail())->pBuffptr, ((PSTREAMBUFFER)qhInProcess.Tail())->ulBuffsz));
-    if(fUnderrun) {
-        PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
-
-//        dprintf(("Restart after underrun!"));
-            fUnderrun = FALSE;
-
-        // configure the wave device
-        // (NOTE: Must call this function; sample rate position is reset there)
-        if(pahw->ConfigDev(StreamId, &_configinfo, pTemp->ulBuffsz) == FALSE) {
-            dprintf(("ConfigDev failed!!"));
-        }
-
-        // prepare wave device for playback/recording
-        if(pahw->Prepare(StreamId) == FALSE) {
-            dprintf(("Prepare failed!!"));
-        }
-            AddBuffers(TRUE);
-            if(ulStreamType == STREAM_WAVE_PLAY)
-                    MixerSetWaveVolume(getMixerStreamId(), StreamId, volume);
-    }
+    //    dprintf2(("WAVESTREAM::Write: Push on tail %lx %ld", ((PSTREAMBUFFER)qhInProcess.Tail())->pBuffptr, ((PSTREAMBUFFER)qhInProcess.Tail())->ulBuffsz));
     return 0;
 }
@@ -433 +392 @@
     if (ulStreamState == STREAM_STREAMING)  // if the stream is active
     {
-            if (ulStreamType & STREAM_WRITE) 
+        if (ulStreamType & STREAM_WRITE)
         {
-                if(pahw->GetPosition(StreamId, &_configinfo, &Processed) == FALSE) 
+            if(pahw->GetPosition(StreamId, &_configinfo, &Processed) == FALSE)
             {
                 DebugInt3();
                 Processed = _ulBytesProcessed; //last known position
             }
-            }
-            else        Processed = _ulBytesProcessed;
-    }
-    else Processed = _ulBytesProcessed;
-
-    //add position of underrun (if one occurred in the past)
-    Processed += _ulUnderrunBase;
+        }
+        else
+            Processed = _ulBytesProcessed;
+    }
+    else
+        Processed = _ulBytesProcessed;
 
     // if we haven't processed anything then just return
@@ -467 +425 @@
     if (ulStreamState == STREAM_STREAMING)  // if the stream is active
     {
-            if (ulStreamType & STREAM_WRITE) {
-                if(pahw->GetPosition(StreamId, &_configinfo, &Processed) == FALSE) 
+        if (ulStreamType & STREAM_WRITE) {
+            if(pahw->GetPosition(StreamId, &_configinfo, &Processed) == FALSE)
             {
                 DebugInt3();
                 Processed = _ulBytesProcessed; //last known position
             }
-            }
-            else        Processed = _ulBytesProcessed;
-    }
-    else Processed = _ulBytesProcessed;
-
-    //add position of underrun (if one occurred in the past)
-    Processed += _ulUnderrunBase;
+        }
+        else
+            Processed = _ulBytesProcessed;
+    }
+    else
+        Processed = _ulBytesProcessed;
+
     return Processed;
 }
@@ -517 +475 @@
 
 #ifdef DEBUG
-//    dprintf(("WAVESTREAM::StartStream"));
+    ddprintf(("WAVESTREAM::StartStream"));
 #endif
 
     if(ulStreamState == STREAM_STREAMING) {
-        dprintf(("StartStream: already playing!!"));
+        ddprintf(("StartStream: already playing!!"));
         return NO_ERROR;
     }
@@ -528 +486 @@
     // (NOTE: Must call this function; sample rate position is reset there)
     if(pahw->ConfigDev(StreamId, &_configinfo, (pTemp) ? pTemp->ulBuffsz : 0) == FALSE) {
-        dprintf(("StartStream: ConfigDev failed!!"));
+        ddprintf(("StartStream: ConfigDev failed!!"));
         goto fail;
     }
-
     // prepare wave device for playback/recording
     if(pahw->Prepare(StreamId) == FALSE) {
-        dprintf(("StartStream: Prepare failed!!"));
+        ddprintf(("StartStream: Prepare failed!!"));
         goto fail;
     }
 
     _ulBytesProcessed = 0;
-    _ulUnderrunBase   = 0;
-    fUnderrun = FALSE;
 
     ulStreamState = STREAM_STREAMING;
     //Adding the first buffer also starts playback
     if(ulStreamType == STREAM_WAVE_PLAY) {
-            AddBuffers(TRUE);
+        AddBuffers(TRUE);
         //Must set volume after adding buffers (voices inside sblive driver might not
         //be allocated otherwise (first start) )
+        dprintf(("SetVolume %lx",volume));
         pahw->SetVolume(StreamId, getMixerStreamId(), volume);
     }
@@ -555 +511 @@
         pahw->SetVolume(StreamId, getMixerStreamId(), inputgain);
 
-            if(pahw->Start(StreamId) != TRUE) {
+        if(pahw->Start(StreamId) != TRUE) {
             dprintf(("pahw->Start failed!!"));
             goto fail;
         }
     }
-//    dprintf(("WAVESTREAM::StartStream %lx", StreamId));
+    ddprintf(("WAVESTREAM::StartStream %lx", StreamId));
     return NO_ERROR;
 
@@ -573 +529 @@
     if(ulStreamState == STREAM_STOPPED) {
         dprintf(("WAVESTREAM::StopStream %lx (already stopped)", StreamId));
-            fUnderrun = FALSE;
             pControl->ulTime = GetCurrentTime();
             return NO_ERROR;
@@ -587 +542 @@
 
     ulStreamState = STREAM_STOPPED;
-    fUnderrun = FALSE;
-//    dprintf(("WAVESTREAM::StopStream %lx", StreamId));
+    ddprintf(("WAVESTREAM::StopStream %lx", StreamId));
     ReturnBuffers();
     pControl->ulTime = GetCurrentTime();
-    _ulTimeBase = 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;
     return NO_ERROR;
 }
@@ -606 +564 @@
 
     ulStreamState = STREAM_PAUSED;
-    fUnderrun = FALSE;
-
-//    dprintf(("WAVESTREAM::PauseStream %lx", StreamId));
+
+    ddprintf(("WAVESTREAM::PauseStream %lx", StreamId));
+
     _vRealignPausedBuffers(endpos);
 
     _ulBytesProcessed = endpos;
     pControl->ulTime = GetCurrentTime();
+    _ulBytesProcessed = 0;
     return NO_ERROR;
 }
@@ -634 +593 @@
     switch(type) {
     case PROPERTY_VOLUME:
-        volume = value; 
+        volume = value;
+        dprintf(("WAVESTREAM::SetProperty() Vol: %0lx",value));
         if(ulStreamState == STREAM_STREAMING && ulStreamType == STREAM_WAVE_PLAY) {
             MixerSetWaveVolume(getMixerStreamId(), StreamId, volume);
@@ -655 +615 @@
 //******************************************************************************
 //******************************************************************************
-ULONG WAVESTREAM::GetProperty(int type) 
+ULONG WAVESTREAM::GetProperty(int type)
 {
 #ifdef DEBUG
@@ -677 +637 @@
 //******************************************************************************
 WAVESTREAM::WAVESTREAM(ULONG streamtype, LPMCI_AUDIO_INIT pinit, USHORT filesysnum, OSSSTREAMID mixerStreamId):
-   STREAM(streamtype, filesysnum, mixerStreamId) 
+   STREAM(streamtype, filesysnum, mixerStreamId)
 {
 #ifdef DEBUG
@@ -692 +652 @@
     _ulBytesProcessed           = 0;
     _ulTimeBase                 = 0;
-    _ulUnderrunBase             = 0;
+    //_ulUnderrunBase             = 0;
     ulSavedInputGain            = 0;
 
     _configinfo.pConversionBuffer  = 0;
     pahw->SetupConversion(&_configinfo, pinit->ulOperation, pinit->sMode, pinit->sChannels, pinit->lBitsPerSRate);
-   
-    if(_configinfo.usConversion != CONVERT_NONE) 
+
+    if(_configinfo.usConversion != CONVERT_NONE)
     {//allocate conversion buffer
         PVOID pSelOff;
         LIN   linAddr;
 
-        if(DevHelp_VMAlloc(VMDHA_FIXED, CONVERSION_BUFFER_SIZE, (ULONG)-1L, &linAddr, &pSelOff) != 0) 
+        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;
@@ -710 +671 @@
         else _configinfo.pConversionBuffer = linAddr;
     }
-    if(_configinfo.fSampleRateConversion == TRUE) 
+    if(_configinfo.fSampleRateConversion == TRUE)
     {//allocate buffer for sample rate conversion
         PVOID pSelOff;
         LIN   linAddr;
 
-        if(DevHelp_VMAlloc(VMDHA_FIXED, CONVERSION_BUFFER_SIZE, (ULONG)-1L, &linAddr, &pSelOff) != 0) 
+        if(DevHelp_VMAlloc((VMDHA_FIXED | VMDHA_CONTIG), CONVERSION_BUFFER_SIZE, (ULONG)-1L, &linAddr, &pSelOff) != 0)
         {
-             DebugInt3(); //should never happen!!
+                         //dgprintf(("Error in DevHelp_VMAlloc SR Conversion Buffer"));
+                         DebugInt3(); //should never happen!!
         }
         else _configinfo.pSRateConvBuffer = linAddr;
@@ -724 +686 @@
     pinit->ulFlags |= pahw->QueryDataFlags(pinit->ulOperation, pinit->sMode, pinit->lBitsPerSRate);
 
-    fUnderrun   = FALSE;
+    //fUnderrun   = FALSE;
     StreamId    = 0;
-    
+
     if(pahw->Open(current_device, ulStreamType, ulSysFileNum, &StreamId) != TRUE)
     {