Megosztás a következőn keresztül:

Útmutató: XAPO létrehozása

  • Cikk

A XAPO API biztosítja a IXAPO felületet, valamint a CXAPOBase osztályt az új XAPO-típusok létrehozásához. Az IXAPO felület tartalmazza az összes metódust, amelyet implementálnunk kell egy új XAPO létrehozásához. A CXAPOBase osztály a IXAPO felület alapszintű implementációját biztosítja. CXAPOBase implementálja az összes IXAPO interfészmetódust, kivéve az IXAPO::P rocess metódust, amely egyedi az egyes XAPO-khoz.

Új statikus XAPO létrehozása

  1. Új XAPO-osztályt származtat a CXAPOBase alaposztályból.

    Jegyzet

    Az XAPOs implementálja a IUnknown felületet. Az IXAPO és IXAPOParameters interfészek a három IUnknown metódust tartalmazzák: QueryInterface, AddRefés Release. CXAPOBase mindhárom IUnknown metódus implementálását biztosítja. A CXAPOBase új példánya 1 hivatkozási számot fog kapni. A hivatkozási szám 0-ra változásakor el lesz pusztítva. Ha azt szeretné, hogy az XAudio2 megsemmisítse az XAPO egy példányát, amikor már nincs rá szükség, hívja meg IUnknown::Release az XAPO-n, miután hozzáadta az XAudio2 effektuslánchoz. Az XAPO-nak az XAudio2-vel való használatáról további információkat a : Az XAPO használata az XAudio2-ben részben talál.

     

  2. A IXAPO::LockForProcess metódus CXAPOBase osztály implementációjának felülbírálása.

    A LockForProcess felülírásával a hangadatok formátumára vonatkozó információk tárolhatók a IXAPO::Processszámára.

  3. Hajtsa végre az IXAPO::Process metódust.

    Az XAudio2 meghívja az IXAPO::P rocess metódust, amikor egy XAPO-nak hangadatokat kell feldolgoznia. Folyamat egy XAPO kódjának nagy részét tartalmazza.

A folyamatmetódus implementálása

Az IXAPO::Process metódus streampuffereket fogad a bemeneti és kimeneti hangadatok fogadására. Egy tipikus XAPO egy bemeneti streampufferre és egy kimeneti streampufferre számíthat. A bemeneti adatfolyam pufferéből származó adatok feldolgozását a LockForProcess függvényben megadott formátumra kell alapoznia, valamint az Folyamat függvénynek a bemeneti adatfolyam pufferrel átadott jelzőire. Másolja a feldolgozott bemeneti adatfolyam pufferadatait a kimeneti stream pufferbe. Állítsa be a kimeneti streampuffer BufferFlags paraméterét XAPO_BUFFER_VALID vagy XAPO_BUFFER_SILENT.

Az alábbi példa egy LockForProcess és Process implementációt mutat be, amely egyszerűen átmásolja az adatokat egy bemeneti pufferből egy kimeneti pufferbe. Nincs azonban feldolgozás, ha a bemeneti puffer XAPO_BUFFER_SILENTvan megjelölve.

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

}

Ha Process módszert ír, fontos megjegyezni, hogy az XAudio2 hangadatok át vannak váltogatva. Ez azt jelenti, hogy az egyes csatornák adatai egy adott mintaszámnál egymás mellett helyezkednek el. Ha például egy 4 csatornás hullám játszódik le egy XAudio2-forráshangban, a hangadatok a 0. csatorna mintája, az 1. csatorna mintája, a 2. csatorna mintája, a 3. csatorna mintája, majd a 0, 1, 2, 3 stb. csatornák következő mintája.

Hangeffektusok

XAPO áttekintése