Condividi tramite

Recupero di eventi di anatraggio

  • Articolo

Un'applicazione multimediale che vuole offrire un'esperienza personalizzata di anatraggio deve essere in ascolto delle notifiche degli eventi quando un flusso di comunicazione viene aperto o chiuso nel sistema. L'implementazione personalizzata può essere fornita tramite MediaFoundation, DirectShow o DirectSound, che usano le API Audio principali. Un client WASAPI diretto può anche eseguire l'override della gestione predefinita se sa quando viene avviata e terminata la sessione di comunicazione.

Per fornire un'implementazione personalizzata, un'applicazione multimediale deve ricevere notifiche dal sistema quando un'applicazione di comunicazione avvia o termina un flusso di comunicazione. L'applicazione multimediale deve implementare l'interfaccia IAudioVolumeDuckNotification e registrare l'implementazione con il sistema audio. Al termine della registrazione, l'applicazione multimediale riceve notifiche degli eventi sotto forma di callback tramite i metodi nell'interfaccia. Per altre informazioni, vedere Considerazioni sull'implementazione per le notifiche di ducking.

Per inviare notifiche di anatraggio, il sistema audio deve sapere quale sessione audio è in ascolto degli eventi di anatraggio. Ogni sessione audio viene identificata in modo univoco con un GUID, ovvero l'identificatore dell'istanza di sessione. Gestione sessioni consente a un'applicazione di ottenere informazioni sulla sessione, ad esempio il titolo della sessione audio, lo stato di rendering e l'identificatore dell'istanza di sessione. L'identificatore può essere recuperato usando l'interfaccia del controllo dei criteri IAudioSessionControl2.

I passaggi seguenti riepilogano il processo di recupero dell'identificatore dell'istanza di sessione dell'applicazione multimediale:

  1. Creare un'istanza dell'enumeratore del dispositivo e usarlo per ottenere un riferimento all'endpoint del dispositivo usato dall'applicazione multimediale per eseguire il rendering del flusso non di comunicazione.
  2. Attivare il gestore di sessioni dall'endpoint del dispositivo e ottenere un riferimento all'interfaccia IAudioSessionManager2 del gestore sessione.
  3. Usando il puntatore IAudioSessionManager2, ottenere un riferimento all'interfaccia IAudioSessionControl del gestore sessione.
  4. Eseguire una query per IAudioSessionControl2 dall'interfaccia IAudioSessionControl.
  5. Chiama IAudioSessionControl2::GetSessionInstanceIdentifier e recupera una stringa contenente l'identificatore di sessione per la sessione audio corrente.

Per ricevere notifiche di anatraggio sui flussi di comunicazione, l'applicazione multimediale chiama IAudioSessionManager2::RegisterDuckNotification. L'applicazione multimediale fornisce l'identificatore dell'istanza di sessione al sistema audio e un puntatore all'implementazione di IAudioVolumeDuckNotification . L'applicazione può ora ricevere la notifica degli eventi quando un flusso aperto nel dispositivo di comunicazione. Per interrompere la notifica, l'applicazione multimediale deve chiamare IAudioSessionManager2::UnregisterDuckNotification.

Il codice seguente illustra come un'applicazione può registrarsi per ricevere notifiche di anatraggio. La classe CMediaPlayer è definita in Considerazioni sull'implementazione per le notifiche di anatraggio. L'esempio DuckingMediaPlayer implementa questa funzionalità.

////////////////////////////////////////////////////////////////////
//Description: Registers for duck notifications depending on the 
//             the ducking options specified by the caller.
//Parameters: 
//    If DuckingOptOutChecked is TRUE, the client is registered for
//    to receive ducking notifications; 
//    FALSE, the client's registration is deleted.
////////////////////////////////////////////////////////////////////

HRESULT CMediaPlayer::DuckingOptOut(bool DuckingOptOutChecked)
{
    HRESULT hr = S_OK;

    IMMDeviceEnumerator* pDeviceEnumerator NULL;
    IMMDevice* pEndpoint = NULL;
    IAudioSessionManager2* pSessionManager2 = NULL;
    IAudioSessionControl* pSessionControl = NULL;
    IAudioSessionControl2* pSessionControl2 = NULL;

    LPWSTR sessionId = NULL;

    //  Start with the default endpoint.

    hr = CoCreateInstance(__uuidof(MMDeviceEnumerator), 
                          NULL, 
                          CLSCTX_INPROC_SERVER, 
                          IID_PPV_ARGS(&pDeviceEnumerator));
    
    if (SUCCEEDED(hr))
    {
        hr = pDeviceEnumerator>GetDefaultAudioEndpoint(
              eRender, eConsole, &pEndpoint);

        pDeviceEnumerator>Release();
        pDeviceEnumerator = NULL;
    }

    // Activate the session manager.
    if (SUCCEEDED(hr))
    {
        hr = pEndpoint->Activate(__uuidof(IAudioSessionManager2), 
                                 CLSCTX_INPROC_SERVER,
                                 NULL, 
                                 reinterpret_cast<void **>
                                 (&pSessionManager2));
        pEndpoint->Release();
        pEndpoint = NULL;
    }
    if (SUCCEEDED(hr))
    {
        hr = pSessionManager2->GetAudioSessionControl(
                                  NULL, 0, &pSessionControl);
        
    }

    if (SUCCEEDED(hr))
    {
        hr = pSessionControl->QueryInterface(
                               IID_PPV_ARGS(&pSessionControl2));
                
        pSessionControl->Release();
        pSessionControl = NULL;
    }

    // Get the session instance identifier.
    
    if (SUCCEEDED(hr))
    {
        hr = pSessionControl2->GetSessionInstanceIdentifier(
                                 sessionId);
                
        pSessionControl2->Release();
        pSessionControl2 = NULL;
    }

    //  Register for ducking events depending on 
    //  the specified preference.

    if (SUCCEEDED(hr))
    {
        if (DuckingOptOutChecked)
        {
            hr = pSessionManager2->RegisterDuckNotification(
                                    sessionId, this);
        }
        else
        {
            hr = pSessionManager2->UnregisterDuckNotification
                                      (FALSE);
        }
        pSessionManager2->Release();
        pSessionManager2 = NULL;
    }
    return hr;
}

Uso di un dispositivo di comunicazione

Esperienza predefinita di anatraggio

Disabilitazione dell'esperienza predefinita di ducking

Fornire un comportamento personalizzato di anatraggio

Considerazioni sull'implementazione per le notifiche di ducking