Delen via

Handleiding voor: Een XAPO maken

  • Artikel

De XAPO-API biedt de IXAPO--interface en de CXAPOBase--klasse voor het bouwen van nieuwe XAPO-typen. De IXAPO--interface bevat alle methoden die moeten worden geïmplementeerd om een nieuwe XAPO te maken. De klasse CXAPOBase biedt een eenvoudige implementatie van de IXAPO interface. CXAPOBase implementeert alle IXAPO interfacemethoden, met uitzondering van de IXAPO::P rocess methode, die uniek is voor elke XAPO.

Om een nieuwe statische XAPO te maken

  1. Leid een nieuwe XAPO-klasse af van de CXAPOBase basisklasse.

    Notitie

    XAPOs voeren de IUnknown interface uit. De IXAPO en IXAPOParameters interfaces bevatten de drie IUnknown methoden: QueryInterface, AddRefen Release. CXAPOBase biedt implementaties van alle drie de IUnknown methoden. Een nieuw exemplaar van CXAPOBase heeft een referentieaantal van 1. Het wordt vernietigd wanneer het aantal verwijzingen 0 wordt. Als u wilt toestaan dat XAudio2 een exemplaar van een XAPO vernietigt wanneer deze niet meer nodig is, roept u IUnknown::Release op de XAPO nadat deze is toegevoegd aan een XAudio2-effectketen. Zie Procedure: Een XAPO gebruiken in XAudio2 voor meer informatie over het gebruik van een XAPO met XAudio2.

     

  2. Overschrijf de CXAPOBase--klasse-implementatie van de methode IXAPO::LockForProcess.

    Door LockForProcess te overschrijven, kan informatie over de indeling van audiogegevens worden opgeslagen voor gebruik in IXAPO::P rocess.

  3. Implementeer de methode IXAPO::P rocess.

    XAudio2 roept de IXAPO::P rocess methode aan wanneer een XAPO audiogegevens moet verwerken. Process bevat het grootste deel van de code voor een XAPO.

De procesmethode implementeren

De methode IXAPO::P rocess accepteert stroombuffers voor invoer- en uitvoeraudiogegevens. Een typische XAPO verwacht één invoerstroombuffer en één uitvoerstroombuffer. U moet de verwerking van gegevens uit de invoerstroombuffer baseren op de indeling die is opgegeven in de functie LockForProcess en eventuele vlaggen die worden doorgegeven aan de functie Proces met de invoerstroombuffer. Kopieer de verwerkte invoerstroombuffergegevens naar de uitvoerstroombuffer. Stel de bufferflagsparameter van de uitvoerstroom in als XAPO_BUFFER_VALID of XAPO_BUFFER_SILENT.

In het volgende voorbeeld ziet u een LockForProcess-- en proces--implementatie waarmee eenvoudig gegevens worden gekopieerd van een invoerbuffer naar een uitvoerbuffer. Er is echter geen verwerking als de invoerbuffer is gemarkeerd met XAPO_BUFFER_SILENT.

STDMETHOD(LockForProcess) (UINT32 InputLockedParameterCount,
          const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pInputLockedParameters,
          UINT32 OutputLockedParameterCount,
          const XAPO_LOCKFORPROCESS_BUFFER_PARAMETERS* pOutputLockedParameters)
{
    assert(!IsLocked());
    assert(InputLockedParameterCount == 1);
    assert(OutputLockedParameterCount == 1);
    assert(pInputLockedParameters != NULL);
    assert(pOutputLockedParameters != NULL);
    assert(pInputLockedParameters[0].pFormat != NULL);
    assert(pOutputLockedParameters[0].pFormat != NULL);


    m_uChannels = pInputLockedParameters[0].pFormat->nChannels;
    m_uBytesPerSample = (pInputLockedParameters[0].pFormat->wBitsPerSample >> 3);

    return CXAPOBase::LockForProcess(
        InputLockedParameterCount,
        pInputLockedParameters,
        OutputLockedParameterCount,
        pOutputLockedParameters);
}
STDMETHOD_(void, Process)(UINT32 InputProcessParameterCount,
           const XAPO_PROCESS_BUFFER_PARAMETERS* pInputProcessParameters,
           UINT32 OutputProcessParameterCount,
           XAPO_PROCESS_BUFFER_PARAMETERS* pOutputProcessParameters,
           BOOL IsEnabled)
{
    assert(IsLocked());
    assert(InputProcessParameterCount == 1);
    assert(OutputProcessParameterCount == 1);
    assert(NULL != pInputProcessParameters);
    assert(NULL != pOutputProcessParameters);


    XAPO_BUFFER_FLAGS inFlags = pInputProcessParameters[0].BufferFlags;
    XAPO_BUFFER_FLAGS outFlags = pOutputProcessParameters[0].BufferFlags;

    // assert buffer flags are legitimate
    assert(inFlags == XAPO_BUFFER_VALID || inFlags == XAPO_BUFFER_SILENT);
    assert(outFlags == XAPO_BUFFER_VALID || outFlags == XAPO_BUFFER_SILENT);

    // check input APO_BUFFER_FLAGS
    switch (inFlags)
    {
    case XAPO_BUFFER_VALID:
        {
            void* pvSrc = pInputProcessParameters[0].pBuffer;
            assert(pvSrc != NULL);

            void* pvDst = pOutputProcessParameters[0].pBuffer;
            assert(pvDst != NULL);

            memcpy(pvDst,pvSrc,pInputProcessParameters[0].ValidFrameCount * m_uChannels * m_uBytesPerSample);
            break;
        }

    case XAPO_BUFFER_SILENT:
        {
            // All that needs to be done for this case is setting the
            // output buffer flag to XAPO_BUFFER_SILENT which is done below.
            break;
        }

    }

    // set destination valid frame count, and buffer flags
    pOutputProcessParameters[0].ValidFrameCount = pInputProcessParameters[0].ValidFrameCount; // set destination frame count same as source
    pOutputProcessParameters[0].BufferFlags     = pInputProcessParameters[0].BufferFlags;     // set destination buffer flags same as source

}

Bij het schrijven van een methode Proces, is het belangrijk om te weten dat XAudio2-audiogegevens onderling zijn verbonden. Dit betekent dat gegevens uit elk kanaal grenzen aan een bepaald voorbeeldnummer. Als er bijvoorbeeld een 4-kanaals golf wordt afgespeeld in een XAudio2-bronstem, zijn de audiogegevens een voorbeeld van kanaal 0, een voorbeeld van kanaal 1, een voorbeeld van kanaal 2, een voorbeeld van kanaal 3 en vervolgens het volgende voorbeeld van kanalen 0, 1, 2, 3, enzovoort.

Audio-effecten

XAPO-overzicht