Changeset 88008 in vbox for trunk/src/VBox/Devices

Timestamp:

Mar 8, 2021 12:31:30 PM (4 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

143136

Message:

Audio: Moved the PCM property helpers closer together. bugref:9890

File:

• trunk/src/VBox/Devices/Audio/DrvAudioCommon.cpp (modified) (4 diffs)

trunk/src/VBox/Devices/Audio/DrvAudioCommon.cpp

@@ -113 +113 @@
             case 32: return PDMAUDIOFMT_U32;
             default: AssertMsgFailedReturn(("Bogus audio bits %RU8\n", cBits), PDMAUDIOFMT_INVALID);
-        }
-    }
-}
-
-/**
- * Clears a sample buffer by the given amount of audio frames with silence (according to the format
- * given by the PCM properties).
- *
- * @param   pPCMProps               PCM properties to use for the buffer to clear.
- * @param   pvBuf                   Buffer to clear.
- * @param   cbBuf                   Size (in bytes) of the buffer.
- * @param   cFrames                 Number of audio frames to clear in the buffer.
- */
-void DrvAudioHlpClearBuf(PCPDMAUDIOPCMPROPS pPCMProps, void *pvBuf, size_t cbBuf, uint32_t cFrames)
-{
-    /*
-     * Validate input
-     */
-    AssertPtrReturnVoid(pPCMProps);
-    Assert(pPCMProps->cbSample);
-    if (!cbBuf || !cFrames)
-        return;
-    AssertPtrReturnVoid(pvBuf);
-
-    Assert(pPCMProps->fSwapEndian == false); /** @todo Swapping Endianness is not supported yet. */
-
-    /*
-     * Decide how much needs clearing.
-     */
-    size_t cbToClear = DrvAudioHlpFramesToBytes(pPCMProps, cFrames);
-    AssertStmt(cbToClear <= cbBuf, cbToClear = cbBuf);
-
-    Log2Func(("pPCMProps=%p, pvBuf=%p, cFrames=%RU32, fSigned=%RTbool, cBytes=%RU8\n",
-              pPCMProps, pvBuf, cFrames, pPCMProps->fSigned, pPCMProps->cbSample));
-
-    /*
-     * Do the job.
-     */
-    if (pPCMProps->fSigned)
-        RT_BZERO(pvBuf, cbToClear);
-    else /* Unsigned formats. */
-    {
-        switch (pPCMProps->cbSample)
-        {
-            case 1: /* 8 bit */
-                memset(pvBuf, 0x80, cbToClear);
-                break;
-
-            case 2: /* 16 bit */
-            {
-                uint16_t *pu16Dst = (uint16_t *)pvBuf;
-                size_t    cLeft   = cbToClear / sizeof(uint16_t);
-                while (cLeft-- > 0)
-                    *pu16Dst++ = 0x80;
-                break;
-            }
-
-            /** @todo Add 24 bit? */
-
-            case 4: /* 32 bit */
-                ASMMemFill32(pvBuf, cbToClear & ~(size_t)3, 0x80);
-                break;
-
-            default:
-                AssertMsgFailed(("Invalid bytes per sample: %RU8\n", pPCMProps->cbSample));
         }
     }
@@ -800 +735 @@
     AssertMsgFailed(("Invalid audio format '%s'\n", pszFmt));
     return PDMAUDIOFMT_INVALID;
+}
+
+/**
+ * Initializes a stream configuration with its default values.
+ *
+ * @param   pCfg                Stream configuration to initialize.
+ */
+void DrvAudioHlpStreamCfgInit(PPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturnVoid(pCfg);
+
+    RT_ZERO(*pCfg);
+
+    pCfg->Backend.cFramesPreBuffering = UINT32_MAX; /* Explicitly set to "undefined". */
+}
+
+/**
+ * Checks whether a given stream configuration is valid or not.
+ *
+ * Returns @c true if configuration is valid, @c false if not.
+ * @param   pCfg                Stream configuration to check.
+ */
+bool DrvAudioHlpStreamCfgIsValid(PCPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturn(pCfg, false);
+
+    bool fValid = (   pCfg->enmDir == PDMAUDIODIR_IN
+                   || pCfg->enmDir == PDMAUDIODIR_OUT);
+
+    fValid &= (   pCfg->enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED
+               || pCfg->enmLayout == PDMAUDIOSTREAMLAYOUT_RAW);
+
+    if (fValid)
+        fValid = DrvAudioHlpPCMPropsAreValid(&pCfg->Props);
+
+    return fValid;
+}
+
+/**
+ * Frees an allocated audio stream configuration.
+ *
+ * @param   pCfg                Audio stream configuration to free.
+ */
+void DrvAudioHlpStreamCfgFree(PPDMAUDIOSTREAMCFG pCfg)
+{
+    if (pCfg)
+    {
+        RTMemFree(pCfg);
+        pCfg = NULL;
+    }
+}
+
+/**
+ * Copies a source stream configuration to a destination stream configuration.
+ *
+ * @returns IPRT status code.
+ * @param   pDstCfg             Destination stream configuration to copy source to.
+ * @param   pSrcCfg             Source stream configuration to copy to destination.
+ */
+int DrvAudioHlpStreamCfgCopy(PPDMAUDIOSTREAMCFG pDstCfg, PCPDMAUDIOSTREAMCFG pSrcCfg)
+{
+    AssertPtrReturn(pDstCfg, VERR_INVALID_POINTER);
+    AssertPtrReturn(pSrcCfg, VERR_INVALID_POINTER);
+
+#ifdef VBOX_STRICT
+    if (!DrvAudioHlpStreamCfgIsValid(pSrcCfg))
+    {
+        AssertMsgFailed(("Stream config '%s' (%p) is invalid\n", pSrcCfg->szName, pSrcCfg));
+        return VERR_INVALID_PARAMETER;
+    }
+#endif
+
+    memcpy(pDstCfg, pSrcCfg, sizeof(PDMAUDIOSTREAMCFG));
+
+    return VINF_SUCCESS;
+}
+
+/**
+ * Duplicates an audio stream configuration.
+ * Must be free'd with DrvAudioHlpStreamCfgFree().
+ *
+ * @return  Duplicates audio stream configuration on success, or NULL on failure.
+ * @param   pCfg                    Audio stream configuration to duplicate.
+ */
+PPDMAUDIOSTREAMCFG DrvAudioHlpStreamCfgDup(PCPDMAUDIOSTREAMCFG pCfg)
+{
+    AssertPtrReturn(pCfg, NULL);
+
+#ifdef VBOX_STRICT
+    if (!DrvAudioHlpStreamCfgIsValid(pCfg))
+    {
+        AssertMsgFailed(("Stream config '%s' (%p) is invalid\n", pCfg->szName, pCfg));
+        return NULL;
+    }
+#endif
+
+    PPDMAUDIOSTREAMCFG pDst = (PPDMAUDIOSTREAMCFG)RTMemAllocZ(sizeof(PDMAUDIOSTREAMCFG));
+    if (!pDst)
+        return NULL;
+
+    int rc2 = DrvAudioHlpStreamCfgCopy(pDst, pCfg);
+    if (RT_FAILURE(rc2))
+    {
+        DrvAudioHlpStreamCfgFree(pDst);
+        pDst = NULL;
+    }
+
+    AssertPtr(pDst);
+    return pDst;
+}
+
+/**
+ * Prints an audio stream configuration to the debug log.
+ *
+ * @param   pCfg                Stream configuration to log.
+ */
+void DrvAudioHlpStreamCfgPrint(PCPDMAUDIOSTREAMCFG pCfg)
+{
+    if (!pCfg)
+        return;
+
+    LogFunc(("szName=%s, enmDir=%RU32 (uHz=%RU32, cBits=%RU8%s, cChannels=%RU8)\n",
+             pCfg->szName, pCfg->enmDir,
+             pCfg->Props.uHz, pCfg->Props.cbSample * 8, pCfg->Props.fSigned ? "S" : "U", pCfg->Props.cChannels));
+}
+
+/**
+ * Converts a stream command to a string.
+ *
+ * @returns Stringified stream command, or "Unknown", if not found.
+ * @param   enmCmd              Stream command to convert.
+ */
+const char *DrvAudioHlpStreamCmdToStr(PDMAUDIOSTREAMCMD enmCmd)
+{
+    switch (enmCmd)
+    {
+        case PDMAUDIOSTREAMCMD_INVALID: return "Invalid";
+        case PDMAUDIOSTREAMCMD_UNKNOWN: return "Unknown";
+        case PDMAUDIOSTREAMCMD_ENABLE:  return "Enable";
+        case PDMAUDIOSTREAMCMD_DISABLE: return "Disable";
+        case PDMAUDIOSTREAMCMD_PAUSE:   return "Pause";
+        case PDMAUDIOSTREAMCMD_RESUME:  return "Resume";
+        case PDMAUDIOSTREAMCMD_DRAIN:   return "Drain";
+        case PDMAUDIOSTREAMCMD_DROP:    return "Drop";
+        case PDMAUDIOSTREAMCMD_32BIT_HACK:
+            break;
+    }
+    AssertMsgFailed(("Invalid stream command %d\n", enmCmd));
+    return "Unknown";
+}
+
+/**
+ * Returns @c true if the given stream status indicates a can-be-read-from stream,
+ * @c false if not.
+ *
+ * @returns @c true if ready to be read from, @c if not.
+ * @param   fStatus     Stream status to evaluate, PDMAUDIOSTREAMSTS_FLAGS_XXX.
+ */
+bool DrvAudioHlpStreamStatusCanRead(PDMAUDIOSTREAMSTS fStatus)
+{
+    AssertReturn(fStatus & PDMAUDIOSTREAMSTS_VALID_MASK, false);
+
+    return      fStatus & PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED
+           &&   fStatus & PDMAUDIOSTREAMSTS_FLAGS_ENABLED
+           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PAUSED)
+           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PENDING_REINIT);
+}
+
+/**
+ * Returns @c true if the given stream status indicates a can-be-written-to stream,
+ * @c false if not.
+ *
+ * @returns @c true if ready to be written to, @c if not.
+ * @param   fStatus     Stream status to evaluate, PDMAUDIOSTREAMSTS_FLAGS_XXX.
+ */
+bool DrvAudioHlpStreamStatusCanWrite(PDMAUDIOSTREAMSTS fStatus)
+{
+    AssertReturn(fStatus & PDMAUDIOSTREAMSTS_VALID_MASK, false);
+
+    return      fStatus & PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED
+           &&   fStatus & PDMAUDIOSTREAMSTS_FLAGS_ENABLED
+           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PAUSED)
+           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PENDING_DISABLE)
+           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PENDING_REINIT);
+}
+
+/**
+ * Returns @c true if the given stream status indicates a ready-to-operate stream,
+ * @c false if not.
+ *
+ * @returns @c true if ready to operate, @c if not.
+ * @param   fStatus Stream status to evaluate.
+ */
+bool DrvAudioHlpStreamStatusIsReady(PDMAUDIOSTREAMSTS fStatus)
+{
+    AssertReturn(fStatus & PDMAUDIOSTREAMSTS_VALID_MASK, false);
+
+    return      fStatus & PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED
+           &&   fStatus & PDMAUDIOSTREAMSTS_FLAGS_ENABLED
+           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PENDING_REINIT);
+}
+
+/**
+ * Calculates the audio bit rate of the given bits per sample, the Hz and the number
+ * of audio channels.
+ *
+ * Divide the result by 8 to get the byte rate.
+ *
+ * @returns Bitrate.
+ * @param   cBits               Number of bits per sample.
+ * @param   uHz                 Hz (Hertz) rate.
+ * @param   cChannels           Number of audio channels.
+ */
+uint32_t DrvAudioHlpCalcBitrate(uint8_t cBits, uint32_t uHz, uint8_t cChannels)
+{
+    return cBits * uHz * cChannels;
+}
+
+
+/*********************************************************************************************************************************
+*   PCM Property Helpers                                                                                                         *
+*********************************************************************************************************************************/
+
+/**
+ * Gets the bitrate.
+ *
+ * Divide the result by 8 to get the byte rate.
+ *
+ * @returns Bit rate.
+ * @param   pProps              PCM properties to calculate bitrate for.
+ */
+uint32_t DrvAudioHlpGetBitrate(PCPDMAUDIOPCMPROPS pProps)
+{
+    return DrvAudioHlpCalcBitrate(pProps->cbSample * 8, pProps->uHz, pProps->cChannels);
+}
+
+/**
+ * Rounds down the given byte amount to the nearest frame boundrary.
+ *
+ * @returns Rounded byte amount.
+ * @param   pProps      PCM properties to use.
+ * @param   cb          The size (in bytes) to round.
+ */
+uint32_t DrvAudioHlpFloorBytesToFrame(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
+{
+    AssertPtrReturn(pProps, 0);
+    return PDMAUDIOPCMPROPS_F2B(pProps, PDMAUDIOPCMPROPS_B2F(pProps, cb));
+}
+
+/**
+ * Checks if the given size is aligned on a frame boundrary.
+ *
+ * @returns @c true if properly aligned, @c false if not.
+ * @param   pProps      PCM properties to use.
+ * @param   cb          The size (in bytes) to check.
+ */
+bool DrvAudioHlpIsBytesAligned(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
+{
+    AssertPtrReturn(pProps, false);
+    uint32_t const cbFrame = PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */);
+    AssertReturn(cbFrame, false);
+    return cb % cbFrame == 0;
+}
+
+/**
+ * Returns the bytes per second for given PCM properties.
+ *
+ * @returns Bytes per second.
+ * @param   pProps              PCM properties to retrieve size for.
+ */
+DECLINLINE(uint64_t) drvAudioHlpBytesPerSec(PCPDMAUDIOPCMPROPS pProps)
+{
+    return PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */) * pProps->uHz;
+}
+
+/**
+ * Converts bytes to frames (rounding down of course).
+ *
+ * @returns Number of frames.
+ * @param   pProps      PCM properties to use.
+ * @param   cb          The number of bytes to convert.
+ */
+uint32_t DrvAudioHlpBytesToFrames(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
+{
+    AssertPtrReturn(pProps, 0);
+    return PDMAUDIOPCMPROPS_B2F(pProps, cb);
+}
+
+/**
+ * Converts bytes to milliseconds.
+ *
+ * @return  Number milliseconds @a cb takes to play or record.
+ * @param   pProps      PCM properties to use.
+ * @param   cb          The number of bytes to convert.
+ *
+ * @note    Rounds up the result.
+ */
+uint64_t DrvAudioHlpBytesToMilli(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
+{
+    AssertPtrReturn(pProps, 0);
+
+    /* Check parameters to prevent division by chainsaw: */
+    uint32_t const uHz = pProps->uHz;
+    if (uHz)
+    {
+        const unsigned cbFrame = PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */);
+        if (cbFrame)
+        {
+            /* Round cb up to closest frame size: */
+            cb = (cb + cbFrame - 1) / cbFrame;
+
+            /* Convert to milliseconds. */
+            return (cb * (uint64_t)RT_MS_1SEC + uHz - 1) / uHz;
+        }
+    }
+    return 0;
+}
+
+/**
+ * Converts bytes to microseconds.
+ *
+ * @return  Number microseconds @a cb takes to play or record.
+ * @param   pProps      PCM properties to use.
+ * @param   cb          The number of bytes to convert.
+ *
+ * @note    Rounds up the result.
+ */
+uint64_t DrvAudioHlpBytesToMicro(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
+{
+    AssertPtrReturn(pProps, 0);
+
+    /* Check parameters to prevent division by chainsaw: */
+    uint32_t const uHz = pProps->uHz;
+    if (uHz)
+    {
+        const unsigned cbFrame = PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */);
+        if (cbFrame)
+        {
+            /* Round cb up to closest frame size: */
+            cb = (cb + cbFrame - 1) / cbFrame;
+
+            /* Convert to microseconds. */
+            return (cb * (uint64_t)RT_US_1SEC + uHz - 1) / uHz;
+        }
+    }
+    return 0;
+}
+
+/**
+ * Converts bytes to nanoseconds.
+ *
+ * @return  Number nanoseconds @a cb takes to play or record.
+ * @param   pProps      PCM properties to use.
+ * @param   cb          The number of bytes to convert.
+ *
+ * @note    Rounds up the result.
+ */
+uint64_t DrvAudioHlpBytesToNano(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
+{
+    AssertPtrReturn(pProps, 0);
+
+    /* Check parameters to prevent division by chainsaw: */
+    uint32_t const uHz = pProps->uHz;
+    if (uHz)
+    {
+        const unsigned cbFrame = PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */);
+        if (cbFrame)
+        {
+            /* Round cb up to closest frame size: */
+            cb = (cb + cbFrame - 1) / cbFrame;
+
+            /* Convert to nanoseconds. */
+            return (cb * (uint64_t)RT_NS_1SEC + uHz - 1) / uHz;
+        }
+    }
+    return 0;
+}
+
+/**
+ * Converts frames to bytes.
+ *
+ * @return Number of bytes.
+ * @param   pProps      The PCM properties to use.
+ * @param   cFrames     Number of audio frames to convert.
+ */
+uint32_t DrvAudioHlpFramesToBytes(PCPDMAUDIOPCMPROPS pProps, uint32_t cFrames)
+{
+    AssertPtrReturn(pProps, 0);
+    return PDMAUDIOPCMPROPS_F2B(pProps, cFrames);
+}
+
+/**
+ * Converts frames to milliseconds.
+ *
+ * @returns milliseconds.
+ * @param   pProps      The PCM properties to use.
+ * @param   cFrames     Number of audio frames to convert.
+ * @note    No rounding here, result is floored.
+ */
+uint64_t DrvAudioHlpFramesToMilli(PCPDMAUDIOPCMPROPS pProps, uint32_t cFrames)
+{
+    AssertPtrReturn(pProps, 0);
+
+    /* Check input to prevent division by chainsaw: */
+    uint32_t const uHz = pProps->uHz;
+    if (uHz)
+        return ASMMultU32ByU32DivByU32(cFrames, RT_MS_1SEC, uHz);
+    return 0;
+}
+
+/**
+ * Converts frames to nanoseconds.
+ *
+ * @returns Nanoseconds.
+ * @param   pProps      The PCM properties to use.
+ * @param   cFrames     Number of audio frames to convert.
+ * @note    No rounding here, result is floored.
+ */
+uint64_t DrvAudioHlpFramesToNano(PCPDMAUDIOPCMPROPS pProps, uint32_t cFrames)
+{
+    AssertPtrReturn(pProps, 0);
+
+    /* Check input to prevent division by chainsaw: */
+    uint32_t const uHz = pProps->uHz;
+    if (uHz)
+        return ASMMultU32ByU32DivByU32(cFrames, RT_NS_1SEC, uHz);
+    return 0;
+}
+
+/**
+ * Converts milliseconds to frames.
+ *
+ * @returns Number of frames
+ * @param   pProps      The PCM properties to use.
+ * @param   cMs         The number of milliseconds to convert.
+ *
+ * @note    The result is rounded rather than floored (hysterical raisins).
+ */
+uint32_t DrvAudioHlpMilliToFrames(PCPDMAUDIOPCMPROPS pProps, uint64_t cMs)
+{
+    AssertPtrReturn(pProps, 0);
+
+    uint32_t const uHz = pProps->uHz;
+    uint32_t cFrames;
+    if (cMs < RT_MS_1SEC)
+        cFrames = 0;
+    else
+    {
+        cFrames = cMs / RT_MS_1SEC * uHz;
+        cMs %= RT_MS_1SEC;
+    }
+    cFrames += (ASMMult2xU32RetU64(uHz, (uint32_t)cMs) + RT_MS_1SEC - 1) / RT_MS_1SEC;
+    return cFrames;
+}
+
+/**
+ * Converts milliseconds to bytes.
+ *
+ * @returns Number of bytes (frame aligned).
+ * @param   pProps      The PCM properties to use.
+ * @param   cMs         The number of milliseconds to convert.
+ *
+ * @note    The result is rounded rather than floored (hysterical raisins).
+ */
+uint32_t DrvAudioHlpMilliToBytes(PCPDMAUDIOPCMPROPS pProps, uint64_t cMs)
+{
+    return PDMAUDIOPCMPROPS_F2B(pProps, DrvAudioHlpMilliToFrames(pProps, cMs));
+}
+
+/**
+ * Converts nanoseconds to frames.
+ *
+ * @returns Number of frames
+ * @param   pProps      The PCM properties to use.
+ * @param   cNs         The number of nanoseconds to convert.
+ *
+ * @note    The result is rounded rather than floored (hysterical raisins).
+ */
+uint32_t DrvAudioHlpNanoToFrames(PCPDMAUDIOPCMPROPS pProps, uint64_t cNs)
+{
+    AssertPtrReturn(pProps, 0);
+
+    uint32_t const uHz = pProps->uHz;
+    uint32_t cFrames;
+    if (cNs < RT_NS_1SEC)
+        cFrames = 0;
+    else
+    {
+        cFrames = cNs / RT_NS_1SEC * uHz;
+        cNs %= RT_NS_1SEC;
+    }
+    cFrames += (ASMMult2xU32RetU64(uHz, (uint32_t)cNs) + RT_NS_1SEC - 1) / RT_NS_1SEC;
+    return cFrames;
+}
+
+/**
+ * Converts nanoseconds to bytes.
+ *
+ * @returns Number of bytes (frame aligned).
+ * @param   pProps      The PCM properties to use.
+ * @param   cNs         The number of nanoseconds to convert.
+ *
+ * @note    The result is rounded rather than floored (hysterical raisins).
+ */
+uint32_t DrvAudioHlpNanoToBytes(PCPDMAUDIOPCMPROPS pProps, uint64_t cNs)
+{
+    return PDMAUDIOPCMPROPS_F2B(pProps, DrvAudioHlpNanoToFrames(pProps, cNs));
+}
+
+/**
+ * Clears a sample buffer by the given amount of audio frames with silence (according to the format
+ * given by the PCM properties).
+ *
+ * @param   pPCMProps               PCM properties to use for the buffer to clear.
+ * @param   pvBuf                   Buffer to clear.
+ * @param   cbBuf                   Size (in bytes) of the buffer.
+ * @param   cFrames                 Number of audio frames to clear in the buffer.
+ */
+void DrvAudioHlpClearBuf(PCPDMAUDIOPCMPROPS pPCMProps, void *pvBuf, size_t cbBuf, uint32_t cFrames)
+{
+    /*
+     * Validate input
+     */
+    AssertPtrReturnVoid(pPCMProps);
+    Assert(pPCMProps->cbSample);
+    if (!cbBuf || !cFrames)
+        return;
+    AssertPtrReturnVoid(pvBuf);
+
+    Assert(pPCMProps->fSwapEndian == false); /** @todo Swapping Endianness is not supported yet. */
+
+    /*
+     * Decide how much needs clearing.
+     */
+    size_t cbToClear = DrvAudioHlpFramesToBytes(pPCMProps, cFrames);
+    AssertStmt(cbToClear <= cbBuf, cbToClear = cbBuf);
+
+    Log2Func(("pPCMProps=%p, pvBuf=%p, cFrames=%RU32, fSigned=%RTbool, cBytes=%RU8\n",
+              pPCMProps, pvBuf, cFrames, pPCMProps->fSigned, pPCMProps->cbSample));
+
+    /*
+     * Do the job.
+     */
+    if (pPCMProps->fSigned)
+        RT_BZERO(pvBuf, cbToClear);
+    else /* Unsigned formats. */
+    {
+        switch (pPCMProps->cbSample)
+        {
+            case 1: /* 8 bit */
+                memset(pvBuf, 0x80, cbToClear);
+                break;
+
+            case 2: /* 16 bit */
+            {
+                uint16_t *pu16Dst = (uint16_t *)pvBuf;
+                size_t    cLeft   = cbToClear / sizeof(uint16_t);
+                while (cLeft-- > 0)
+                    *pu16Dst++ = 0x80;
+                break;
+            }
+
+            /** @todo Add 24 bit? */
+
+            case 4: /* 32 bit */
+                ASMMemFill32(pvBuf, cbToClear & ~(size_t)3, 0x80);
+                break;
+
+            default:
+                AssertMsgFailed(("Invalid bytes per sample: %RU8\n", pPCMProps->cbSample));
+        }
+    }
 }
 
@@ -917 +1424 @@
  * @param   pProps              PCM properties to convert.
  * @param   pCfg                Stream configuration to store result into.
+ * @todo r=bird: Rename to DrvAudioHlpStreamCfgInitFromPCMProps.
  */
 int DrvAudioHlpPCMPropsToStreamCfg(PCPDMAUDIOPCMPROPS pProps, PPDMAUDIOSTREAMCFG pCfg)
@@ -929 +1437 @@
 }
 
-/**
- * Initializes a stream configuration with its default values.
- *
- * @param   pCfg                Stream configuration to initialize.
- */
-void DrvAudioHlpStreamCfgInit(PPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturnVoid(pCfg);
-
-    RT_ZERO(*pCfg);
-
-    pCfg->Backend.cFramesPreBuffering = UINT32_MAX; /* Explicitly set to "undefined". */
-}
-
-/**
- * Checks whether a given stream configuration is valid or not.
- *
- * Returns @c true if configuration is valid, @c false if not.
- * @param   pCfg                Stream configuration to check.
- */
-bool DrvAudioHlpStreamCfgIsValid(PCPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pCfg, false);
-
-    bool fValid = (   pCfg->enmDir == PDMAUDIODIR_IN
-                   || pCfg->enmDir == PDMAUDIODIR_OUT);
-
-    fValid &= (   pCfg->enmLayout == PDMAUDIOSTREAMLAYOUT_NON_INTERLEAVED
-               || pCfg->enmLayout == PDMAUDIOSTREAMLAYOUT_RAW);
-
-    if (fValid)
-        fValid = DrvAudioHlpPCMPropsAreValid(&pCfg->Props);
-
-    return fValid;
-}
-
-/**
- * Frees an allocated audio stream configuration.
- *
- * @param   pCfg                Audio stream configuration to free.
- */
-void DrvAudioHlpStreamCfgFree(PPDMAUDIOSTREAMCFG pCfg)
-{
-    if (pCfg)
-    {
-        RTMemFree(pCfg);
-        pCfg = NULL;
-    }
-}
-
-/**
- * Copies a source stream configuration to a destination stream configuration.
- *
- * @returns IPRT status code.
- * @param   pDstCfg             Destination stream configuration to copy source to.
- * @param   pSrcCfg             Source stream configuration to copy to destination.
- */
-int DrvAudioHlpStreamCfgCopy(PPDMAUDIOSTREAMCFG pDstCfg, PCPDMAUDIOSTREAMCFG pSrcCfg)
-{
-    AssertPtrReturn(pDstCfg, VERR_INVALID_POINTER);
-    AssertPtrReturn(pSrcCfg, VERR_INVALID_POINTER);
-
-#ifdef VBOX_STRICT
-    if (!DrvAudioHlpStreamCfgIsValid(pSrcCfg))
-    {
-        AssertMsgFailed(("Stream config '%s' (%p) is invalid\n", pSrcCfg->szName, pSrcCfg));
-        return VERR_INVALID_PARAMETER;
-    }
-#endif
-
-    memcpy(pDstCfg, pSrcCfg, sizeof(PDMAUDIOSTREAMCFG));
-
-    return VINF_SUCCESS;
-}
-
-/**
- * Duplicates an audio stream configuration.
- * Must be free'd with DrvAudioHlpStreamCfgFree().
- *
- * @return  Duplicates audio stream configuration on success, or NULL on failure.
- * @param   pCfg                    Audio stream configuration to duplicate.
- */
-PPDMAUDIOSTREAMCFG DrvAudioHlpStreamCfgDup(PCPDMAUDIOSTREAMCFG pCfg)
-{
-    AssertPtrReturn(pCfg, NULL);
-
-#ifdef VBOX_STRICT
-    if (!DrvAudioHlpStreamCfgIsValid(pCfg))
-    {
-        AssertMsgFailed(("Stream config '%s' (%p) is invalid\n", pCfg->szName, pCfg));
-        return NULL;
-    }
-#endif
-
-    PPDMAUDIOSTREAMCFG pDst = (PPDMAUDIOSTREAMCFG)RTMemAllocZ(sizeof(PDMAUDIOSTREAMCFG));
-    if (!pDst)
-        return NULL;
-
-    int rc2 = DrvAudioHlpStreamCfgCopy(pDst, pCfg);
-    if (RT_FAILURE(rc2))
-    {
-        DrvAudioHlpStreamCfgFree(pDst);
-        pDst = NULL;
-    }
-
-    AssertPtr(pDst);
-    return pDst;
-}
-
-/**
- * Prints an audio stream configuration to the debug log.
- *
- * @param   pCfg                Stream configuration to log.
- */
-void DrvAudioHlpStreamCfgPrint(PCPDMAUDIOSTREAMCFG pCfg)
-{
-    if (!pCfg)
-        return;
-
-    LogFunc(("szName=%s, enmDir=%RU32 (uHz=%RU32, cBits=%RU8%s, cChannels=%RU8)\n",
-             pCfg->szName, pCfg->enmDir,
-             pCfg->Props.uHz, pCfg->Props.cbSample * 8, pCfg->Props.fSigned ? "S" : "U", pCfg->Props.cChannels));
-}
-
-/**
- * Converts a stream command to a string.
- *
- * @returns Stringified stream command, or "Unknown", if not found.
- * @param   enmCmd              Stream command to convert.
- */
-const char *DrvAudioHlpStreamCmdToStr(PDMAUDIOSTREAMCMD enmCmd)
-{
-    switch (enmCmd)
-    {
-        case PDMAUDIOSTREAMCMD_INVALID: return "Invalid";
-        case PDMAUDIOSTREAMCMD_UNKNOWN: return "Unknown";
-        case PDMAUDIOSTREAMCMD_ENABLE:  return "Enable";
-        case PDMAUDIOSTREAMCMD_DISABLE: return "Disable";
-        case PDMAUDIOSTREAMCMD_PAUSE:   return "Pause";
-        case PDMAUDIOSTREAMCMD_RESUME:  return "Resume";
-        case PDMAUDIOSTREAMCMD_DRAIN:   return "Drain";
-        case PDMAUDIOSTREAMCMD_DROP:    return "Drop";
-        case PDMAUDIOSTREAMCMD_32BIT_HACK:
-            break;
-    }
-    AssertMsgFailed(("Invalid stream command %d\n", enmCmd));
-    return "Unknown";
-}
-
-/**
- * Returns @c true if the given stream status indicates a can-be-read-from stream,
- * @c false if not.
- *
- * @returns @c true if ready to be read from, @c if not.
- * @param   fStatus     Stream status to evaluate, PDMAUDIOSTREAMSTS_FLAGS_XXX.
- */
-bool DrvAudioHlpStreamStatusCanRead(PDMAUDIOSTREAMSTS fStatus)
-{
-    AssertReturn(fStatus & PDMAUDIOSTREAMSTS_VALID_MASK, false);
-
-    return      fStatus & PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED
-           &&   fStatus & PDMAUDIOSTREAMSTS_FLAGS_ENABLED
-           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PAUSED)
-           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PENDING_REINIT);
-}
-
-/**
- * Returns @c true if the given stream status indicates a can-be-written-to stream,
- * @c false if not.
- *
- * @returns @c true if ready to be written to, @c if not.
- * @param   fStatus     Stream status to evaluate, PDMAUDIOSTREAMSTS_FLAGS_XXX.
- */
-bool DrvAudioHlpStreamStatusCanWrite(PDMAUDIOSTREAMSTS fStatus)
-{
-    AssertReturn(fStatus & PDMAUDIOSTREAMSTS_VALID_MASK, false);
-
-    return      fStatus & PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED
-           &&   fStatus & PDMAUDIOSTREAMSTS_FLAGS_ENABLED
-           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PAUSED)
-           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PENDING_DISABLE)
-           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PENDING_REINIT);
-}
-
-/**
- * Returns @c true if the given stream status indicates a ready-to-operate stream,
- * @c false if not.
- *
- * @returns @c true if ready to operate, @c if not.
- * @param   fStatus Stream status to evaluate.
- */
-bool DrvAudioHlpStreamStatusIsReady(PDMAUDIOSTREAMSTS fStatus)
-{
-    AssertReturn(fStatus & PDMAUDIOSTREAMSTS_VALID_MASK, false);
-
-    return      fStatus & PDMAUDIOSTREAMSTS_FLAGS_INITIALIZED
-           &&   fStatus & PDMAUDIOSTREAMSTS_FLAGS_ENABLED
-           && !(fStatus & PDMAUDIOSTREAMSTS_FLAGS_PENDING_REINIT);
-}
-
-/**
- * Calculates the audio bit rate of the given bits per sample, the Hz and the number
- * of audio channels.
- *
- * Divide the result by 8 to get the byte rate.
- *
- * @returns Bitrate.
- * @param   cBits               Number of bits per sample.
- * @param   uHz                 Hz (Hertz) rate.
- * @param   cChannels           Number of audio channels.
- */
-uint32_t DrvAudioHlpCalcBitrate(uint8_t cBits, uint32_t uHz, uint8_t cChannels)
-{
-    return cBits * uHz * cChannels;
-}
-
-/**
- * Gets the bitrate.
- *
- * Divide the result by 8 to get the byte rate.
- *
- * @returns Bit rate.
- * @param   pProps              PCM properties to calculate bitrate for.
- */
-uint32_t DrvAudioHlpGetBitrate(PCPDMAUDIOPCMPROPS pProps)
-{
-    return DrvAudioHlpCalcBitrate(pProps->cbSample * 8, pProps->uHz, pProps->cChannels);
-}
-
-/**
- * Rounds down the given byte amount to the nearest frame boundrary.
- *
- * @returns Rounded byte amount.
- * @param   pProps      PCM properties to use.
- * @param   cb          The size (in bytes) to round.
- */
-uint32_t DrvAudioHlpFloorBytesToFrame(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
-{
-    AssertPtrReturn(pProps, 0);
-    return PDMAUDIOPCMPROPS_F2B(pProps, PDMAUDIOPCMPROPS_B2F(pProps, cb));
-}
-
-/**
- * Checks if the given size is aligned on a frame boundrary.
- *
- * @returns @c true if properly aligned, @c false if not.
- * @param   pProps      PCM properties to use.
- * @param   cb          The size (in bytes) to check.
- */
-bool DrvAudioHlpIsBytesAligned(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
-{
-    AssertPtrReturn(pProps, false);
-    uint32_t const cbFrame = PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */);
-    AssertReturn(cbFrame, false);
-    return cb % cbFrame == 0;
-}
-
-/**
- * Returns the bytes per second for given PCM properties.
- *
- * @returns Bytes per second.
- * @param   pProps              PCM properties to retrieve size for.
- */
-DECLINLINE(uint64_t) drvAudioHlpBytesPerSec(PCPDMAUDIOPCMPROPS pProps)
-{
-    return PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */) * pProps->uHz;
-}
-
-/**
- * Converts bytes to frames (rounding down of course).
- *
- * @returns Number of frames.
- * @param   pProps      PCM properties to use.
- * @param   cb          The number of bytes to convert.
- */
-uint32_t DrvAudioHlpBytesToFrames(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
-{
-    AssertPtrReturn(pProps, 0);
-    return PDMAUDIOPCMPROPS_B2F(pProps, cb);
-}
-
-/**
- * Converts bytes to milliseconds.
- *
- * @return  Number milliseconds @a cb takes to play or record.
- * @param   pProps      PCM properties to use.
- * @param   cb          The number of bytes to convert.
- *
- * @note    Rounds up the result.
- */
-uint64_t DrvAudioHlpBytesToMilli(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
-{
-    AssertPtrReturn(pProps, 0);
-
-    /* Check parameters to prevent division by chainsaw: */
-    uint32_t const uHz = pProps->uHz;
-    if (uHz)
-    {
-        const unsigned cbFrame = PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */);
-        if (cbFrame)
-        {
-            /* Round cb up to closest frame size: */
-            cb = (cb + cbFrame - 1) / cbFrame;
-
-            /* Convert to milliseconds. */
-            return (cb * (uint64_t)RT_MS_1SEC + uHz - 1) / uHz;
-        }
-    }
-    return 0;
-}
-
-/**
- * Converts bytes to microseconds.
- *
- * @return  Number microseconds @a cb takes to play or record.
- * @param   pProps      PCM properties to use.
- * @param   cb          The number of bytes to convert.
- *
- * @note    Rounds up the result.
- */
-uint64_t DrvAudioHlpBytesToMicro(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
-{
-    AssertPtrReturn(pProps, 0);
-
-    /* Check parameters to prevent division by chainsaw: */
-    uint32_t const uHz = pProps->uHz;
-    if (uHz)
-    {
-        const unsigned cbFrame = PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */);
-        if (cbFrame)
-        {
-            /* Round cb up to closest frame size: */
-            cb = (cb + cbFrame - 1) / cbFrame;
-
-            /* Convert to microseconds. */
-            return (cb * (uint64_t)RT_US_1SEC + uHz - 1) / uHz;
-        }
-    }
-    return 0;
-}
-
-/**
- * Converts bytes to nanoseconds.
- *
- * @return  Number nanoseconds @a cb takes to play or record.
- * @param   pProps      PCM properties to use.
- * @param   cb          The number of bytes to convert.
- *
- * @note    Rounds up the result.
- */
-uint64_t DrvAudioHlpBytesToNano(PCPDMAUDIOPCMPROPS pProps, uint32_t cb)
-{
-    AssertPtrReturn(pProps, 0);
-
-    /* Check parameters to prevent division by chainsaw: */
-    uint32_t const uHz = pProps->uHz;
-    if (uHz)
-    {
-        const unsigned cbFrame = PDMAUDIOPCMPROPS_F2B(pProps, 1 /* Frame */);
-        if (cbFrame)
-        {
-            /* Round cb up to closest frame size: */
-            cb = (cb + cbFrame - 1) / cbFrame;
-
-            /* Convert to nanoseconds. */
-            return (cb * (uint64_t)RT_NS_1SEC + uHz - 1) / uHz;
-        }
-    }
-    return 0;
-}
-
-/**
- * Converts frames to bytes.
- *
- * @return Number of bytes.
- * @param   pProps      The PCM properties to use.
- * @param   cFrames     Number of audio frames to convert.
- */
-uint32_t DrvAudioHlpFramesToBytes(PCPDMAUDIOPCMPROPS pProps, uint32_t cFrames)
-{
-    AssertPtrReturn(pProps, 0);
-    return PDMAUDIOPCMPROPS_F2B(pProps, cFrames);
-}
-
-/**
- * Converts frames to milliseconds.
- *
- * @returns milliseconds.
- * @param   pProps      The PCM properties to use.
- * @param   cFrames     Number of audio frames to convert.
- * @note    No rounding here, result is floored.
- */
-uint64_t DrvAudioHlpFramesToMilli(PCPDMAUDIOPCMPROPS pProps, uint32_t cFrames)
-{
-    AssertPtrReturn(pProps, 0);
-
-    /* Check input to prevent division by chainsaw: */
-    uint32_t const uHz = pProps->uHz;
-    if (uHz)
-        return ASMMultU32ByU32DivByU32(cFrames, RT_MS_1SEC, uHz);
-    return 0;
-}
-
-/**
- * Converts frames to nanoseconds.
- *
- * @returns Nanoseconds.
- * @param   pProps      The PCM properties to use.
- * @param   cFrames     Number of audio frames to convert.
- * @note    No rounding here, result is floored.
- */
-uint64_t DrvAudioHlpFramesToNano(PCPDMAUDIOPCMPROPS pProps, uint32_t cFrames)
-{
-    AssertPtrReturn(pProps, 0);
-
-    /* Check input to prevent division by chainsaw: */
-    uint32_t const uHz = pProps->uHz;
-    if (uHz)
-        return ASMMultU32ByU32DivByU32(cFrames, RT_NS_1SEC, uHz);
-    return 0;
-}
-
-/**
- * Converts milliseconds to frames.
- *
- * @returns Number of frames
- * @param   pProps      The PCM properties to use.
- * @param   cMs         The number of milliseconds to convert.
- *
- * @note    The result is rounded rather than floored (hysterical raisins).
- */
-uint32_t DrvAudioHlpMilliToFrames(PCPDMAUDIOPCMPROPS pProps, uint64_t cMs)
-{
-    AssertPtrReturn(pProps, 0);
-
-    uint32_t const uHz = pProps->uHz;
-    uint32_t cFrames;
-    if (cMs < RT_MS_1SEC)
-        cFrames = 0;
-    else
-    {
-        cFrames = cMs / RT_MS_1SEC * uHz;
-        cMs %= RT_MS_1SEC;
-    }
-    cFrames += (ASMMult2xU32RetU64(uHz, (uint32_t)cMs) + RT_MS_1SEC - 1) / RT_MS_1SEC;
-    return cFrames;
-}
-
-/**
- * Converts milliseconds to bytes.
- *
- * @returns Number of bytes (frame aligned).
- * @param   pProps      The PCM properties to use.
- * @param   cMs         The number of milliseconds to convert.
- *
- * @note    The result is rounded rather than floored (hysterical raisins).
- */
-uint32_t DrvAudioHlpMilliToBytes(PCPDMAUDIOPCMPROPS pProps, uint64_t cMs)
-{
-    return PDMAUDIOPCMPROPS_F2B(pProps, DrvAudioHlpMilliToFrames(pProps, cMs));
-}
-
-/**
- * Converts nanoseconds to frames.
- *
- * @returns Number of frames
- * @param   pProps      The PCM properties to use.
- * @param   cNs         The number of nanoseconds to convert.
- *
- * @note    The result is rounded rather than floored (hysterical raisins).
- */
-uint32_t DrvAudioHlpNanoToFrames(PCPDMAUDIOPCMPROPS pProps, uint64_t cNs)
-{
-    AssertPtrReturn(pProps, 0);
-
-    uint32_t const uHz = pProps->uHz;
-    uint32_t cFrames;
-    if (cNs < RT_NS_1SEC)
-        cFrames = 0;
-    else
-    {
-        cFrames = cNs / RT_NS_1SEC * uHz;
-        cNs %= RT_NS_1SEC;
-    }
-    cFrames += (ASMMult2xU32RetU64(uHz, (uint32_t)cNs) + RT_NS_1SEC - 1) / RT_NS_1SEC;
-    return cFrames;
-}
-
-/**
- * Converts nanoseconds to bytes.
- *
- * @returns Number of bytes (frame aligned).
- * @param   pProps      The PCM properties to use.
- * @param   cNs         The number of nanoseconds to convert.
- *
- * @note    The result is rounded rather than floored (hysterical raisins).
- */
-uint32_t DrvAudioHlpNanoToBytes(PCPDMAUDIOPCMPROPS pProps, uint64_t cNs)
-{
-    return PDMAUDIOPCMPROPS_F2B(pProps, DrvAudioHlpNanoToFrames(pProps, cNs));
-}
+
+/*********************************************************************************************************************************
+*   Audio File Helpers                                                                                                           *
+*********************************************************************************************************************************/
 
 /**