Changeset 88234 in vbox

Timestamp:

Mar 22, 2021 10:25:25 AM (4 years ago)

Author:

vboxsync

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

143430

Message:

Audio: Renamed DrvAudioCommon.* to AudioHlp.*, changing functions from DrvAudioHlp to AudioHlp. bugref:9890

Location:

trunk/src/VBox/Devices

Files:

• Audio/AudioHlp.cpp (moved) (moved from trunk/src/VBox/Devices/Audio/DrvAudioCommon.cpp ) (18 diffs)
• Audio/AudioHlp.h (moved) (moved from trunk/src/VBox/Devices/Audio/DrvAudioCommon.h ) (2 diffs)
• Audio/AudioMixer.cpp (modified) (7 diffs)
• Audio/DevHda.cpp (modified) (7 diffs)
• Audio/DevHdaStream.cpp (modified) (12 diffs)
• Audio/DevHdaStreamMap.cpp (modified) (2 diffs)
• Audio/DevIchAc97.cpp (modified) (12 diffs)
• Audio/DevSB16.cpp (modified) (3 diffs)
• Audio/DrvAudio.cpp (modified) (13 diffs)
• Audio/DrvHostAudioDebug.cpp (modified) (5 diffs)
• Audio/DrvHostAudioValidationKit.cpp (modified) (4 diffs)
• Audio/testcase/Makefile.kmk (modified) (1 diff)
• Audio/testcase/tstAudioMixBuffer.cpp (modified) (11 diffs)
• Makefile.kmk (modified) (1 diff)

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

@@ -43 +43 @@
 #include <stdlib.h>
 
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 #include "AudioMixBuffer.h"
 
@@ -149 +149 @@
  * @param   pszFmt              String to convert to an audio format.
  */
-PDMAUDIOFMT DrvAudioHlpStrToAudFmt(const char *pszFmt)
+PDMAUDIOFMT AudioHlpStrToAudFmt(const char *pszFmt)
 {
     AssertPtrReturn(pszFmt, PDMAUDIOFMT_INVALID);
@@ -173 +173 @@
  * Checks whether a given stream configuration is valid or not.
  *
- * @note    See notes on DrvAudioHlpPcmPropsAreValid().
+ * @note    See notes on AudioHlpPcmPropsAreValid().
  *
  * Returns @c true if configuration is valid, @c false if not.
  * @param   pCfg                Stream configuration to check.
  */
-bool DrvAudioHlpStreamCfgIsValid(PCPDMAUDIOSTREAMCFG pCfg)
+bool AudioHlpStreamCfgIsValid(PCPDMAUDIOSTREAMCFG pCfg)
 {
     AssertPtrReturn(pCfg, false);
@@ -191 +191 @@
 
     if (fValid)
-        fValid = DrvAudioHlpPcmPropsAreValid(&pCfg->Props);
+        fValid = AudioHlpPcmPropsAreValid(&pCfg->Props);
 
     return fValid;
@@ -207 +207 @@
  * @param   cChannels           Number of audio channels.
  */
-uint32_t DrvAudioHlpCalcBitrate(uint8_t cBits, uint32_t uHz, uint8_t cChannels)
+uint32_t AudioHlpCalcBitrate(uint8_t cBits, uint32_t uHz, uint8_t cChannels)
 {
     return cBits * uHz * cChannels;
@@ -225 +225 @@
  * @param   pProps      The PCM properties to check.
  */
-bool DrvAudioHlpPcmPropsAreValid(PCPDMAUDIOPCMPROPS pProps)
+bool AudioHlpPcmPropsAreValid(PCPDMAUDIOPCMPROPS pProps)
 {
     AssertPtrReturn(pProps, false);
@@ -285 +285 @@
  * @param   cbPath              Size (in bytes) of path to sanitize.
  */
-int DrvAudioHlpFileNameSanitize(char *pszPath, size_t cbPath)
+int AudioHlpFileNameSanitize(char *pszPath, size_t cbPath)
 {
     RT_NOREF(cbPath);
@@ -327 +327 @@
  * @param   fFlags              File naming flags, PDMAUDIOFILENAME_FLAGS_XXX.
  */
-int DrvAudioHlpFileNameGet(char *pszFile, size_t cchFile, const char *pszPath, const char *pszName,
-                           uint32_t uInstance, PDMAUDIOFILETYPE enmType, uint32_t fFlags)
+int AudioHlpFileNameGet(char *pszFile, size_t cchFile, const char *pszPath, const char *pszName,
+                        uint32_t uInstance, PDMAUDIOFILETYPE enmType, uint32_t fFlags)
 {
     AssertPtrReturn(pszFile, VERR_INVALID_POINTER);
@@ -383 +383 @@
             }
 
-            rc = DrvAudioHlpFileNameSanitize(szFileName, sizeof(szFileName));
+            rc = AudioHlpFileNameSanitize(szFileName, sizeof(szFileName));
             if (RT_FAILURE(rc))
                 break;
@@ -446 +446 @@
  * @param   fFlags              Audio file flags, PDMAUDIOFILE_FLAGS_XXX.
  * @param   ppFile              Where to store the created audio file handle.
- *                              Needs to be destroyed with DrvAudioHlpFileDestroy().
- */
-int DrvAudioHlpFileCreate(PDMAUDIOFILETYPE enmType, const char *pszFile, uint32_t fFlags, PPDMAUDIOFILE *ppFile)
+ *                              Needs to be destroyed with AudioHlpFileDestroy().
+ */
+int AudioHlpFileCreate(PDMAUDIOFILETYPE enmType, const char *pszFile, uint32_t fFlags, PPDMAUDIOFILE *ppFile)
 {
     AssertPtrReturn(pszFile, VERR_INVALID_POINTER);
@@ -496 +496 @@
  * @param   pFile               Audio file (object) to destroy.
  */
-void DrvAudioHlpFileDestroy(PPDMAUDIOFILE pFile)
+void AudioHlpFileDestroy(PPDMAUDIOFILE pFile)
 {
     if (!pFile)
         return;
 
-    DrvAudioHlpFileClose(pFile);
+    AudioHlpFileClose(pFile);
 
     RTMemFree(pFile);
@@ -516 +516 @@
  * @param   pProps              PCM properties to use.
  */
-int DrvAudioHlpFileOpen(PPDMAUDIOFILE pFile, uint32_t fOpen, PCPDMAUDIOPCMPROPS pProps)
+int AudioHlpFileOpen(PPDMAUDIOFILE pFile, uint32_t fOpen, PCPDMAUDIOPCMPROPS pProps)
 {
     AssertPtrReturn(pFile,   VERR_INVALID_POINTER);
@@ -600 +600 @@
  * @param   pFile               Audio file handle to close.
  */
-int DrvAudioHlpFileClose(PPDMAUDIOFILE pFile)
+int AudioHlpFileClose(PPDMAUDIOFILE pFile)
 {
     if (!pFile)
         return VINF_SUCCESS;
 
-    size_t cbSize = DrvAudioHlpFileGetDataSize(pFile);
+    size_t cbSize = AudioHlpFileGetDataSize(pFile);
 
     int rc = VINF_SUCCESS;
@@ -641 +641 @@
         && !(pFile->fFlags & PDMAUDIOFILE_FLAGS_KEEP_IF_EMPTY))
     {
-        rc = DrvAudioHlpFileDelete(pFile);
+        rc = AudioHlpFileDelete(pFile);
     }
 
@@ -663 +663 @@
  * @param   pFile               Audio file handle to delete.
  */
-int DrvAudioHlpFileDelete(PPDMAUDIOFILE pFile)
+int AudioHlpFileDelete(PPDMAUDIOFILE pFile)
 {
     AssertPtrReturn(pFile, VERR_INVALID_POINTER);
@@ -690 +690 @@
  * @param   pFile               Audio file handle to retrieve the audio data size for.
  */
-size_t DrvAudioHlpFileGetDataSize(PPDMAUDIOFILE pFile)
+size_t AudioHlpFileGetDataSize(PPDMAUDIOFILE pFile)
 {
     AssertPtrReturn(pFile, 0);
@@ -716 +716 @@
  * @param   pFile               Audio file handle to check open status for.
  */
-bool DrvAudioHlpFileIsOpen(PPDMAUDIOFILE pFile)
+bool AudioHlpFileIsOpen(PPDMAUDIOFILE pFile)
 {
     if (!pFile)
@@ -733 +733 @@
  * @param   fFlags              Additional write flags. Not being used at the moment and must be 0.
  */
-int DrvAudioHlpFileWrite(PPDMAUDIOFILE pFile, const void *pvBuf, size_t cbBuf, uint32_t fFlags)
+int AudioHlpFileWrite(PPDMAUDIOFILE pFile, const void *pvBuf, size_t cbBuf, uint32_t fFlags)
 {
     AssertPtrReturn(pFile, VERR_INVALID_POINTER);

trunk/src/VBox/Devices/Audio/AudioHlp.h

@@ -16 +16 @@
  */
 
-#ifndef VBOX_INCLUDED_SRC_Audio_DrvAudioCommon_h
-#define VBOX_INCLUDED_SRC_Audio_DrvAudioCommon_h
+#ifndef VBOX_INCLUDED_SRC_Audio_AudioHlp_h
+#define VBOX_INCLUDED_SRC_Audio_AudioHlp_h
 #ifndef RT_WITHOUT_PRAGMA_ONCE
 # pragma once
@@ -35 +35 @@
 /** @name Audio calculation helper methods.
  * @{ */
-uint32_t DrvAudioHlpCalcBitrate(uint8_t cBits, uint32_t uHz, uint8_t cChannels);
+uint32_t AudioHlpCalcBitrate(uint8_t cBits, uint32_t uHz, uint8_t cChannels);
 /** @} */
 
 /** @name Audio PCM properties helper methods.
  * @{ */
-bool     DrvAudioHlpPcmPropsAreValid(PCPDMAUDIOPCMPROPS pProps);
+bool     AudioHlpPcmPropsAreValid(PCPDMAUDIOPCMPROPS pProps);
 /** @}  */
 
 /** @name Audio configuration helper methods.
  * @{ */
-bool    DrvAudioHlpStreamCfgIsValid(PCPDMAUDIOSTREAMCFG pCfg);
+bool    AudioHlpStreamCfgIsValid(PCPDMAUDIOSTREAMCFG pCfg);
 /** @}  */
 
 /** @name Audio file (name) helper methods.
  * @{ */
-int DrvAudioHlpFileNameSanitize(char *pszPath, size_t cbPath);
-int DrvAudioHlpFileNameGet(char *pszFile, size_t cchFile, const char *pszPath, const char *pszName, uint32_t uInstance,
-                           PDMAUDIOFILETYPE enmType, uint32_t fFlags);
+int     AudioHlpFileNameSanitize(char *pszPath, size_t cbPath);
+int     AudioHlpFileNameGet(char *pszFile, size_t cchFile, const char *pszPath, const char *pszName,
+                            uint32_t uInstance, PDMAUDIOFILETYPE enmType, uint32_t fFlags);
 /** @}  */
 
 /** @name Audio string-ify methods.
  * @{ */
-PDMAUDIOFMT DrvAudioHlpStrToAudFmt(const char *pszFmt);
+PDMAUDIOFMT AudioHlpStrToAudFmt(const char *pszFmt);
 /** @}  */
 
 /** @name Audio file methods.
  * @{ */
-int DrvAudioHlpFileCreate(PDMAUDIOFILETYPE enmType, const char *pszFile, uint32_t fFlags, PPDMAUDIOFILE *ppFile);
-void DrvAudioHlpFileDestroy(PPDMAUDIOFILE pFile);
-int DrvAudioHlpFileOpen(PPDMAUDIOFILE pFile, uint32_t fOpen, PCPDMAUDIOPCMPROPS pProps);
-int DrvAudioHlpFileClose(PPDMAUDIOFILE pFile);
-int DrvAudioHlpFileDelete(PPDMAUDIOFILE pFile);
-size_t DrvAudioHlpFileGetDataSize(PPDMAUDIOFILE pFile);
-bool DrvAudioHlpFileIsOpen(PPDMAUDIOFILE pFile);
-int DrvAudioHlpFileWrite(PPDMAUDIOFILE pFile, const void *pvBuf, size_t cbBuf, uint32_t fFlags);
+int     AudioHlpFileCreate(PDMAUDIOFILETYPE enmType, const char *pszFile, uint32_t fFlags, PPDMAUDIOFILE *ppFile);
+void    AudioHlpFileDestroy(PPDMAUDIOFILE pFile);
+int     AudioHlpFileOpen(PPDMAUDIOFILE pFile, uint32_t fOpen, PCPDMAUDIOPCMPROPS pProps);
+int     AudioHlpFileClose(PPDMAUDIOFILE pFile);
+int     AudioHlpFileDelete(PPDMAUDIOFILE pFile);
+size_t  AudioHlpFileGetDataSize(PPDMAUDIOFILE pFile);
+bool    AudioHlpFileIsOpen(PPDMAUDIOFILE pFile);
+int     AudioHlpFileWrite(PPDMAUDIOFILE pFile, const void *pvBuf, size_t cbBuf, uint32_t fFlags);
 /** @}  */
 
 #define AUDIO_MAKE_FOURCC(c0, c1, c2, c3) RT_H2LE_U32_C(RT_MAKE_U32_FROM_U8(c0, c1, c2, c3))
 
-#endif /* !VBOX_INCLUDED_SRC_Audio_DrvAudioCommon_h */
+#endif /* !VBOX_INCLUDED_SRC_Audio_AudioHlp_h */
 

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

@@ -74 +74 @@
 #include "AudioMixer.h"
 #include "AudioMixBuffer.h"
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 
 #include <VBox/vmm/pdm.h>
@@ -615 +615 @@
      * Always use the sink's PCM audio format as the host side when creating a stream for it.
      */
-    AssertMsg(DrvAudioHlpPcmPropsAreValid(&pSink->PCMProps),
+    AssertMsg(AudioHlpPcmPropsAreValid(&pSink->PCMProps),
               ("%s: Does not (yet) have a format set when it must\n", pSink->pszName));
 
@@ -920 +920 @@
         && pSink->pParent->fFlags & AUDMIXER_FLAGS_DEBUG)
     {
-        DrvAudioHlpFileDestroy(pSink->Dbg.pFile);
+        AudioHlpFileDestroy(pSink->Dbg.pFile);
         pSink->Dbg.pFile = NULL;
     }
@@ -1274 +1274 @@
             if (pSink->pParent->fFlags & AUDMIXER_FLAGS_DEBUG)
             {
-                int rc2 = DrvAudioHlpFileWrite(pSink->Dbg.pFile, pvBuf, cbRead, 0 /* fFlags */);
+                int rc2 = AudioHlpFileWrite(pSink->Dbg.pFile, pvBuf, cbRead, 0 /* fFlags */);
                 AssertRC(rc2);
             }
@@ -1470 +1470 @@
     AssertPtrReturn(pSink,     VERR_INVALID_POINTER);
     AssertPtrReturn(pPCMProps, VERR_INVALID_POINTER);
-    AssertReturn(DrvAudioHlpPcmPropsAreValid(pPCMProps), VERR_INVALID_PARAMETER);
+    AssertReturn(AudioHlpPcmPropsAreValid(pPCMProps), VERR_INVALID_PARAMETER);
 
     int rc = RTCritSectEnter(&pSink->CritSect);
@@ -1509 +1509 @@
         && (pSink->pParent->fFlags & AUDMIXER_FLAGS_DEBUG))
     {
-        DrvAudioHlpFileClose(pSink->Dbg.pFile);
+        AudioHlpFileClose(pSink->Dbg.pFile);
 
         char szName[64];
@@ -1515 +1515 @@
 
         char szFile[RTPATH_MAX];
-        int rc2 = DrvAudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), NULL /* Use temporary directory */, szName,
-                                         0 /* Instance */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+        int rc2 = AudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), NULL /* Use temporary directory */, szName,
+                                      0 /* Instance */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         if (RT_SUCCESS(rc2))
         {
-            rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
-                                        &pSink->Dbg.pFile);
+            rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE, &pSink->Dbg.pFile);
             if (RT_SUCCESS(rc2))
-                rc2 = DrvAudioHlpFileOpen(pSink->Dbg.pFile, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS, &pSink->PCMProps);
+                rc2 = AudioHlpFileOpen(pSink->Dbg.pFile, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS, &pSink->PCMProps);
         }
     }

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

@@ -59 +59 @@
 #include "DevHdaStreamMap.h"
 
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 
 
@@ -2197 +2197 @@
     PHDASTREAM pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkLineIn);
     if (   pStream
-        && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
+        && AudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
         int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkLineIn.pMixSink, &pStream->State.Cfg, pDrv);
@@ -2207 +2207 @@
     pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkMicIn);
     if (   pStream
-        && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
+        && AudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
         int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkMicIn.pMixSink, &pStream->State.Cfg, pDrv);
@@ -2217 +2217 @@
     pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkFront);
     if (   pStream
-        && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
+        && AudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
         int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkFront.pMixSink, &pStream->State.Cfg, pDrv);
@@ -2227 +2227 @@
     pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkCenterLFE);
     if (   pStream
-        && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
+        && AudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
         int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkCenterLFE.pMixSink, &pStream->State.Cfg, pDrv);
@@ -2236 +2236 @@
     pStream = hdaR3GetSharedStreamFromSink(&pThisCC->SinkRear);
     if (   pStream
-        && DrvAudioHlpStreamCfgIsValid(&pStream->State.Cfg))
+        && AudioHlpStreamCfgIsValid(&pStream->State.Cfg))
     {
         int rc2 = hdaR3MixerAddDrvStream(pThisCC->SinkRear.pMixSink, &pStream->State.Cfg, pDrv);
@@ -2444 +2444 @@
     LogFunc(("Sink=%s, Stream=%s\n", pMixSink->pszName, pCfg->szName));
 
-    if (!DrvAudioHlpStreamCfgIsValid(pCfg))
+    if (!AudioHlpStreamCfgIsValid(pCfg))
         return VERR_INVALID_PARAMETER;
 

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

@@ -31 +31 @@
 #include <VBox/vmm/pdmaudioinline.h>
 
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 
 #include "DevHda.h"
@@ -118 +118 @@
             RTStrPrintf(szFile, sizeof(szFile), "hdaStreamReadSD%RU8", uSD);
 
-        int rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
-                                         0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+        int rc2 = AudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
+                                      0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         AssertRC(rc2);
 
-        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamR3->Dbg.Runtime.pFileStream);
+        rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamR3->Dbg.Runtime.pFileStream);
         AssertRC(rc2);
 
@@ -131 +131 @@
             RTStrPrintf(szFile, sizeof(szFile), "hdaDMARawReadSD%RU8", uSD);
 
-        rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
-                                     0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+        rc2 = AudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
+                                  0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         AssertRC(rc2);
 
-        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamR3->Dbg.Runtime.pFileDMARaw);
+        rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamR3->Dbg.Runtime.pFileDMARaw);
         AssertRC(rc2);
 
@@ -144 +144 @@
             RTStrPrintf(szFile, sizeof(szFile), "hdaDMAReadMappedSD%RU8", uSD);
 
-        rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
-                                     0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+        rc2 = AudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
+                                  0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         AssertRC(rc2);
 
-        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamR3->Dbg.Runtime.pFileDMAMapped);
+        rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamR3->Dbg.Runtime.pFileDMAMapped);
         AssertRC(rc2);
 
         /* Delete stale debugging files from a former run. */
-        DrvAudioHlpFileDelete(pStreamR3->Dbg.Runtime.pFileStream);
-        DrvAudioHlpFileDelete(pStreamR3->Dbg.Runtime.pFileDMARaw);
-        DrvAudioHlpFileDelete(pStreamR3->Dbg.Runtime.pFileDMAMapped);
+        AudioHlpFileDelete(pStreamR3->Dbg.Runtime.pFileStream);
+        AudioHlpFileDelete(pStreamR3->Dbg.Runtime.pFileDMARaw);
+        AudioHlpFileDelete(pStreamR3->Dbg.Runtime.pFileDMAMapped);
     }
 
@@ -203 +203 @@
     if (pStreamR3->Dbg.Runtime.fEnabled)
     {
-        DrvAudioHlpFileDestroy(pStreamR3->Dbg.Runtime.pFileStream);
+        AudioHlpFileDestroy(pStreamR3->Dbg.Runtime.pFileStream);
         pStreamR3->Dbg.Runtime.pFileStream = NULL;
 
-        DrvAudioHlpFileDestroy(pStreamR3->Dbg.Runtime.pFileDMARaw);
+        AudioHlpFileDestroy(pStreamR3->Dbg.Runtime.pFileDMARaw);
         pStreamR3->Dbg.Runtime.pFileDMARaw = NULL;
 
-        DrvAudioHlpFileDestroy(pStreamR3->Dbg.Runtime.pFileDMAMapped);
+        AudioHlpFileDestroy(pStreamR3->Dbg.Runtime.pFileDMAMapped);
         pStreamR3->Dbg.Runtime.pFileDMAMapped = NULL;
     }
@@ -904 +904 @@
         && pStreamR3->Dbg.Runtime.fEnabled)
     {
-        Assert(DrvAudioHlpPcmPropsAreValid(&pStreamShared->State.Cfg.Props));
+        Assert(AudioHlpPcmPropsAreValid(&pStreamShared->State.Cfg.Props));
 
         if (fEnable)
         {
-            if (!DrvAudioHlpFileIsOpen(pStreamR3->Dbg.Runtime.pFileStream))
+            if (!AudioHlpFileIsOpen(pStreamR3->Dbg.Runtime.pFileStream))
             {
-                int rc2 = DrvAudioHlpFileOpen(pStreamR3->Dbg.Runtime.pFileStream, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                              &pStreamShared->State.Cfg.Props);
+                int rc2 = AudioHlpFileOpen(pStreamR3->Dbg.Runtime.pFileStream, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                           &pStreamShared->State.Cfg.Props);
                 AssertRC(rc2);
             }
 
-            if (!DrvAudioHlpFileIsOpen(pStreamR3->Dbg.Runtime.pFileDMARaw))
+            if (!AudioHlpFileIsOpen(pStreamR3->Dbg.Runtime.pFileDMARaw))
             {
-                int rc2 = DrvAudioHlpFileOpen(pStreamR3->Dbg.Runtime.pFileDMARaw, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                              &pStreamShared->State.Cfg.Props);
+                int rc2 = AudioHlpFileOpen(pStreamR3->Dbg.Runtime.pFileDMARaw, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                           &pStreamShared->State.Cfg.Props);
                 AssertRC(rc2);
             }
 
-            if (!DrvAudioHlpFileIsOpen(pStreamR3->Dbg.Runtime.pFileDMAMapped))
+            if (!AudioHlpFileIsOpen(pStreamR3->Dbg.Runtime.pFileDMAMapped))
             {
-                int rc2 = DrvAudioHlpFileOpen(pStreamR3->Dbg.Runtime.pFileDMAMapped, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                              &pStreamShared->State.Cfg.Props);
+                int rc2 = AudioHlpFileOpen(pStreamR3->Dbg.Runtime.pFileDMAMapped, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                           &pStreamShared->State.Cfg.Props);
                 AssertRC(rc2);
             }
@@ -1387 +1387 @@
                 { /* likely */ }
                 else
-                    DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, pvBufSrc, cbBufSrc, 0 /* fFlags */);
+                    AudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, pvBufSrc, cbBufSrc, 0 /* fFlags */);
 
 #ifdef VBOX_WITH_DTRACE
@@ -1457 +1457 @@
                     { /* likely */ }
                     else
-                        DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, pvBufSrc, cbBufSrc, 0 /* fFlags */);
+                        AudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, pvBufSrc, cbBufSrc, 0 /* fFlags */);
 
 #ifdef VBOX_WITH_DTRACE
@@ -1590 +1590 @@
         { /* likely */ }
         else
-            DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileStream, abBuf, cbRead, 0 /* fFlags */);
+            AudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileStream, abBuf, cbRead, 0 /* fFlags */);
 
         /* Advance. */
@@ -1681 +1681 @@
                 { /* likely */ }
                 else
-                    DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, pvBufDst, cbBufDst, 0 /* fFlags */);
+                    AudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, pvBufDst, cbBufDst, 0 /* fFlags */);
 
 #ifdef VBOX_WITH_DTRACE
@@ -1760 +1760 @@
                     { /* likely */ }
                     else
-                        DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, pvBufDst, cbBufDst, 0 /* fFlags */);
+                        AudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileDMARaw, pvBufDst, cbBufDst, 0 /* fFlags */);
 
                     pStreamR3->State.offWrite += cbBufDst;
@@ -1844 +1844 @@
         { /* likely */ }
         else
-            DrvAudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileStream, pvSrcBuf, cbSrcBuf, 0 /* fFlags */);
+            AudioHlpFileWrite(pStreamR3->Dbg.Runtime.pFileStream, pvSrcBuf, cbSrcBuf, 0 /* fFlags */);
 
         uint32_t cbWritten = 0;

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

@@ -30 +30 @@
 #include <iprt/string.h>
 
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 
 #include "DevHdaStreamChannel.h"
@@ -329 +329 @@
     AssertPtrReturn(pProps, VERR_INVALID_POINTER);
 
-    if (!DrvAudioHlpPcmPropsAreValid(pProps))
+    if (!AudioHlpPcmPropsAreValid(pProps))
         return VERR_INVALID_PARAMETER;
 

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

@@ -41 +41 @@
 #include "AudioMixBuffer.h"
 #include "AudioMixer.h"
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 
 
@@ -1001 +1001 @@
         else
         {
-            if (!DrvAudioHlpFileIsOpen(pStreamCC->Dbg.Runtime.pFileStream))
+            if (!AudioHlpFileIsOpen(pStreamCC->Dbg.Runtime.pFileStream))
             {
-                int rc2 = DrvAudioHlpFileOpen(pStreamCC->Dbg.Runtime.pFileStream, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                              &pStreamCC->State.Cfg.Props);
+                int rc2 = AudioHlpFileOpen(pStreamCC->Dbg.Runtime.pFileStream, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                           &pStreamCC->State.Cfg.Props);
                 AssertRC(rc2);
             }
 
-            if (!DrvAudioHlpFileIsOpen(pStreamCC->Dbg.Runtime.pFileDMA))
+            if (!AudioHlpFileIsOpen(pStreamCC->Dbg.Runtime.pFileDMA))
             {
-                int rc2 = DrvAudioHlpFileOpen(pStreamCC->Dbg.Runtime.pFileDMA, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                              &pStreamCC->State.Cfg.Props);
+                int rc2 = AudioHlpFileOpen(pStreamCC->Dbg.Runtime.pFileDMA, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                           &pStreamCC->State.Cfg.Props);
                 AssertRC(rc2);
             }
@@ -1103 +1103 @@
 
         char szPath[RTPATH_MAX];
-        int rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
-                                         0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+        int rc2 = AudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
+                                      0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         AssertRC(rc2);
-        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamCC->Dbg.Runtime.pFileStream);
+        rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamCC->Dbg.Runtime.pFileStream);
         AssertRC(rc2);
 
@@ -1114 +1114 @@
             RTStrPrintf(szFile, sizeof(szFile), "ac97DMAReadSD%RU8", pStream->u8SD);
 
-        rc2 = DrvAudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
-                                     0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+        rc2 = AudioHlpFileNameGet(szPath, sizeof(szPath), pThisCC->Dbg.pszOutPath, szFile,
+                                  0 /* uInst */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         AssertRC(rc2);
 
-        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamCC->Dbg.Runtime.pFileDMA);
+        rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szPath, PDMAUDIOFILE_FLAGS_NONE, &pStreamCC->Dbg.Runtime.pFileDMA);
         AssertRC(rc2);
 
         /* Delete stale debugging files from a former run. */
-        DrvAudioHlpFileDelete(pStreamCC->Dbg.Runtime.pFileStream);
-        DrvAudioHlpFileDelete(pStreamCC->Dbg.Runtime.pFileDMA);
+        AudioHlpFileDelete(pStreamCC->Dbg.Runtime.pFileStream);
+        AudioHlpFileDelete(pStreamCC->Dbg.Runtime.pFileDMA);
     }
 
@@ -1157 +1157 @@
     else
     {
-        DrvAudioHlpFileDestroy(pStreamCC->Dbg.Runtime.pFileStream);
+        AudioHlpFileDestroy(pStreamCC->Dbg.Runtime.pFileStream);
         pStreamCC->Dbg.Runtime.pFileStream = NULL;
 
-        DrvAudioHlpFileDestroy(pStreamCC->Dbg.Runtime.pFileDMA);
+        AudioHlpFileDestroy(pStreamCC->Dbg.Runtime.pFileDMA);
         pStreamCC->Dbg.Runtime.pFileDMA = NULL;
     }
@@ -1254 +1254 @@
         { /* likely */ }
         else
-            DrvAudioHlpFileWrite(pDstStreamCC->Dbg.Runtime.pFileStream, pvDst, cbRead, 0 /* fFlags */);
+            AudioHlpFileWrite(pDstStreamCC->Dbg.Runtime.pFileStream, pvDst, cbRead, 0 /* fFlags */);
     }
 
@@ -1302 +1302 @@
             { /* likely */ }
             else
-                DrvAudioHlpFileWrite(pSrcStreamCC->Dbg.Runtime.pFileStream, pvSrc, cbSrc, 0 /* fFlags */);
+                AudioHlpFileWrite(pSrcStreamCC->Dbg.Runtime.pFileStream, pvSrc, cbSrc, 0 /* fFlags */);
 
             rc = AudioMixerSinkWrite(pDstMixSink, AUDMIXOP_COPY, pvSrc, (uint32_t)cbSrc, &cbWritten);
@@ -1940 +1940 @@
     AssertPtrReturn(pMixSink, VERR_INVALID_POINTER);
 
-    if (!DrvAudioHlpStreamCfgIsValid(pCfg))
+    if (!AudioHlpStreamCfgIsValid(pCfg))
         return VERR_INVALID_PARAMETER;
 
@@ -1973 +1973 @@
     int rc = VINF_SUCCESS;
 
-    if (DrvAudioHlpStreamCfgIsValid(&pThisCC->aStreams[AC97SOUNDSOURCE_PI_INDEX].State.Cfg))
+    if (AudioHlpStreamCfgIsValid(&pThisCC->aStreams[AC97SOUNDSOURCE_PI_INDEX].State.Cfg))
         rc = ichac97R3MixerAddDrvStream(pThisCC->pSinkLineIn, &pThisCC->aStreams[AC97SOUNDSOURCE_PI_INDEX].State.Cfg, pDrv);
 
-    if (DrvAudioHlpStreamCfgIsValid(&pThisCC->aStreams[AC97SOUNDSOURCE_PO_INDEX].State.Cfg))
+    if (AudioHlpStreamCfgIsValid(&pThisCC->aStreams[AC97SOUNDSOURCE_PO_INDEX].State.Cfg))
     {
         int rc2 = ichac97R3MixerAddDrvStream(pThisCC->pSinkOut, &pThisCC->aStreams[AC97SOUNDSOURCE_PO_INDEX].State.Cfg, pDrv);
@@ -1983 +1983 @@
     }
 
-    if (DrvAudioHlpStreamCfgIsValid(&pThisCC->aStreams[AC97SOUNDSOURCE_MC_INDEX].State.Cfg))
+    if (AudioHlpStreamCfgIsValid(&pThisCC->aStreams[AC97SOUNDSOURCE_MC_INDEX].State.Cfg))
     {
         int rc2 = ichac97R3MixerAddDrvStream(pThisCC->pSinkMicIn, &pThisCC->aStreams[AC97SOUNDSOURCE_MC_INDEX].State.Cfg, pDrv);
@@ -2906 +2906 @@
                     { /* likely */ }
                     else
-                        DrvAudioHlpFileWrite(pStreamCC->Dbg.Runtime.pFileDMA, pvDst, cbDst, 0 /* fFlags */);
+                        AudioHlpFileWrite(pStreamCC->Dbg.Runtime.pFileDMA, pvDst, cbDst, 0 /* fFlags */);
                 }
 
@@ -2931 +2931 @@
                     { /* likely */ }
                     else
-                        DrvAudioHlpFileWrite(pStreamCC->Dbg.Runtime.pFileDMA, pvSrc, cbSrc, 0 /* fFlags */);
+                        AudioHlpFileWrite(pStreamCC->Dbg.Runtime.pFileDMA, pvSrc, cbSrc, 0 /* fFlags */);
                 }
 

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

@@ -63 +63 @@
 #include "AudioMixBuffer.h"
 #include "AudioMixer.h"
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 
 
@@ -1767 +1767 @@
 {
     AssertReturn(pCfg->enmDir == PDMAUDIODIR_OUT, VERR_INVALID_PARAMETER);
-    Assert(DrvAudioHlpStreamCfgIsValid(pCfg));
+    Assert(AudioHlpStreamCfgIsValid(pCfg));
 
     PPDMAUDIOSTREAMCFG pCfgHost = PDMAudioStrmCfgDup(pCfg);
@@ -1867 +1867 @@
     AssertPtr(pCfg);
 
-    if (!DrvAudioHlpStreamCfgIsValid(pCfg))
+    if (!AudioHlpStreamCfgIsValid(pCfg))
         return VERR_INVALID_PARAMETER;
 

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

@@ -44 +44 @@
 #include <stdlib.h>
 
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 #include "AudioMixBuffer.h"
 
@@ -244 +244 @@
     }
 
-    PDMAUDIOFMT fmt = DrvAudioHlpStrToAudFmt(pszValue);
+    PDMAUDIOFMT fmt = AudioHlpStrToAudFmt(pszValue);
     if (fmt == PDMAUDIOFMT_INVALID)
     {
@@ -1171 +1171 @@
 
         if (pThis->Out.Cfg.Dbg.fEnabled)
-            DrvAudioHlpFileWrite(pStream->Out.Dbg.pFileStreamWrite, pvBuf, cbToWrite, 0 /* fFlags */);
+            AudioHlpFileWrite(pStream->Out.Dbg.pFileStreamWrite, pvBuf, cbToWrite, 0 /* fFlags */);
 
         uint32_t cfGstMixed = 0;
@@ -1536 +1536 @@
         {
             if (pThis->Out.Cfg.Dbg.fEnabled)
-                DrvAudioHlpFileWrite(pStream->Out.Dbg.pFilePlayNonInterleaved, pvChunk, cbPlayed, 0 /* fFlags */);
+                AudioHlpFileWrite(pStream->Out.Dbg.pFilePlayNonInterleaved, pvChunk, cbPlayed, 0 /* fFlags */);
 
             if (cbRead != cbPlayed)
@@ -1924 +1924 @@
 
         if (pThis->In.Cfg.Dbg.fEnabled)
-            DrvAudioHlpFileWrite(pStream->In.Dbg.pFileCaptureNonInterleaved, pThis->pvScratchBuf, cbCaptured, 0 /* fFlags */);
+            AudioHlpFileWrite(pStream->In.Dbg.pFileCaptureNonInterleaved, pThis->pvScratchBuf, cbCaptured, 0 /* fFlags */);
 
         uint32_t cfHstMixed = 0;
@@ -2523 +2523 @@
             {
                 if (pThis->In.Cfg.Dbg.fEnabled)
-                    DrvAudioHlpFileWrite(pStream->In.Dbg.pFileStreamRead,
+                    AudioHlpFileWrite(pStream->In.Dbg.pFileStreamRead,
                                          pvBuf, AUDIOMIXBUF_F2B(&pStream->Guest.MixBuf, cfReadTotal), 0 /* fFlags */);
 
@@ -2599 +2599 @@
     do /* this is not a loop, just a construct to make the code more difficult to follow. */
     {
-        if (   !DrvAudioHlpStreamCfgIsValid(pCfgHost)
-            || !DrvAudioHlpStreamCfgIsValid(pCfgGuest))
+        if (   !AudioHlpStreamCfgIsValid(pCfgHost)
+            || !AudioHlpStreamCfgIsValid(pCfgGuest))
         {
             RC_BREAK(VERR_INVALID_PARAMETER);
@@ -2693 +2693 @@
             if (pThis->In.Cfg.Dbg.fEnabled)
             {
-                int rc2 = DrvAudioHlpFileNameGet(szFile, sizeof(szFile), pThis->In.Cfg.Dbg.szPathOut, "DrvAudioCapNonInt",
-                                                 pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+                int rc2 = AudioHlpFileNameGet(szFile, sizeof(szFile), pThis->In.Cfg.Dbg.szPathOut, "DrvAudioCapNonInt",
+                                              pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
                 if (RT_SUCCESS(rc2))
                 {
-                    rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
-                                                &pStream->In.Dbg.pFileCaptureNonInterleaved);
+                    rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
+                                             &pStream->In.Dbg.pFileCaptureNonInterleaved);
                     if (RT_SUCCESS(rc2))
-                        rc2 = DrvAudioHlpFileOpen(pStream->In.Dbg.pFileCaptureNonInterleaved, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                                  &pStream->Host.Cfg.Props);
+                        rc2 = AudioHlpFileOpen(pStream->In.Dbg.pFileCaptureNonInterleaved, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                               &pStream->Host.Cfg.Props);
                 }
 
                 if (RT_SUCCESS(rc2))
                 {
-                    rc2 = DrvAudioHlpFileNameGet(szFile, sizeof(szFile), pThis->In.Cfg.Dbg.szPathOut, "DrvAudioRead",
-                                                 pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+                    rc2 = AudioHlpFileNameGet(szFile, sizeof(szFile), pThis->In.Cfg.Dbg.szPathOut, "DrvAudioRead",
+                                              pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
                     if (RT_SUCCESS(rc2))
                     {
-                        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
-                                                    &pStream->In.Dbg.pFileStreamRead);
+                        rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
+                                                 &pStream->In.Dbg.pFileStreamRead);
                         if (RT_SUCCESS(rc2))
-                            rc2 = DrvAudioHlpFileOpen(pStream->In.Dbg.pFileStreamRead, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                                      &pStream->Host.Cfg.Props);
+                            rc2 = AudioHlpFileOpen(pStream->In.Dbg.pFileStreamRead, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                                   &pStream->Host.Cfg.Props);
                     }
                 }
@@ -2726 +2726 @@
             if (pThis->Out.Cfg.Dbg.fEnabled)
             {
-                int rc2 = DrvAudioHlpFileNameGet(szFile, sizeof(szFile), pThis->Out.Cfg.Dbg.szPathOut, "DrvAudioPlayNonInt",
-                                                 pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+                int rc2 = AudioHlpFileNameGet(szFile, sizeof(szFile), pThis->Out.Cfg.Dbg.szPathOut, "DrvAudioPlayNonInt",
+                                              pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
                 if (RT_SUCCESS(rc2))
                 {
-                    rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
-                                                &pStream->Out.Dbg.pFilePlayNonInterleaved);
+                    rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
+                                             &pStream->Out.Dbg.pFilePlayNonInterleaved);
                     if (RT_SUCCESS(rc2))
-                        rc = DrvAudioHlpFileOpen(pStream->Out.Dbg.pFilePlayNonInterleaved, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                                 &pStream->Host.Cfg.Props);
+                        rc = AudioHlpFileOpen(pStream->Out.Dbg.pFilePlayNonInterleaved, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                              &pStream->Host.Cfg.Props);
                 }
 
                 if (RT_SUCCESS(rc2))
                 {
-                    rc2 = DrvAudioHlpFileNameGet(szFile, sizeof(szFile), pThis->Out.Cfg.Dbg.szPathOut, "DrvAudioWrite",
-                                                 pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+                    rc2 = AudioHlpFileNameGet(szFile, sizeof(szFile), pThis->Out.Cfg.Dbg.szPathOut, "DrvAudioWrite",
+                                              pThis->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
                     if (RT_SUCCESS(rc2))
                     {
-                        rc2 = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
-                                                    &pStream->Out.Dbg.pFileStreamWrite);
+                        rc2 = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE,
+                                                 &pStream->Out.Dbg.pFileStreamWrite);
                         if (RT_SUCCESS(rc2))
-                            rc2 = DrvAudioHlpFileOpen(pStream->Out.Dbg.pFileStreamWrite, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
-                                                      &pStream->Host.Cfg.Props);
+                            rc2 = AudioHlpFileOpen(pStream->Out.Dbg.pFileStreamWrite, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS,
+                                                   &pStream->Host.Cfg.Props);
                     }
                 }
@@ -3221 +3221 @@
 
     /* Validate PCM properties. */
-    if (!DrvAudioHlpPcmPropsAreValid(&pCfgReq->Props))
+    if (!AudioHlpPcmPropsAreValid(&pCfgReq->Props))
     {
         LogRel(("Audio: Invalid custom PCM properties set for stream '%s', cannot create stream\n", pStream->szName));
@@ -3337 +3337 @@
 
     /* Validate acquired configuration. */
-    if (!DrvAudioHlpStreamCfgIsValid(pCfgAcq))
+    if (!AudioHlpStreamCfgIsValid(pCfgAcq))
     {
         LogRel(("Audio: Creating stream '%s' returned an invalid backend configuration, skipping\n", pStream->szName));
@@ -3473 +3473 @@
         if (pThis->In.Cfg.Dbg.fEnabled)
         {
-            DrvAudioHlpFileDestroy(pStream->In.Dbg.pFileCaptureNonInterleaved);
+            AudioHlpFileDestroy(pStream->In.Dbg.pFileCaptureNonInterleaved);
             pStream->In.Dbg.pFileCaptureNonInterleaved = NULL;
 
-            DrvAudioHlpFileDestroy(pStream->In.Dbg.pFileStreamRead);
+            AudioHlpFileDestroy(pStream->In.Dbg.pFileStreamRead);
             pStream->In.Dbg.pFileStreamRead = NULL;
         }
@@ -3490 +3490 @@
         if (pThis->Out.Cfg.Dbg.fEnabled)
         {
-            DrvAudioHlpFileDestroy(pStream->Out.Dbg.pFilePlayNonInterleaved);
+            AudioHlpFileDestroy(pStream->Out.Dbg.pFilePlayNonInterleaved);
             pStream->Out.Dbg.pFilePlayNonInterleaved = NULL;
 
-            DrvAudioHlpFileDestroy(pStream->Out.Dbg.pFileStreamWrite);
+            AudioHlpFileDestroy(pStream->Out.Dbg.pFileStreamWrite);
             pStream->Out.Dbg.pFileStreamWrite = NULL;
         }

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

@@ -29 +29 @@
 #include <VBox/vmm/pdmaudioinline.h>
 
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 #include "VBoxDD.h"
 
@@ -136 +136 @@
 {
     char szFile[RTPATH_MAX];
-    int rc = DrvAudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), NULL /* Use temporary directory */, fIn ? "DebugAudioIn" : "DebugAudioOut",
-                                    pDrv->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+    int rc = AudioHlpFileNameGet(szFile, RT_ELEMENTS(szFile), NULL /* Use temporary directory */, fIn ? "DebugAudioIn" : "DebugAudioOut",
+                                 pDrv->pDrvIns->iInstance, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
     if (RT_SUCCESS(rc))
     {
-        rc = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE, &pStreamDbg->pFile);
+        rc = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE, &pStreamDbg->pFile);
         if (RT_SUCCESS(rc))
-        {
-            rc = DrvAudioHlpFileOpen(pStreamDbg->pFile, RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE,
-                                     &pCfg->Props);
-        }
-
+            rc = AudioHlpFileOpen(pStreamDbg->pFile, RTFILE_O_WRITE | RTFILE_O_DENY_WRITE | RTFILE_O_CREATE_REPLACE, &pCfg->Props);
         if (RT_FAILURE(rc))
             LogRel(("DebugAudio: Creating %sput file '%s' failed with %Rrc\n", fIn ? "in" : "out", szFile, rc));
@@ -222 +218 @@
     PDEBUGAUDIOSTREAM  pStreamDbg = (PDEBUGAUDIOSTREAM)pStream;
 
-    int rc = DrvAudioHlpFileWrite(pStreamDbg->pFile, pvBuf, uBufSize, 0 /* fFlags */);
+    int rc = AudioHlpFileWrite(pStreamDbg->pFile, pvBuf, uBufSize, 0 /* fFlags */);
     if (RT_FAILURE(rc))
     {
@@ -266 +262 @@
     }
 
-    int rc = DrvAudioHlpFileWrite(pStreamDbg->pFile, pvBuf, uBufSize, 0 /* fFlags */);
+    int rc = AudioHlpFileWrite(pStreamDbg->pFile, pvBuf, uBufSize, 0 /* fFlags */);
     if (RT_FAILURE(rc))
     {
@@ -315 +311 @@
     if (RT_SUCCESS(rc))
     {
-        DrvAudioHlpFileDestroy(pStreamDbg->pFile);
+        AudioHlpFileDestroy(pStreamDbg->pFile);
 
         PDMAudioStrmCfgFree(pStreamDbg->pCfg);

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

@@ -25 +25 @@
 #include <VBox/vmm/pdmaudioinline.h>
 
-#include "DrvAudioCommon.h"
+#include "AudioHlp.h"
 #include "VBoxDD.h"
 
@@ -157 +157 @@
     {
         char szFile[RTPATH_MAX];
-        rc = DrvAudioHlpFileNameGet(szFile, sizeof(szFile), szTemp, "VaKit",
-                                    0 /* Instance */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
+        rc = AudioHlpFileNameGet(szFile, sizeof(szFile), szTemp, "VaKit",
+                                 0 /* Instance */, PDMAUDIOFILETYPE_WAV, PDMAUDIOFILENAME_FLAGS_NONE);
         if (RT_SUCCESS(rc))
         {
-            rc = DrvAudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE, &pStreamDbg->pFile);
+            rc = AudioHlpFileCreate(PDMAUDIOFILETYPE_WAV, szFile, PDMAUDIOFILE_FLAGS_NONE, &pStreamDbg->pFile);
             if (RT_SUCCESS(rc))
-                rc = DrvAudioHlpFileOpen(pStreamDbg->pFile, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS, &pCfgReq->Props);
+                rc = AudioHlpFileOpen(pStreamDbg->pFile, PDMAUDIOFILE_DEFAULT_OPEN_FLAGS, &pCfgReq->Props);
         }
 
@@ -252 +252 @@
    // pStreamDbg->Out.tsLastPlayed = PDMDrvHlpTMGetVirtualTime(pDrv->pDrvIns);;
 
-    int rc2 = DrvAudioHlpFileWrite(pStreamDbg->pFile, pvBuf, uBufSize, 0 /* fFlags */);
+    int rc2 = AudioHlpFileWrite(pStreamDbg->pFile, pvBuf, uBufSize, 0 /* fFlags */);
     if (RT_FAILURE(rc2))
         LogRel(("VaKitAudio: Writing output failed with %Rrc\n", rc2));
@@ -297 +297 @@
     if (pStreamDbg->pFile)
     {
-        size_t cbDataSize = DrvAudioHlpFileGetDataSize(pStreamDbg->pFile);
+        size_t cbDataSize = AudioHlpFileGetDataSize(pStreamDbg->pFile);
         if (cbDataSize)
             LogRel(("VaKitAudio: Created output file '%s' (%zu bytes)\n", pStreamDbg->pFile->szName, cbDataSize));
 
-        DrvAudioHlpFileDestroy(pStreamDbg->pFile);
+        AudioHlpFileDestroy(pStreamDbg->pFile);
         pStreamDbg->pFile = NULL;
     }

trunk/src/VBox/Devices/Audio/testcase/Makefile.kmk

@@ -30 +30 @@
         tstAudioMixBuffer.cpp \
         ../AudioMixBuffer.cpp \
-        ../DrvAudioCommon.cpp
+        ../AudioHlp.cpp
  tstAudioMixBuffer_LIBS = $(LIB_RUNTIME)
 

trunk/src/VBox/Devices/Audio/testcase/tstAudioMixBuffer.cpp

@@ -31 +31 @@
 
 #include "../AudioMixBuffer.h"
-#include "../DrvAudioCommon.h"
+#include "../AudioHlp.h"
 
 
@@ -67 +67 @@
     RTTESTI_CHECK(PDMAudioPropsGetBitrate(&Cfg441StereoU32) == 44100*8*8);
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&Cfg441StereoS16));
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&Cfg441StereoU16) == false); /* go figure */
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&Cfg441StereoU32) == false); /* go figure */
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&Cfg441StereoS16));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&Cfg441StereoU16) == false); /* go figure */
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&Cfg441StereoU32) == false); /* go figure */
 
 
@@ -200 +200 @@
     );
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&config));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&config));
 
     uint32_t cBufSize = _1K;
@@ -321 +321 @@
     );
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_p));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&cfg_p));
 
     PDMAUDIOMIXBUF parent;
@@ -336 +336 @@
     );
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_c1));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&cfg_c1));
 
     uint32_t cFrames      = 16;
@@ -355 +355 @@
     );
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_c2));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&cfg_c2));
 
     PDMAUDIOMIXBUF child2;
@@ -469 +469 @@
     );
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_p));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&cfg_p));
 
     PDMAUDIOMIXBUF parent;
@@ -492 +492 @@
     );
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_c));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&cfg_c));
 
     PDMAUDIOMIXBUF child;
@@ -574 +574 @@
     );
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_p));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&cfg_p));
 
     PDMAUDIOMIXBUF parent;
@@ -589 +589 @@
     );
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg_c));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&cfg_c));
 
     PDMAUDIOMIXBUF child;
@@ -671 +671 @@
     );
 
-    RTTESTI_CHECK(DrvAudioHlpPcmPropsAreValid(&cfg));
+    RTTESTI_CHECK(AudioHlpPcmPropsAreValid(&cfg));
 
     PDMAUDIOVOLUME vol = { false, 0, 0 };   /* Not muted. */

trunk/src/VBox/Devices/Makefile.kmk

@@ -638 +638 @@
         Audio/DevHdaStreamChannel.cpp \
         Audio/DevHdaStreamMap.cpp \
+        Audio/AudioHlp.cpp \
         Audio/AudioMixBuffer.cpp \
         Audio/AudioMixer.cpp \
         Audio/DrvAudio.cpp \
-        Audio/DrvAudioCommon.cpp \
         Audio/DrvHostAudioNull.cpp