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

Timestamp:

May 6, 2010, 3:08:34 AM (15 years ago)

Author:

David Azarewicz

Message:

Rework buffer management

File:

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

OCO/trunk/drv16/wavestrm.cpp

@@ -40 +40 @@
 #endif
 
+extern "C" ULONG  __cdecl __saveregs OSSIDC_EntryPoint(ULONG cmd, ULONG param1, ULONG param2);
+
 
 //******************************************************************************
@@ -50 +52 @@
 // the data has been played and 1 if there is still some data left.
 //******************************************************************************
-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);
+USHORT  WAVESTREAM::_vRealignBuffer(ULONG ulEndPos, PSTREAMBUFFER pBuffer)
+{
+        if (ulEndPos >= pBuffer->ulDonepos) { /* all of the data has been consumed */
+                pBuffer->ulBuffpos = pBuffer->ulBuffsz;
+                pBuffer->ulDonepos = 0;
+                return(0);
+        }
+
+        if (ulEndPos >= (pBuffer->ulDonepos - pBuffer->ulBuffpos)) { /* some of the data has been consumed */
+                pBuffer->ulBuffpos = pBuffer->ulDonepos - ulEndPos;
+                pBuffer->ulBuffpos &= 0xFFFFFFFC; //keep it on a dword boundary
+                pBuffer->ulDonepos = 0;
+                return(1);
+        }
+        /* none of the data in this buffer has been consumed */
+        pBuffer->ulDonepos = 0;
+        pBuffer->ulBuffpos = 0;
+        return(1);
 }
 
@@ -99 +89 @@
 // and put the STREAMBUFFER on the Head queue.
 //******************************************************************************
-void WAVESTREAM::_vRealignPausedBuffers(ULONG endpos)
-{
-   PQUEUEHEAD pTempHead = new QUEUEHEAD;
-   PSTREAMBUFFER ptempbuff;
-   USHORT usRC;
-
-
-   switch (ulStreamType & STREAM_WRITE) {
-   case STREAM_READ:
-      _vReadAudioBuf();
-      break;
-
-   case STREAM_WRITE:
-
-      // 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 !!
+void WAVESTREAM::_vRealignPausedBuffers(ULONG ulEndPos)
+{
+        PQUEUEHEAD pTempHead = new QUEUEHEAD;
+        PSTREAMBUFFER pTmpBuf;
+        USHORT usRC;
+
+
+        switch (ulStreamType & STREAM_WRITE) {
+        case STREAM_READ:
+                _vReadAudioBuf();
+                break;
+
+        case STREAM_WRITE:
+
+                // 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
+                        pTmpBuf = (PSTREAMBUFFER)qhInProcess.Head();
+                        if (pTmpBuf->ulDonepos)
+                        {
+                                _vRealignBuffer(ulEndPos, pTmpBuf);
+                        }
+                }
+
+                // if there are buffere 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());
+                }
+
+                while (pTempHead->IsElements())
+                {
+                        usRC = _vRealignBuffer(ulEndPos, (PSTREAMBUFFER)pTempHead->Head());
+                        if (usRC)
+                                qhInProcess.PushOnHead(pTempHead->PopHead());
+                        else
+                                qhDone.PushOnTail(pTempHead->PopHead());
+                }
+                while (qhDone.IsElements()) {
+                        ReturnBuffer();
+                }
+                break;
+        default:
+                break;
+        } /* endswitch */
 }
 
@@ -163 +154 @@
 #pragma on (unreferenced)
 {
-    ULONG space, byteswritten, curspace,i;
-
-//    dgprintf(("AddBuffers %d",fFirst == TRUE?1:2));
-
-    byteswritten = 0;
-    if (ulStreamType & STREAM_WRITE) 
+    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
@@ -175 +167 @@
         // 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) 
+                if (pahw->GetSpace(StreamId, &_configinfo, &ulSpace) == FALSE)
         {
-//            dgprintf(("WAVESTREAM::AddBuffers Error 1"));
+                        dgprintf(("WAVESTREAM::AddBuffers GetSpace failed"));
             return;
         }
-        space &= (~(_configinfo.ulSampleSize - 1));
-//        curspace = min(space, _configinfo.ulBytesPerIRQ/_configinfo.ulSampleSize * 2);
-        curspace = space;
-        while (space && qhInProcess.IsElements()) 
+        ulSpace &= (~(_configinfo.ulSampleSize - 1));
+                ulDAZ = 0;
+        while (ulSpace && qhInProcess.IsElements())
         {
-            // Fisrt time going in task time
-            // for I7 need give time for interrupt time
-            if (fFirst == TRUE)  //PS+++
-            {
-                cli();
-//                 DevHelp_ProcBlock (space, 20, 0);
-            }
-//            dgprintf(("AddBuffers write %ld SSize:%ld %d",space, _configinfo.ulSampleSize, fFirst == TRUE?1:2));
-            byteswritten = AddBuffer(space > curspace? curspace: space);
-            if (pahw->GetSpace(StreamId, &_configinfo, &curspace) == FALSE) 
-            {
-//                dgprintf(("WAVESTREAM::AddBuffers Error 2"));
-                break;
-            }
-            if(byteswritten == (ULONG)-1)
-                break;
-            if (!curspace)
-            {
-                curspace = _configinfo.ulSampleSize;
-            }
-            space -= byteswritten;
-            space &= ( ~(_configinfo.ulSampleSize - 1));
-        }
-
-    }
-//    dgprintf(("AddBuffers %d End",fFirst == TRUE?1:2));
-}
+                        if (ulDAZ++ > 20) {
+                                dgprintf(("WAVESTREAM::AddBuffers DAZ break")); // Temporary hack to prevent lockups when uniaud32 stops (underrun)
+                                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) break;
+            ulSpace -= ulBytesWritten;
+            ulSpace &= ( ~(_configinfo.ulSampleSize - 1));
+        }
+
+    }
+}
+
 //******************************************************************************
 // write one buffer to the audio buffer                                           1
@@ -218 +203 @@
 // there are buffers on pHead... BEWARE
 //******************************************************************************
-ULONG WAVESTREAM::AddBuffer(ULONG space)
+ULONG WAVESTREAM::AddBuffer(ULONG ulSpace)
 {
     PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
-    ULONG pdataBuf;
-    ULONG Buff_left, byteswritten, start_pos;
-
-//    ddprintf(("AddBuffer"));
-    // make sure we have a buffer to copy from.....
-    if (!pTemp) 
+    ULONG pDataBuf;
+    ULONG ulBuffLeft;
+        ULONG ulBytesWritten;
+        ULONG ulStartPos;
+
+    /* 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)
+        /* make sure there is space in the output buffer */
+    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;
+    }
+
+    // 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"));
@@ -240 +238 @@
     }
 
-    if (!pTemp->ulBuffsz || !space)
-    {
-        dgprintf(("WAVESTREAM::AddBuffer 0, Bufsz:%ld Space:%ld",pTemp->ulBuffsz, space));
-        //PS+++ if is ZERO do nothing and ask for give new buffer, See REMARK in mmpm2.inf
+    // 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)
+    {
+                // This could mean that the hardware has underrun TODO: implement underrun logic
+        dgprintf(("WS::AddBuffer: pahw->Transfer failed"));
+        return (ULONG)-1;
+    }
+    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));
+
+        _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());
-//        DebugInt3();
-        return -1;
-    }
-    // get the buffer pointer and amount of data remaining
-    pdataBuf  = (ULONG)pTemp->pBuffptr + pTemp->ulBuffpos;
-    Buff_left = pTemp->ulBuffsz - pTemp->ulBuffpos;
-    Buff_left = min(Buff_left, space);
-
-    if (pahw->Transfer(StreamId, &_configinfo, pdataBuf, Buff_left, &byteswritten) == FALSE) 
-    {
-        dgprintf(("AddBuffer: pahw->Transfer failed!!"));
-//        DebugInt3();
-        return (ULONG)-1;
-    }
-    if (byteswritten == 0) 
-    {
-        dgprintf(("AddBuffer: No more room!!"));
-//        DebugInt3();
-//PS+++        return (ULONG)-1; //no more room
-        return 0;   //PS+++ may be in next time?
-    }
-    // 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(("WV::AddBuffer sz %lx, bywr %lx dp %lx", Buff_left, byteswritten,pTemp->ulDonepos));
-    return byteswritten;
+    }
+    return ulBytesWritten;
 }
 //******************************************************************************
@@ -287 +277 @@
 {
     PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
-    ULONG pdataBuf;
-    ULONG Buff_left, bytesread;
-
-    if(!pTemp)
-        return FALSE;
+    ULONG pDataBuf;
+    ULONG ulBuffLeft, ulBytesRead;
+
+    if(!pTemp) return FALSE;
 
     // get the buffer pointer and amount of data remaining
-    pdataBuf  = (ULONG)pTemp->pBuffptr + pTemp->ulBuffpos;
-    Buff_left = pTemp->ulBuffsz - pTemp->ulBuffpos;
+    pDataBuf  = (ULONG)pTemp->pBuffptr + pTemp->ulBuffpos;
+    ulBuffLeft = pTemp->ulBuffsz - pTemp->ulBuffpos;
 
     // read wave data
-    if(pahw->Transfer(StreamId, &_configinfo, pdataBuf, Buff_left, &bytesread) == FALSE) 
-    {
-       dprintf(("_vReadAudioBuf: pahw->Transfer failed!!"));
-       return FALSE;
-    }
-    if(bytesread == 0) {
-       return FALSE; //no more data
-    }
-
-//    dprintf4(("_vReadAudioBuf %lx size %ld, bytes read %ld", pdataBuf, Buff_left, bytesread));
+    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  += bytesread;
-    _ulBytesProcessed += bytesread;
+    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();
-            dprintf(("_vReadAudioBuf return buffer %lx size %ld, bytes read %ld position %ld", (ULONG)pTemp->pBuffptr, pTemp->ulBuffsz, bytesread, _ulBytesProcessed));
     }
 
@@ -328 +318 @@
 // can be returned and finally process any events pending.
 //******************************************************************************
-USHORT ProcNumber = 0;
 void DBGCALLCONV WAVESTREAM::Process(void)
 {
- PSTREAMBUFFER ptemp;
- ULONG         ulCurBytesProcessed = 0;
- USHORT        CurProcNumber = ProcNumber++;
- ULONG         space;
-
-#ifdef DEBUG
-//    ddprintf(("WAVESTREAM::Process %d",CurProcNumber));
-#endif
+        PSTREAMBUFFER pTemp;
+        ULONG   ulBytes;
+        ULONG ulDAZ;
+
+        //ddprintf(("WAVESTREAM::Process Start"));
 
     // get the stream position. if we get a bad rc or the position is 0
@@ -344 +330 @@
     // 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)
+        // 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"));
@@ -350 +339 @@
         return;
     }
-//    ddprintf(("StPos: %lx", ulCurBytesProcessed));
-    // save the bytes processed in the stream object
-    _ulBytesProcessed = ulCurBytesProcessed;
-
-    switch (ulStreamType & STREAM_WRITE) 
-    {
-
-        // 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
+    _ulBytesProcessed = ulBytes;
+
+    switch (ulStreamType & STREAM_WRITE)
+    {
         case STREAM_WRITE:
-        {
-            if (qhDone.IsElements()) 
+            if (qhInProcess.IsElements())
             {
-                ptemp = (PSTREAMBUFFER)qhDone.Head();
-                while ((_ulBytesProcessed + _configinfo.ulBytesPerIRQ) >= ptemp->ulDonepos)
-                {
-                    ReturnBuffer();
-                    ptemp = (PSTREAMBUFFER)qhDone.Head();
-                }
+                                AddBuffers(FALSE);
             }
-            if ((pahw->GetSpace(StreamId, &_configinfo, &space) != FALSE) 
-               && qhInProcess.IsElements())
-            {
-               AddBuffers(FALSE);
-            }
-
-        break;
-
-        }
+                // Return any buffers that have been completely written to uniaud32
+                        while (qhDone.IsElements()) {
+                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 */
+                                ReturnBuffer();
+                        }
+                break;
         case STREAM_READ:
-            while(_vReadAudioBuf());
-            break;
+                        ulDAZ = 0;
+                    while(_vReadAudioBuf()) {
+                                if (ulDAZ++ > 20) { /* temporary hack to prevent hangs when uniaud32 stops (overruns) */
+                                ddprintf(("WAVESTREAM::Process Read DAZ Break"));
+                                        break;
+                                }
+                        }
+                    break;
         default:
             break;
@@ -395 +372 @@
 
     ProcessEvents();
-//    ddprintf(("WAVESTREAM::Process %d End",CurProcNumber));
+    //ddprintf(("WAVESTREAM::Process End"));
 }
 //******************************************************************************
@@ -404 +381 @@
 {
     PSTREAMBUFFER pStreamBuf = new STREAMBUFFER(uLength, pbuf);
- 
+
     return Write(pStreamBuf);
 }
@@ -420 +397 @@
 {
     qhInProcess.PushOnTail((PQUEUEELEMENT)new STREAMBUFFER(uLength, pbuf));
-//    dprintf2(("WAVESTREAM::Read: Push on tail %lx %d", pbuf, uLength));
+    //dprintf2(("WAVESTREAM::Read: Push on tail %lx %lx", pbuf, uLength));
     return 0;
 }
@@ -441 +418 @@
     ULONG Seconds, MilliSeconds, Overflow, Processed;
 
-//PS++ optimize code
+        //PS++ optimize code
     Processed = _ulBytesProcessed;
     if (ulStreamState == STREAM_STREAMING)  // if the stream is active
@@ -449 +426 @@
            if (pahw->GetPosition(StreamId, &_configinfo, &Processed) == FALSE)
            {
-//                DebugInt3();
+                                //DebugInt3();
                 Processed = _ulBytesProcessed; //last known position
            }
@@ -455 +432 @@
     }
 
-    // if we haven't processed anything then just return
-    // _ulTimeBase
+    // if we haven't processed anything then just return _ulTimeBase
     if(Processed == 0)
         return(_ulTimeBase);
@@ -470 +446 @@
 ULONG WAVESTREAM::GetCurrentPos(void)
 {
-    ULONG 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
-           }
+        ULONG 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
+                        }
+                }
         }
-    }
-
-    return Processed;
+        return Processed;
 }
 //******************************************************************************
@@ -498 +473 @@
    PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhDone.Tail();
 
-   if(!pTemp) 
+   if(!pTemp)
    {
        pTemp = (PSTREAMBUFFER)qhInProcess.Head();
    }
-   if(pTemp) 
+   if(pTemp)
    {
        writepos = pTemp->ulBuffpos;
@@ -517 +492 @@
 void  WAVESTREAM::SetCurrentTime(ULONG time)
 {
+        //ddprintf(("SetCurrentTime: %lx", time));
     _ulTimeBase = time;
 }
@@ -525 +501 @@
     PSTREAMBUFFER pTemp = (PSTREAMBUFFER)qhInProcess.Head();
 
-#ifdef DEBUG
-//    ddprintf(("WAVESTREAM::StartStream"));
-#endif
-
-    if(ulStreamState == STREAM_STREAMING) 
+    if(ulStreamState == STREAM_STREAMING)
     {
         ddprintf(("StartStream: already playing!!"));
@@ -537 +509 @@
     // 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) 
+    if(pahw->ConfigDev(StreamId, &_configinfo, (pTemp) ? pTemp->ulBuffsz : 0) == FALSE)
     {
         ddprintf(("StartStream: ConfigDev failed!!"));
         return ERROR_INSUFF_BUFFER;
-//        goto fail;
+                //goto fail;
     }
     // prepare wave device for playback/recording
-    if(pahw->Prepare(StreamId) == FALSE) 
+    if(pahw->Prepare(StreamId) == FALSE)
     {
         ddprintf(("StartStream: Prepare failed!!"));
@@ -551 +523 @@
 
     _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);
+    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 
-    {
+//      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);
 
-        if(pahw->Start(StreamId) != TRUE) 
-       {
+                if(pahw->Start(StreamId) != TRUE)
+                {
             dprintf(("pahw->Start failed!!"));
             goto fail;
         }
     }
-//    ddprintf(("WAVESTREAM::StartStream %lx End", StreamId));
     return NO_ERROR;
 
@@ -602 +575 @@
 
     ulStreamState = STREAM_STOPPED;
-//    ddprintf(("WAVESTREAM::StopStream %lx", StreamId));
+        //ddprintf(("WAVESTREAM::StopStream %lx", StreamId));
+
     ReturnBuffers();
     pControl->ulTime = GetCurrentTime();
@@ -610 +584 @@
     // DDCMD_ENABLE_EVENT the event time will get screwed up. rjj
     _ulBytesProcessed = 0;
+        _ulBytesWritten = 0;
     return NO_ERROR;
 }
@@ -616 +591 @@
 ULONG  WAVESTREAM::PauseStream(PCONTROL_PARM pControl)
 {
-    ULONG endpos;
-
-    pahw->GetPosition(StreamId, &_configinfo, &endpos);
+    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);
 
+        /* DAZ test code begin */
+    if (pahw->GetPosition(StreamId, &_configinfo, &ulEndPos2) == FALSE) ulEndPos2 = 0;
+        if (ulEndPos2 != ulEndPos) {
+            ddprintf(("WAVESTREAM::PauseStream %lx!=%lx", ulEndPos, ulEndPos2));
+                if (ulEndPos2) ulEndPos = ulEndPos2;
+        }
+        /* DAZ test code end */
+
     ulStreamState = STREAM_PAUSED;
 
     ddprintf(("WAVESTREAM::PauseStream %lx", StreamId));
 
-    _vRealignPausedBuffers(endpos);
-
-    _ulBytesProcessed = endpos;
+    _ulBytesProcessed = ulEndPos;
+
+    _vRealignPausedBuffers(ulEndPos);
+
     pControl->ulTime = GetCurrentTime();
+
     _ulBytesProcessed = 0;
+        _ulBytesWritten = 0;
+
     return NO_ERROR;
 }
@@ -639 +632 @@
 {
 #ifdef DEBUG
-    dprintf(("WAVESTREAM::ResumeStream %lx", StreamId));
+    //dprintf(("WAVESTREAM::ResumeStream %lx", StreamId));
 #endif
     return StartStream();
@@ -647 +640 @@
 BOOL WAVESTREAM::SetProperty(int type, ULONG value, ULONG reserved)
 {
-#ifdef DEBUG
-//    dprintf(("WAVESTREAM::SetProperty"));
-#endif
-
     switch(type) {
     case PROPERTY_VOLUME:
@@ -677 +666 @@
 ULONG WAVESTREAM::GetProperty(int type)
 {
-#ifdef DEBUG
-//    dprintf(("WAVESTREAM::GetProperty"));
-#endif
     switch(type) {
     case PROPERTY_FREQUENCY:
@@ -699 +685 @@
    STREAM(streamtype, filesysnum, mixerStreamId)
 {
-#ifdef DEBUG
-    dprintf(("WS::WS:S"));
-#endif
     // get the pointer to the hardware object
     pahw = (WAVEAUDIO*)GetHardwareDevice(streamtype);
@@ -710 +693 @@
     _configinfo.ulNumChannels   = pinit->sChannels;
     _configinfo.ulDataType      = pinit->sMode;
+    _ulBytesWritten             = 0;
     _ulBytesProcessed           = 0;
     _ulTimeBase                 = 0;
-    //_ulUnderrunBase             = 0;
     ulSavedInputGain            = 0;
 
@@ -746 +729 @@
     pinit->ulFlags |= pahw->QueryDataFlags(pinit->ulOperation, pinit->sMode, pinit->lBitsPerSRate);
 
-    //fUnderrun   = FALSE;
     StreamId    = 0;
 
@@ -755 +737 @@
     }
 
-//    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));
+        //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));
 }
 //******************************************************************************
@@ -761 +743 @@
 WAVESTREAM::~WAVESTREAM()
 {
-//    dprintf(("WAVESTREAM stream %x dtor %lx", hstream, StreamId));
+        //dprintf(("WAVESTREAM stream %x dtor %lx", hstream, StreamId));
     if(_configinfo.pConversionBuffer) {
         if(DevHelp_VMFree(_configinfo.pConversionBuffer) != 0) {