[C++] WASAPI loopback playing

[Robain]

Hellow everyone,


Ik ben aan het proberen om een loopback player te maken (audio dat speelt op een bepaald audio endpoint opnieuw afspelen op een ander endpoint). Bij wijze van oefening wil ik hervoor de nieuwe vista audio api's gebruiken, en mijn oog is gevallen op wasapi.

Echter, het werkt niet. Het spelen op een endpoint apart, werkt. Het recorden van een endpoint in loopback mode, werkt. Echter, wanneer ik de 2 stukken tesamen breng, en ze dezelfde buffer laat gebruiken, loopt het mis.
De capture buffer, lijkt zelfs steeds leeg te zijn, waardoor ik vermoed dat het endpoint zelfs niet in loopback geactiveerd te zijn. Zeer raar...

Misschien dat eimand die al wat ervaring heeft met wasapi 5 minuutjes de tijd heeft om de code even te doorlopen? Mijn excuses, het is nog dirty code, ik ben nog maar aan het uitzoeken of het uberhaubt kan...

code:

HRESULT hr;
   
    //Variables for getting from and to endpoints
    IMMDevice *pEndpointFrom = NULL;
    IMMDevice *pEndpointTo = NULL;
    IMMDeviceEnumerator *pEnumerator = NULL;
    IMMDeviceCollection *pCollection = NULL;

    //Variables for capturing
    REFERENCE_TIME hnsRequestedDuration = REFTIMES_PER_SEC;
    REFERENCE_TIME hnsActualDuration;
    IAudioClient *pAudioClientFrom = NULL;
    IAudioClient *pAudioClientTo = NULL;

    IAudioRenderClient *pRenderClient = NULL;
    IAudioCaptureClient *pCaptureClient = NULL;

    WAVEFORMATEX *pwfx = NULL;
    UINT32 bufferFrameCountFrom;
    UINT32 bufferFrameCountTo;
    UINT32 numFramesAvailable;
    UINT32 numFramesPadding;
    BYTE *pData;
    UINT32 packetLength = 0;
    DWORD flags = 0;

    HANDLE hEvent = NULL;
    HANDLE hTask = NULL;


    //Get COM stuff figured out
    hr = CoCreateInstance(
           CLSID_MMDeviceEnumerator, NULL,
           CLSCTX_ALL, IID_IMMDeviceEnumerator,
           (void**)&pEnumerator);
    EXIT_ON_ERROR(hr)

    //Get all audio endpoints
    hr = pEnumerator->EnumAudioEndpoints(
                        eRender, DEVICE_STATE_ACTIVE | DEVICE_STATE_UNPLUGGED,
                        &pCollection);
    EXIT_ON_ERROR(hr)

    UINT count;
    hr = pCollection->GetCount(&count);
    EXIT_ON_ERROR(hr)

    if (count == 0){
        throw gcnew System::Exception("No endpoints detected"); 
    }

    //Select FROM and TO endpoints
    hr = pCollection->Item(from, &pEndpointFrom);
    hr = pCollection->Item(to, &pEndpointTo);
    EXIT_ON_ERROR(hr)

    // Activate FROM endpoint
    hr = pEndpointFrom->Activate(
                    IID_IAudioClient, CLSCTX_ALL,
                    NULL, (void**)&pAudioClientFrom);
    EXIT_ON_ERROR(hr)
   
    //Activate TO endpoint
    hr = pEndpointTo->Activate(
                    IID_IAudioClient2, CLSCTX_ALL,
                    NULL, (void**)&pAudioClientTo);
    EXIT_ON_ERROR(hr)

    //Get mix format from either from or to device
    hr = pAudioClientFrom->GetMixFormat(&pwfx);
    EXIT_ON_ERROR(hr)

    //Activate FROM audioclient
    hr = pAudioClientFrom->Initialize(
                         AUDCLNT_SHAREMODE_SHARED,
                         AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_LOOPBACK,
                         hnsRequestedDuration,
                         0,
                         pwfx,
                         NULL);
    EXIT_ON_ERROR(hr)

    // Activate TO audioclient
    hr = pAudioClientTo->Initialize(
                         AUDCLNT_SHAREMODE_SHARED,
                         0,
                         hnsRequestedDuration,
                         0,
                         pwfx,
                         NULL);
    EXIT_ON_ERROR(hr)

    // Create an event handle and register it for buffer-event notifications.
    hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (hEvent == NULL){
        hr = E_FAIL;
        goto Exit;
    }

    hr = pAudioClientFrom->SetEventHandle(hEvent);
    EXIT_ON_ERROR(hr);

    // Get the actual size of the two allocated buffers.
    hr = pAudioClientFrom->GetBufferSize(&bufferFrameCountFrom);
    EXIT_ON_ERROR(hr)

    hr = pAudioClientFrom->GetService(
                         IID_IAudioCaptureClient,
                         (void**)&pCaptureClient);
    EXIT_ON_ERROR(hr)

    // Get the size of the allocated buffer.
    hr = pAudioClientTo->GetBufferSize(&bufferFrameCountTo);
    EXIT_ON_ERROR(hr)

    hr = pAudioClientTo->GetService(
                         IID_IAudioRenderClient,
                         (void**)&pRenderClient);
    EXIT_ON_ERROR(hr)


    // Load the first buffer with data from the audio source before starting the stream.
    hr = pRenderClient->GetBuffer(bufferFrameCountTo, &pData);
    EXIT_ON_ERROR(hr)

    //Check if there is any data in the capture buffer
    hr = pCaptureClient->GetNextPacketSize(&packetLength);
    EXIT_ON_ERROR(hr)

    while (packetLength != 0)
    {
        // Get the available data in the shared buffer.
        hr = pCaptureClient->GetBuffer(
                               &pData,
                               &numFramesAvailable,
                               &flags, NULL, NULL);
        EXIT_ON_ERROR(hr)

        hr = pCaptureClient->ReleaseBuffer(numFramesAvailable);
        EXIT_ON_ERROR(hr)

        hr = pCaptureClient->GetNextPacketSize(&packetLength);
        EXIT_ON_ERROR(hr)
    }

    hr = pRenderClient->ReleaseBuffer(bufferFrameCountTo, flags);
    EXIT_ON_ERROR(hr)


    hr = pAudioClientFrom->Start();  // Start playing.
    hr = pAudioClientTo->Start();  // Start capturing.
    EXIT_ON_ERROR(hr)

    bool test = true;

    // Each loop fills one of the two buffers.
    while (test)
    {
        // Wait for next buffer event to be signaled.
        DWORD retval = WaitForSingleObject(hEvent, INFINITE);
        if (retval != WAIT_OBJECT_0)
        {
            // Event handle timed out after a 2-second wait.
            pAudioClientFrom->Stop();
            hr = ERROR_TIMEOUT;
            goto Exit;
        }

        // Grab the next empty buffer from the audio device.
        hr = pRenderClient->GetBuffer(bufferFrameCountTo, &pData);
        EXIT_ON_ERROR(hr)

           //Check if there is any data in the capture buffer
        hr = pCaptureClient->GetNextPacketSize(&packetLength);
        EXIT_ON_ERROR(hr)

        while (packetLength != 0)
        {
            // Get the available data in the shared buffer.
            hr = pCaptureClient->GetBuffer(
                                   &pData,
                                   &numFramesAvailable,
                                   &flags, NULL, NULL);
            EXIT_ON_ERROR(hr)

            hr = pCaptureClient->ReleaseBuffer(numFramesAvailable);
            EXIT_ON_ERROR(hr)

            hr = pCaptureClient->GetNextPacketSize(&packetLength);
            EXIT_ON_ERROR(hr)
        }

        hr = pRenderClient->ReleaseBuffer(bufferFrameCountTo, flags);
        EXIT_ON_ERROR(hr)
    }

[MLM]

Ik ga niet heel je code doorspitten, maar denk er aan dat je niet DEZELFDE buffer tegelijk kan gebruiken voor read en write, je gaat er meer nodig hebben omdat je buffer niet gelijk vol is (immers, het kost tijd om de audio af te spelen). Denk bijvoorbeeld:

T=1
source -> buffer 1

T=2
source -> buffer 2
buffer 1 -> target

T=3
source -> buffer 3
buffer 2 -> target

[Robain]

Welja dat doe ik nu, min of meer eigenlijk. Wasapi biedt namelijk zelf een systeem aan zodat elk endpoint meerdere buffers ter beschikking heeft.

Ik had misschien beter enkel de afspeellus code geplaatst, al de rest is immers voorbereiding en initialisatie. Vanaf regel 157 t.e.m. 194 zie je het eigenlijke afspelen.

Wat er dus gebeurt:
- Vooraf heb ik een eventhandler aan de buffers van het capture endpoint gehangen
- Vervolgens een lus die :
- Wacht tot dat er data beschikbaar is in een capture buffer
- Deze data kopieert naar een lege render buffer van het render endpoint

In principe heb ik hierbij geen intermediaire buffer nodig, right?

[MLM]

...hmmm...

[ Voor 95% gewijzigd door MLM op 28-12-2008 23:38 . Reden: foutje :x ]

[Robain]

Voor de mensen die het ooit nuttig zouden kunnen vinden, het probleem zat in dit stukje code :

C++:

//Activate FROM audioclient
    hr = pAudioClientFrom->Initialize(
                         AUDCLNT_SHAREMODE_SHARED,
                         AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_LOOPBACK,
                         hnsRequestedDuration,
                         0,
                         pwfx,
                         NULL);

Meerbepaald in AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_LOOPBACK. Dit zou ervoor moeten zorgen dat het endpoint in loopback mode geactiveerd wordt, en dat er een event gegenereerd wordt wanneer er audio data klaar staat in de buffer om op te vangen.

De code voert perfect uit, en zelfs de pAudioClient->SetEventHandle(...) voert perfect uit. Echter, er zal nooit een event opgeworpen om te melden dat er audio data klaar staat.
Zucht, kunnen die kl**tzakken bij microsoft nu in godsnaam nooit iets goed doen. Dan ontwerpen ze een volledig nieuwe technologie voor hun audio stack en zijn ze verbaasd dat niemand het begrijpt...

De persoon die dit aan het licht bracht en meer info, is hier te vinden : klik

[ Voor 41% gewijzigd door Robain op 09-01-2009 10:49 ]