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

Timestamp:

Dec 9, 2010 4:29:49 PM (14 years ago)

Author:

vboxsync

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

68723

Message:

Initial audio filter implementation, which is used for audio input via remote desktop server.

Location:

trunk/src/VBox/Devices

Files:

• Audio/audio.c (modified) (1 diff)
• Audio/audio_int.h (modified) (1 diff)
• Audio/audiosniffer.c (modified) (7 diffs)
• Makefile.kmk (modified) (1 diff)

trunk/src/VBox/Devices/Audio/audio.c

@@ -1551 +1551 @@
 
     if (s->drv_opaque) {
+        /* Filter must be installed before initializing voices. */
+        drv = filteraudio_install(drv, s->drv_opaque);
         audio_init_nb_voices_out (s, drv);
         audio_init_nb_voices_in (s, drv);

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

@@ -314 +314 @@
                                     unsigned cSamples);
 
+/*
+ * Filter interface.
+ */
+typedef DECLCALLBACK(int) FNAUDIOINPUTCALLBACK(void* pvCtx, uint32_t cbSamples, const void *pvSamples);
+typedef FNAUDIOINPUTCALLBACK *PFNAUDIOINPUTCALLBACK;
+
+int filter_output_intercepted(void);
+int filter_output_begin(void **ppvOutputCtx, struct audio_pcm_info *pinfo, int samples);
+void filter_output_end(void *pvOutputCtx);
+
+int filter_input_intercepted(void);
+int filter_input_begin(void **ppvInputCtx, PFNAUDIOINPUTCALLBACK pfnCallback, void *pvCallback, HWVoiceIn *phw, int samples);
+void filter_input_end(void *pvInputCtx);
+
+struct audio_driver *filteraudio_install(struct audio_driver *pDrv, void *pDrvOpaque);
+
 #endif /* audio_int.h */

trunk/src/VBox/Devices/Audio/audiosniffer.c

@@ -5 +5 @@
 
 /*
- * Copyright (C) 2006-2007 Oracle Corporation
+ * Copyright (C) 2006-2010 Oracle Corporation
  *
  * This file is part of VirtualBox Open Source Edition (OSE), as
@@ -22 +22 @@
 
 #include <VBox/log.h>
+#include <iprt/asm.h>
 #include <iprt/assert.h>
 #include <iprt/uuid.h>
@@ -40 +41 @@
     /** Whether audio should reach the host driver too. */
     bool fKeepHostAudio;
+
+    /** Whether audio input operations should be forwarded to the connector. */
+    bool fInterceptAudioInput;
 
     /** Pointer to device instance. */
@@ -100 +104 @@
 
 /*
- * Audio Sniffer PDM device.
- */
+ * Filter interface.
+ */
+
+/* Internal audio input context, which makes sure that:
+ *   - the filter audio input callback is not called after the filter has issued filter_input_end;
+ *   - maintains internal information and state of the audio stream.
+ */
+typedef struct SnifferInputCtx
+{
+    /* Whether the context is still in use by the filter or I'll check. */
+    int32_t volatile cRefs;
+
+    /* The filter callback for incoming audio data. */
+    PFNAUDIOINPUTCALLBACK pfnFilterCallback;
+    void *pvFilterCallback;
+
+    /* Whether the stream has been ended by the filter. */
+    bool fEndedByFilter;
+
+    /* Context pointer returned by pfnAudioInputBegin. */
+    void *pvUserCtx;
+
+    /* Audio format used for recording. */
+    HWVoiceIn *phw;
+
+    /* Number of bytes per frame (bitsPerSample * channels) of the actual input format. */
+    uint32_t cBytesPerFrame;
+
+    /* Frequency of the actual audio format. */
+    int iFreq;
+
+    /* Convertion from the actual input format to st_sample_t. */
+    t_sample *conv;
+
+    /* If the actual format frequence differs from the requested format, this is not NULL. */
+    void *rate;
+
+} SnifferInputCtx;
+
+/*
+ * Filter audio output.
+ */
+
+/* Whether the filter should intercept audio output. */
+int filter_output_intercepted(void)
+{
+    return 0; /* @todo Not implemented yet.*/
+}
+
+/* Filter informs that an audio output is starting. */
+int filter_output_begin(void **ppvOutputCtx, struct audio_pcm_info *pinfo, int samples)
+{
+    return VERR_NOT_SUPPORTED; /* @todo Not implemented yet.*/
+}
+
+/* Filter informs that the audio output has been stopped. */
+void filter_output_end(void *pvOutputCtx)
+{
+    return; /* @todo Not implemented yet.*/
+}
+
+/*
+ * Filter audio input.
+ */
+
+/* Whether the filter should intercept audio input. */
+int filter_input_intercepted(void)
+{
+    if (!g_pData || !g_pData->pDrv)
+    {
+        return 0;
+    }
+
+    return g_pData->fInterceptAudioInput;
+}
+
+/* Filter informs that an audio input is starting. */
+int filter_input_begin (void **ppvInputCtx, PFNAUDIOINPUTCALLBACK pfnCallback, void *pvCallback, HWVoiceIn *phw, int cSamples)
+{
+    int rc = VINF_SUCCESS;
+
+    SnifferInputCtx *pCtx = NULL;
+
+    if (!g_pData || !g_pData->pDrv)
+    {
+        return VERR_NOT_SUPPORTED;
+    }
+
+    pCtx = (SnifferInputCtx *)RTMemAlloc(sizeof(SnifferInputCtx));
+
+    if (!pCtx)
+    {
+        return VERR_NO_MEMORY;
+    }
+
+    pCtx->cRefs = 2; /* Context is used by both the filter and the user. */
+    pCtx->pfnFilterCallback = pfnCallback;
+    pCtx->pvFilterCallback = pvCallback;
+    pCtx->fEndedByFilter = false;
+    pCtx->pvUserCtx = NULL;
+    pCtx->phw = phw;
+    pCtx->cBytesPerFrame = 1;
+    pCtx->iFreq = 0;
+    pCtx->conv = NULL;
+    pCtx->rate = NULL;
+
+    rc = g_pData->pDrv->pfnAudioInputBegin (g_pData->pDrv,
+                                            &pCtx->pvUserCtx,      /* Returned by the pDrv. */
+                                            pCtx,
+                                            cSamples,              /* How many samples in one block is preferred. */
+                                            phw->info.freq,        /* Required frequency. */
+                                            phw->info.nchannels,   /* Number of audio channels. */
+                                            phw->info.bits);       /* A sample size in one channel, samples are signed. */
+
+    if (RT_SUCCESS(rc))
+    {
+        *ppvInputCtx = pCtx;
+    }
+    else
+    {
+        RTMemFree(pCtx);
+    }
+
+    Log(("input_begin rc = %Rrc\n", rc));
+
+    return rc;
+}
+
+/* Filter informs that the audio input must be stopped. */
+void filter_input_end(void *pvCtx)
+{
+    int32_t c;
+
+    SnifferInputCtx *pCtx = (SnifferInputCtx *)pvCtx;
+
+    void *pvUserCtx = pCtx->pvUserCtx;
+
+    pCtx->fEndedByFilter = true;
+
+    c = ASMAtomicDecU32(&pCtx->cRefs);
+
+    if (c == 0)
+    {
+        /* The caller will not use this context anymore. */
+        if (pCtx->rate)
+        {
+            st_rate_stop (pCtx->rate);
+        }
+        RTMemFree(pCtx);
+        pCtx = NULL;
+    }
+
+    if (!g_pData || !g_pData->pDrv)
+    {
+        AssertFailed();
+        return;
+    }
+
+    g_pData->pDrv->pfnAudioInputEnd (g_pData->pDrv,
+                                     pvUserCtx);
+
+    Log(("input_end\n"));
+}
+
+
+/*
+ * Audio PDM device.
+ */
+static DECLCALLBACK(int) iface_AudioInputIntercept (PPDMIAUDIOSNIFFERPORT pInterface, bool fIntercept)
+{
+    AUDIOSNIFFERSTATE *pThis = RT_FROM_MEMBER(pInterface, AUDIOSNIFFERSTATE, IPort);
+
+    Assert(g_pData == pThis);
+
+    pThis->fInterceptAudioInput = fIntercept;
+
+    return VINF_SUCCESS;
+}
+
+static DECLCALLBACK(int) iface_AudioInputEventBegin (PPDMIAUDIOSNIFFERPORT pInterface,
+                                                     void *pvContext,
+                                                     int iSampleHz,
+                                                     int cChannels,
+                                                     int cBits,
+                                                     bool fUnsigned)
+{
+    int bitIdx;
+
+    AUDIOSNIFFERSTATE *pThis = RT_FROM_MEMBER(pInterface, AUDIOSNIFFERSTATE, IPort);
+
+    int rc = VINF_SUCCESS;
+
+    SnifferInputCtx *pCtx = (SnifferInputCtx *)pvContext;
+
+    Log(("FilterAudio: AudioInputEventBegin: %dHz,%dch,%dbits,%d ended %d\n",
+         iSampleHz, cChannels, cBits, fUnsigned, pCtx->fEndedByFilter));
+
+    Assert(g_pData == pThis);
+
+    /* Prepare a format convertion for the actually used format. */
+    pCtx->cBytesPerFrame = ((cBits + 7) / 8) * cChannels;
+
+    if (cBits == 16)
+    {
+        bitIdx = 1;
+    }
+    else if (cBits == 32)
+    {
+        bitIdx = 2;
+    }
+    else
+    {
+        bitIdx = 0;
+    }
+
+    pCtx->conv = mixeng_conv[(cChannels == 2)? 1: 0] /* stereo */
+                            [!fUnsigned]             /* sign */
+                            [0]                      /* big endian */
+                            [bitIdx];                /* bits */
+
+    if (iSampleHz && iSampleHz != pCtx->phw->info.freq)
+    {
+        pCtx->rate = st_rate_start (iSampleHz, pCtx->phw->info.freq);
+        pCtx->iFreq = iSampleHz;
+    }
+
+    return rc;
+}
+
+static DECLCALLBACK(int) iface_AudioInputEventData (PPDMIAUDIOSNIFFERPORT pInterface,
+                                                    void *pvContext,
+                                                    const void *pvData,
+                                                    uint32_t cbData)
+{
+    AUDIOSNIFFERSTATE *pThis = RT_FROM_MEMBER(pInterface, AUDIOSNIFFERSTATE, IPort);
+
+    int rc = VINF_SUCCESS;
+
+    SnifferInputCtx *pCtx = (SnifferInputCtx *)pvContext;
+
+    Log(("FilterAudio: AudioInputEventData: pvData %p. cbData %d, ended %d\n", pvData, cbData, pCtx->fEndedByFilter));
+
+    Assert(g_pData == pThis);
+
+    if (   !pCtx->fEndedByFilter
+        && pCtx->conv)
+    {
+        /* Convert PCM samples to st_sample_t.
+         * And then apply rate convertion if necessary.
+         */
+        /* @todo Optimization: allocate ps buffer once per context and reallocate if cbData changes. */
+        uint32_t cs = cbData / pCtx->cBytesPerFrame;
+        st_sample_t *ps = (st_sample_t *)RTMemAlloc(cs * sizeof(st_sample_t));
+        if (ps)
+        {
+            void *pvSamplesRateDst = NULL;
+
+            void *pvSamples = NULL;
+            uint32_t cbSamples = 0;
+
+            pCtx->conv(ps, pvData, cs, &nominal_volume);
+
+            if (pCtx->rate)
+            {
+                uint32_t csConverted = (cs * pCtx->phw->info.freq) / pCtx->iFreq;
+                pvSamplesRateDst = RTMemAlloc(csConverted * sizeof(st_sample_t));
+
+                if (pvSamplesRateDst)
+                {
+                    int csSrc = cs;
+                    int csDst = csConverted;
+
+                    st_rate_flow (pCtx->rate,
+                                  ps, (st_sample_t *)pvSamplesRateDst,
+                                  &csSrc, &csDst);
+
+                    pvSamples = pvSamplesRateDst;
+                    cbSamples = csDst * sizeof(st_sample_t);
+                }
+                else
+                {
+                    rc = VERR_NO_MEMORY;
+                }
+            }
+            else
+            {
+                pvSamples = ps;
+                cbSamples = cs * sizeof(st_sample_t);
+            }
+
+            if (cbSamples)
+            {
+                rc = pCtx->pfnFilterCallback(pCtx->pvFilterCallback, cbSamples, pvSamples);
+            }
+
+            RTMemFree(pvSamplesRateDst);
+            RTMemFree(ps);
+        }
+        else
+        {
+            rc = VERR_NO_MEMORY;
+        }
+    }
+
+    return rc;
+}
+
+static DECLCALLBACK(void) iface_AudioInputEventEnd (PPDMIAUDIOSNIFFERPORT pInterface,
+                                                    void *pvContext)
+{
+    int32_t c;
+
+    AUDIOSNIFFERSTATE *pThis = RT_FROM_MEMBER(pInterface, AUDIOSNIFFERSTATE, IPort);
+
+    SnifferInputCtx *pCtx = (SnifferInputCtx *)pvContext;
+
+    Log(("FilterAudio: AudioInputEventEnd: ended %d\n", pCtx->fEndedByFilter));
+
+    Assert(g_pData == pThis);
+
+    c = ASMAtomicDecU32(&pCtx->cRefs);
+
+    if (c == 0)
+    {
+        /* The caller will not use this context anymore. */
+        if (pCtx->rate)
+        {
+            st_rate_stop (pCtx->rate);
+        }
+        RTMemFree(pCtx);
+    }
+}
+
 
 static DECLCALLBACK(int) iface_Setup (PPDMIAUDIOSNIFFERPORT pInterface, bool fEnable, bool fKeepHostAudio)
@@ -159 +494 @@
      * Validate configuration.
      */
-    if (!CFGMR3AreValuesValid(pCfgHandle, "\0"))
+    if (!CFGMR3AreValuesValid(pCfgHandle, "InterceptAudioInput\0"))
     {
         return VERR_PDM_DEVINS_UNKNOWN_CFG_VALUES;
@@ -170 +505 @@
     pThis->fKeepHostAudio = true;
     pThis->pDrv = NULL;
+    rc = CFGMR3QueryBoolDef(pCfgHandle, "InterceptAudioInput", &pThis->fInterceptAudioInput, false);
+    if (RT_FAILURE(rc))
+        return PDMDEV_SET_ERROR(pDevIns, rc,
+                                N_("Configuration error: Failed to get the \"YieldOnLSRRead\" value"));
 
     /*
@@ -179 +518 @@
     /* Audio Sniffer port */
     pThis->IPort.pfnSetup = iface_Setup;
+    pThis->IPort.pfnAudioInputIntercept = iface_AudioInputIntercept;
+    pThis->IPort.pfnAudioInputEventBegin = iface_AudioInputEventBegin;
+    pThis->IPort.pfnAudioInputEventData = iface_AudioInputEventData;
+    pThis->IPort.pfnAudioInputEventEnd = iface_AudioInputEventEnd;
 
     /*

trunk/src/VBox/Devices/Makefile.kmk

@@ -794 +794 @@
         Audio/mixeng.c \
         Audio/noaudio.c \
+        Audio/filteraudio.c \
         Input/DrvKeyboardQueue.cpp \
         Input/DrvMouseQueue.cpp \