Beveiligde gebruikersmodusaudio (PUMA)

Artikel
03/12/2025

Windows Vista heeft audio voor beveiligde gebruikersmodus (PUMA) geïntroduceerd, de audio-engine voor de gebruikersmodus in pe (Protected Environment) die een veiligere omgeving biedt voor audioverwerking en -rendering. Hiermee kunnen alleen de acceptabele audio-uitvoer worden ingeschakeld en zorgt u ervoor dat de uitvoer betrouwbaar is uitgeschakeld. Zie Output Content Protection en Windows Vistavoor meer informatie over PUMA.

PUMA is bijgewerkt voor Windows 7 om de volgende functies te bieden:

SCMS-bits (Serial Copying Management System) instellen op S/PDIF-eindpunten en HDCP-bits (High-bandwidth Digital Content Protection) op High-Definition HDMI-eindpunten (Multimedia Interface).
SCMS- en HDMI-beveiligingsmaatregelen buiten een beveiligde omgeving (PE) inschakelen.

DRM-beveiliging in audiostuurprogramma's

Digital Rights Management (DRM) biedt de mogelijkheid om mediagegevens in een beveiligde container te verpakken en gebruiksregels toe te voegen aan de inhoud. De inhoudsprovider kan bijvoorbeeld Copy Protection of Digitale uitvoer uitschakelen gebruiken om directe digitale kopieën of verzending uit het pc-systeem uit te schakelen.

De audiostack in bepaalde Microsoft-producten ondersteunt DRM door de gebruiksregels te implementeren die het afspelen van de audio-inhoud regelen. Als u de beveiligde inhoud wilt afspelen, moet het onderliggende audiostuurprogramma een vertrouwd stuurprogramma zijn; Dat wil gezegd, het stuurprogramma moet zijn gecertificeerd voor DRMLevel 1300. Voor informatie over het ontwikkelen van vertrouwde stuurprogramma's kunt u interfaces gebruiken die zijn gedefinieerd in de Windows 2000 Driver Development Kit (DDK) of hoger. Stuurprogramma's die zijn ontwikkeld met de DDK implementeren de benodigde interfaces voor DRM. Zie Digital Rights Managementvoor meer informatie.

Als u de beveiligde inhoud wilt weergeven, moet het vertrouwde stuurprogramma controleren of Copy Protection en Digitale uitvoer uitschakelen zijn ingesteld op de inhoud die door de audiostack stroomt en dienovereenkomstig op de instellingen reageert.

Kopieerbeveiligingsregel

Copy Protection geeft aan dat directe digitale kopieën niet zijn toegestaan op het systeem. Tentoonstel B aan de WHQL-testovereenkomst is bijgewerkt om de nieuwe verwachtingen en vereisten van een stuurprogramma weer te geven wanneer Copy Protection is ingesteld op de inhoud. Voor Windows 7 voldoet het ingebouwde stuurprogramma voor HD-audioklasse aan de nieuwste vereisten.

Naast ervoor te zorgen dat inhoud niet mag worden doorgegeven aan een ander onderdeel of mag worden opgeslagen op een niet-compatibel opslagmedium dat niet is geverifieerd door het DRM-systeem, voert het audiostuurprogramma de volgende taken uit wanneer Copy Protection- is ingesteld:

Het stuurprogramma schakelt HDCP in op HDMI-eindpunten.
Voor S/PDIF-interfaces valideert het stuurprogramma dat de combinatie van L-, Cp- en Categoriecode-bits een SCMS-status 'Nooit kopiëren' aangeeft, zoals gedefinieerd in IEC 60958.
De L-bit is ingesteld op 0 en de categoriecode is ingesteld op 'Digital Signal Mixer'.

De DRMRIGHTS structuur, die wordt gebruikt door vertrouwde audiostuurprogramma's, specificeert de DRM-inhoudsrechten die zijn toegewezen aan een KS-audiopin of aan het streamobject van een stuurprogramma van poortklasse. Het lid CopyProtect geeft aan of Copy Protection is ingesteld op de audio-inhoud.

Voor Windows 7 is het gebruik van CopyProtect strenger. Het stuurprogramma zorgt ervoor dat de beveiligingsbesturingselementen zijn ingesteld op de audiointerfaces, HDCP is ingesteld voor HDMI-uitvoer en SCMS is ingesteld voor S/PDIF-uitvoer door de status 'Nooit kopiëren' in te stellen.

Regel voor het uitschakelen van digitale uitvoer

Digitale uitvoer uitschakelen geeft aan dat de inhoud niet mag worden verzonden uit het systeem. In Windows 7 reageert het ingebouwde stuurprogramma van de HD-audioklasse op deze instelling door HDCP in te schakelen op HDMI-eindpunten. Dit is vergelijkbaar met het antwoord van het stuurprogramma op de instelling Copy Protection.

Mechanismen voor inhoudsbeveiliging buiten een beveiligde omgeving inschakelen

PUMA bevindt zich in een afzonderlijk proces in de Beveiligde omgeving (PE). Als u in Windows Vista de besturingselementen voor audio-inhoudsbeveiliging wilt gebruiken die door PUMA worden aangeboden, moet een mediatoepassing zich in een PE bevinden. Omdat alleen Media Foundation-API's kunnen communiceren met een PE, zijn de besturingselementen voor inhoudsbeveiliging beperkt tot toepassingen die Media Foundation-API's gebruiken om audio-inhoud te streamen.

In Windows 7 heeft elke toepassing toegang tot de besturingselementen voor inhoudsbeveiliging die worden geleverd door de PUMA Output Trust Authority (OTA), ongeacht of ze zich in een PE bevinden of Media Foundation-API's gebruiken voor het afspelen van audio.

Implementatie-instructies

De volgende stappen zijn vereist voor een audiotoepassing voor het beheren van SCMS- of HDCP-inhoudsbeveiliging op een audio-eindpunt. Ondersteunde audio-API's zijn DirectShow, DirectSound en WASAPI.

In deze voorbeeldcode worden de volgende interfaces gebruikt.

De mediatoepassing moet de volgende taken uitvoeren.

Stel de ontwikkelomgeving in.
- Verwijs naar de vereiste interfaces en neem de headers op die worden weergegeven in de volgende code.
```
#include <MMdeviceapi.h>        // Device endpoint definitions
#include <Mfidl.h>              // OTA interface definitions
```
- Link naar de Mfuuid.lib om de OTA-interfaces te gebruiken.
- Schakel het kernelfoutopsporingsprogramma en stuurprogrammacontrole uit om verificatiecontrolefouten te voorkomen.

Inventariseer alle eindpunten in het systeem en selecteer het doeleindpunt in de eindpuntverzameling, zoals wordt weergegeven in de volgende code. Zie Enumerating Audio Devicesvoor meer informatie over het inventariseren van apparaten.

BOOL IsDigitalEndpoint(IMMDevice *pDevice)
{
   PROPVARIANT         var;
   IPropertyStore      *pProperties = NULL;
   EndpointFormFactor  formfactor;
   BOOL                bResult = FALSE;
   HRESULT             hr = S_OK;
   PropVariantInit(&var);
   // Open endpoint properties
   hr = pDevice->OpenPropertyStore(STGM_READ, &pProperties);
   IF_FAILED_JUMP(hr, Exit);

   // get form factor 
   hr = pProperties->GetValue(PKEY_AudioEndpoint_FormFactor, &var);
   IF_FAILED_JUMP(hr, Exit);
   formfactor = (EndpointFormFactor)var.uiVal;
   // DigitalAudioDisplayDevice is defined same as HDMI formfactor
   if ((SPDIF == formfactor) || (DigitalAudioDisplayDevice == formfactor))
   {
       bResult = TRUE;
   }

Exit:
   PropVariantClear(&var);
   SAFE_RELEASE(pProperties);
   return bResult;
}

/******************************************************************
*                                                                 *
*  GetDevice:  Selects an endpoint that meets the requirements.   *
*                                                                 *
*  ppDevice: Receives a pointer to an IMMDevice interface of      *
*            the device's endpoint object                         *                                             *                                            *
*                                                                 *
******************************************************************/
HRESULT GetDevice(IMMDevice** ppDevice)
{
   IMMDeviceEnumerator    *pEnumerator = NULL;
   IMMDevice              *pDevice = NULL;
   IMMDeviceCollection    *pEndpoints = NULL;
   UINT                    cEndpoints = 0;

   const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
   const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);

   // Get enumerator for audio endpoint devices
   hr = CoCreateInstance(
       CLSID_MMDeviceEnumerator, 
       NULL,
       CLSCTX_ALL, 
       IID_IMMDeviceEnumerator,
       (void**)&pEnumerator));


   EXIT_ON_ERROR(hr)

   // Enumerate all active endpoints,
   hr = pEnumerator->EnumAudioEndpoints (
       eRender,
       DEVICE_STATE_ACTIVE,
       &pEndpoints);
   EXIT_ON_ERROR(hr)

   hr = pEndpoints->GetCount(&cEndpoints);
   EXIT_ON_ERROR(hr)

   for (UINT i = 0; i < cEndpoints; i++)
   {
       hr = pEndpoints->Item(i, &pDevice);
       IF_FAILED_JUMP(hr, Exit);
       {
           // Select the endpoint that meets the requirements.
           // For example, SPDIF analog output or HDMI
           if (IsDigitalEndpoint(pDevice))
           {
               *(ppDevice) = pDevice;
               (*ppDevice)->AddRef();
               break;
           }
       }
       SAFE_RELEASE(pDevice);
   }
Exit:
   if (FAILED(hr))
   {
       // Notify error.
       // Not Shown.
   }
   SAFE_RELEASE(pEndpoints);
   SAFE_RELEASE(pEnumerator);
}

Gebruik de IMMDevice- aanwijzer naar het eindpunt dat wordt geretourneerd door het opsommingsproces om de gewenste audiostreaming-API te activeren en streaming voor te bereiden. Voor verschillende audio-API's is iets anders voorbereiding vereist.
- Voor DShow-audiotoepassingen:
  1. Maak een DirectShow COM-object door IMMDevice::Activate aan te roepen en IID_IBaseFilter op te geven als interface-id.
```
IUnknown *pDShowFilter = NULL;
...
hr = pDevice->Activate (
                  IID_IBaseFilter,
                  CLSCTX_INPROC_SERVER, NULL,
                  reinterpret_cast<void **>(&pDShowFilter));
```
  2. Bouw een DirectShow-filtergrafiek met dit COM-object dat door het apparaat is geactiveerd. Zie 'De filtergrafiek bouwen' in de DirectShow SDK-documentatie voor meer informatie over dit proces.
- Voor DSound-audiotoepassingen:
  1. Maak een DSound COM-object door IMMDevice::Activate aan te roepen en IID_IDirectSound8 op te geven als interface-id.
```
IDirectSound8  *pDSSound8;
...
hr = pDevice->Activate (
                  IID_IDirectSound8,
                  CLSCTX_INPROC_SERVER, NULL,
                  reinterpret_cast<void **>(&pDSSound8));
```
  2. Gebruik het DSound-object dat hierboven is gemaakt om DSound te programmeren voor stoom. Zie DirectSoundvoor meer informatie over dit proces.
- Voor WASAPI:
  1. Maak een IAudioClient COM-object door IMMDevice::Activate aan te roepen en IID_IAudioClient op te geven als interface-id.
```
IAudioClient *pIAudioClient = NULL;
...
hr = pDevice->Activate (
                  IID_IAudioClient,
                  CLSCTX_INPROC_SERVER, NULL,
                  reinterpret_cast<void **>(&pIAudioClient));
```
  2. Open de audiostream.
```
hr = pIAudioClient->Initialize(...);
```
Audiostreaming starten.
Stel het beveiligingsbeleid voor de stream in.
1. Voor WASAPI-clients krijgt u een verwijzing naar de IMFTrustedOutput interface van het OTA-object (Output Trust Authority) voor de stream door IAudioClient::GetService aan te roepen en IID_IMFTrustedOutput op te geven als interface-id.
```
IMFTrustedOutput*       pTrustedOutput = NULL;
hr = pIAudioClient>GetService(
               __uuidof(IMFTrustedOutput),
               (void**)& pTrustedOutput);
```
2. Haal een telling van de beschikbare OTA-objecten op door IMFTrustedOutput::GetOutputTrustAuthorityCountaan te roepen.
```
hr = pTrustedOutput->GetOutputTrustAuthorityCount(&m_dwCountOTA);
```
3. Inventariseer de OTA-verzameling en haal een verwijzing op naar het OTA-object dat ondersteuning biedt voor de actie PEACTION_PLAY. Alle OTA's maken de interface IMFOutputTrustAuthority beschikbaar.
```
hr = pMFTrustedOutput->GetOutputTrustAuthorityByIndex(I, &pMFOutputTrustAuthority);
hr = pMFOutputTrustAuthority->GetAction(&action) 
```
4. Gebruik de interface IMFTrustedOutput om het beveiligingsbeleid voor de stream in te stellen.
```
hr = pTrustedOutput ->SetPolicy(&pPolicy, nPolicy, &pbTicket, &cbTicket);
```
  Notitie
  
  Als u de EVR gebruikt, genereert SetPolicy- de gebeurtenis MEPolicySet en retourneert MF_S_WAIT_FOR_POLICY_SET om aan te geven dat de OTA het beleid asynchroon afdwingt. In deze voorbeeldcode is de toepassing echter een directe WASAPI-client die het OTA-object van de audioclient heeft opgehaald (stap 5 a). In tegenstelling tot de EVR implementeert een audioclient en andere WASAPI-objecten geen mediagebeurtenisgeneratoren. Zonder mediagebeurtenisgeneratoren retourneert IMFTrustedOutput::SetPolicy geen MF_S_WAIT_FOR_POLICY_SET.
  
  De instellingen voor het audiobeleid moeten worden ingesteld nadat audiostreaming is gestart, anders IMFTrustedOutput::GetOutputTrustAuthorityByIndex mislukt. Om deze functie te ondersteunen, moet het onderliggende audiostuurprogramma ook een vertrouwd stuurprogramma zijn.
  
  In de voorbeeldcode is pPolicy- een aanwijzer naar de IMFOutputPolicy interface van een door de client geïmplementeerd beleidsobject. Zie Media Foundation SDK documentatie voor meer informatie.
  
  In de implementatie van de methode IMFOutputPolicy::GenerateRequiredSchemas moet een verzameling van de uitvoerbeveiligingssystemen (schema's) worden gegenereerd die de OTA moet afdwingen. Elk schema wordt geïdentificeerd door een GUID en bevat configuratiegegevens voor het beveiligingssysteem. Zorg ervoor dat de beveiligingssystemen in de verzameling zijn beperkt tot het gebruik van vertrouwde audiostuurprogramma's. Deze beperking wordt geïdentificeerd door de GUID, MFPROTECTION_TRUSTEDAUDIODRIVERS, DISABLE of CONSTRICTAUDIO. Als MFPROTECTION_TRUSTEDAUDIODRIVERS wordt gebruikt, zijn de configuratiegegevens voor dit schema een DWORD. Zie de sdk-documentatie voor beveiligde omgevingen voor meer informatie over de schema's en de gerelateerde configuratiegegevens.
  
  De client moet ook de schemadefinitie opgeven door de interface IMFOutputSchema te implementeren. IMFOutputSchema::GetSchemaType haalt MFPROTECTION_TRUSTEDAUDIODRIVERS op als schema-GUID. IMFOutputSchema::GetConfigurationData retourneert een aanwijzer naar de configuratiegegevens van het schema.
Doorgaan met streamen van audio.
Zorg ervoor dat het beveiligingsbeleid duidelijk is voordat u streaming stopt.

Laat de gerelateerde beleidsinterfaceverwijzingen hierboven los.

De release-aanroepen wissen de eerder ingestelde beleidsinstellingen.

Notitie

Telkens wanneer een stream opnieuw wordt opgestart, moet het beveiligingsbeleid opnieuw worden ingesteld op de stream. De procedure wordt beschreven in stap 5d.
```
pMFOutputTrustAuthority->Release()
pMFTrustedOutput->Release()
```

In de volgende codevoorbeelden ziet u een voorbeeld van de implementatie van de beleids- en schemaobjecten.

//OTADsoundSample.cpp
#include <stdio.h>
#include <tchar.h>
#include <initguid.h>
#include <windows.h>
#include <mmreg.h>
#include <dsound.h>

#include <mfidl.h>
#include <Mmdeviceapi.h>
#include <AVEndpointKeys.h>
#include "OTADSoundSample.h"

#define STATIC_KSDATAFORMAT_SUBTYPE_AC3\
    DEFINE_WAVEFORMATEX_GUID(WAVE_FORMAT_DOLBY_AC3_SPDIF)
DEFINE_GUIDSTRUCT("00000092-0000-0010-8000-00aa00389b71", KSDATAFORMAT_SUBTYPE_AC3);
#define KSDATAFORMAT_SUBTYPE_AC3 DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_AC3)


HRESULT SetOTAPolicy(IMMDevice *_pMMDevice,
                     DWORD _dwConfigData,
                     IMFTrustedOutput **_ppMFTrustedOutput,
                     IMFOutputTrustAuthority **ppMFOutputTrustAuthority,
                     IMFOutputPolicy **_ppMFOutputPolicy);
HRESULT ClearOTAPolicy(IMFTrustedOutput *_pMFTrustedOutput,
                       IMFOutputTrustAuthority *_pMFOutputTrustAuthority,
                       IMFOutputPolicy *_pMFOutputPolicy);


const CLSID CLSID_MMDeviceEnumerator = __uuidof(MMDeviceEnumerator);
const IID IID_IMMDeviceEnumerator = __uuidof(IMMDeviceEnumerator);

BOOL IsDigitalEndpoint(IMMDevice *pDevice)
{
    PROPVARIANT         var;
    IPropertyStore      *pProperties = NULL;
    EndpointFormFactor  formfactor;
    BOOL                bResult = FALSE;
    HRESULT             hr = S_OK;
    PropVariantInit(&var);

    // Open endpoint properties
    hr = pDevice->OpenPropertyStore(STGM_READ, &pProperties);
    IF_FAILED_JUMP(hr, Exit);

    // get form factor 
    hr = pProperties->GetValue(PKEY_AudioEndpoint_FormFactor, &var);
    IF_FAILED_JUMP(hr, Exit);

    formfactor = (EndpointFormFactor)var.uiVal;
    if ((SPDIF == formfactor) || (DigitalAudioDisplayDevice == formfactor))
    {
        bResult = TRUE;
    }

Exit:
    PropVariantClear(&var);
    SAFE_RELEASE(pProperties);

    return bResult;
}


HRESULT GetDigitalAudioEndpoint(IMMDevice** ppDevice)
{
    IMMDeviceEnumerator    *pEnumerator = NULL;
    IMMDevice              *pDevice = NULL;
    IMMDeviceCollection    *pEndpoints = NULL;
    UINT                    cEndpoints = 0;
    HRESULT hr = S_OK;

    *ppDevice = NULL;
    // Get enumerator for audio endpoint devices.
    hr = CoCreateInstance(CLSID_MMDeviceEnumerator, NULL,
                          CLSCTX_ALL, IID_IMMDeviceEnumerator,
                          (void**)&pEnumerator);
    IF_FAILED_JUMP(hr, Exit);

    // Enumerate all active render endpoints, 
    hr = pEnumerator->EnumAudioEndpoints(eRender, DEVICE_STATE_ACTIVE, &pEndpoints);
    IF_FAILED_JUMP(hr, Exit);

    hr = pEndpoints->GetCount(&cEndpoints);
    IF_FAILED_JUMP(hr, Exit);

    for (UINT i = 0; i < cEndpoints; i++)
    {
        hr = pEndpoints->Item(i, &pDevice);
        IF_FAILED_JUMP(hr, Exit);
        // Select the endpoint that meets the requirements.
        // For example, SPDIF analog output or HDMI
        // Not Shown.
        if (IsDigitalEndpoint(pDevice))
        {
            *ppDevice = pDevice;
            (*ppDevice)->AddRef();
            break;
        }
        SAFE_RELEASE(pDevice);
    }
Exit:
    if (FAILED(hr))
    {
        // Notify error.
        // Not Shown.
    }
    SAFE_RELEASE(pEndpoints);
    SAFE_RELEASE(pEnumerator);
    return hr; 
}


//-------------------------------------------------------------------
int __cdecl wmain(int argc, char* argv[])
{
    IMMDevice *pEndpoint=NULL;
    HRESULT hr = S_OK;

    // DSound related variables
    IDirectSound8*          DSSound8 = NULL; 
    IDirectSoundBuffer*     DSBuffer = NULL; 
    DSBUFFERDESC            DSBufferDesc;
    WAVEFORMATEXTENSIBLE    wfext;
    WORD nChannels = 2;
    DWORD nSamplesPerSec = 48000;
    WORD wBitsPerSample = 16;

    // OTA related variables
    IMFTrustedOutput *pMFTrustedOutput=NULL;
    IMFOutputPolicy *pMFOutputPolicy=NULL;
    IMFOutputTrustAuthority *pMFOutputTrustAuthority=NULL;
    DWORD dwConfigData=0;

    // Initialize COM
    hr = CoInitialize(NULL);
    IF_FAILED_JUMP(hr, Exit);

    printf("OTA test app for DSound\n");

    hr = GetDigitalAudioEndpoint(&pEndpoint);
    IF_FAILED_JUMP(hr, Exit);

    if (pEndpoint)
    {
        printf("Found digital audio endpoint.\n");
    }
    //
    // Active DSound interface
    //
    hr = pEndpoint->Activate(IID_IDirectSound8, CLSCTX_INPROC_SERVER, NULL, reinterpret_cast<void **>(&DSSound8));
    IF_FAILED_JUMP(hr, Exit);

    nChannels = 2;
    nSamplesPerSec = 48000;
    wBitsPerSample = 16;

    ZeroMemory(&wfext, sizeof(wfext));
    wfext.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
    wfext.Format.nChannels = nChannels;
    wfext.Format.nSamplesPerSec = nSamplesPerSec;
    wfext.Format.wBitsPerSample = wBitsPerSample;
    wfext.Format.nBlockAlign = (nChannels * wBitsPerSample) / 8;
    wfext.Format.nAvgBytesPerSec = nSamplesPerSec * ((nChannels * wBitsPerSample) / 8);
    wfext.Format.cbSize = 22;
    wfext.Samples.wValidBitsPerSample = wBitsPerSample;
    wfext.dwChannelMask = 0x3;
    wfext.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
#if 1 
    wfext.SubFormat = KSDATAFORMAT_SUBTYPE_AC3;
#endif

    ZeroMemory(&DSBufferDesc, sizeof(DSBufferDesc));
    DSBufferDesc.dwSize = sizeof(DSBufferDesc);
    DSBufferDesc.dwFlags = DSBCAPS_GLOBALFOCUS | DSBCAPS_LOCSOFTWARE | DSBCAPS_GETCURRENTPOSITION2;
    DSBufferDesc.lpwfxFormat = (WAVEFORMATEX *)&wfext;
    DSBufferDesc.dwBufferBytes = wfext.Format.nAvgBytesPerSec / 100;

    HWND hwnd = GetForegroundWindow();
    hr = DSSound8->SetCooperativeLevel(hwnd, DSSCL_PRIORITY);
    IF_FAILED_JUMP(hr, Exit);

    hr = DSSound8->CreateSoundBuffer(&DSBufferDesc, &DSBuffer, NULL);
    IF_FAILED_JUMP(hr, Exit);

    hr = DSBuffer->Play(0, 0, DSBPLAY_LOOPING);
    IF_FAILED_JUMP(hr, Exit);

    printf("Will set the following audio policy:\n");
    printf("Test Certificate Enable: %s\n", TRUE ? "True" : "False");
    printf("Copy OK: %s\n", FALSE ? "True" : "False");
    printf("Digital Output Disable: %s\n", FALSE ? "True" : "False");
    printf("DRM Level: %u\n", 1300);

    // Set policy when the stream is in RUN state
    dwConfigData = MAKE_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS2(TRUE, /*_bTestCertificateEnable*/ 
                                                              FALSE, /*_bDigitalOutputDisable*/ 
                                                              FALSE, /*_bCopyOK*/ 
                                                              1300 /*_dwDrmLevel*/);

    hr = SetOTAPolicy(pEndpoint,dwConfigData, &pMFTrustedOutput, &pMFOutputTrustAuthority,&pMFOutputPolicy); 
    IF_FAILED_JUMP(hr, Exit);

    //
    // Perform all the necessary streaming operations here.
    //

    // stop audio streaming
    DSBuffer->Stop();

    // In order for the stream to restart successfully 
    // Need to release the following OutputTrust* interface to release audio endpoint
    hr = ClearOTAPolicy(pMFTrustedOutput,pMFOutputTrustAuthority,pMFOutputPolicy);
    IF_FAILED_JUMP(hr, Exit);

    // After above release operations, the following Play() will succeed without device-in-use error message 0x8889000A
    DSBuffer->SetCurrentPosition(0);
    hr = DSBuffer->Play(0, 0, DSBPLAY_LOOPING);
    IF_FAILED_JUMP(hr, Exit);

    // Need to reset the new audio protection state because previous settings were gone with the ClearOTAPolicy call.
    dwConfigData = MAKE_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS2(TRUE, /*_bTestCertificateEnable*/ 
                                                              FALSE, /*_bDigitalOutputDisable*/ 
                                                              FALSE, /*_bCopyOK*/ 
                                                              1300 /*_dwDrmLevel*/);

    hr = SetOTAPolicy(pEndpoint,dwConfigData, &pMFTrustedOutput, &pMFOutputTrustAuthority,&pMFOutputPolicy); 
    IF_FAILED_JUMP(hr, Exit);

    // Clean up setting before leaving your streaming app.
    hr = ClearOTAPolicy(pMFTrustedOutput,pMFOutputTrustAuthority,pMFOutputPolicy);
    IF_FAILED_JUMP(hr, Exit);

    DSBuffer->SetCurrentPosition(0);

Exit:
    SAFE_RELEASE(DSBuffer);
    SAFE_RELEASE(DSSound8);

    SAFE_RELEASE(pEndpoint);

    CoUninitialize();

    return 0;
}

//OTADSoundSample.h
// Macro defines
#define IF_FAILED_JUMP(_hresult, label)                         \
    if(FAILED(_hresult))                                        \
    {                                                           \
        goto label;                                             \
    }

#define SAFE_RELEASE(p) \
    if (NULL != p) { \
        (p)->Release(); \
        (p) = NULL; \
    }

#define IF_TRUE_ACTION_JUMP(condition, action, label)           \
    if(condition)                                               \
    {                                                           \
        action;                                                 \
        goto label;                                             \
    }

// outputpolicy.h

class CTrustedAudioDriversOutputPolicy : public CMFAttributesImpl<IMFOutputPolicy> 
{
friend
    HRESULT CreateTrustedAudioDriversOutputPolicy(DWORD dwConfigData, IMFOutputPolicy **ppMFOutputPolicy);
private:
    ULONG m_cRefCount;
    DWORD m_dwConfigData;
    GUID m_guidOriginator;
    IMFOutputSchema *m_pOutputSchema;
    
    CTrustedAudioDriversOutputPolicy(DWORD dwConfigData, HRESULT &hr);
    ~CTrustedAudioDriversOutputPolicy();

public:
    // IUnknown methods
    HRESULT STDMETHODCALLTYPE QueryInterface(/* [in] */ REFIID riid,/* [out] */ LPVOID *ppvObject);
    ULONG STDMETHODCALLTYPE AddRef();
    ULONG STDMETHODCALLTYPE Release();
    
    // IMFOutputPolicy methods
    HRESULT STDMETHODCALLTYPE
        GenerateRequiredSchemas( 
            /* [in] */ DWORD dwAttributes,
            /* [in] */ GUID guidOutputSubType,
            /* [in] */ GUID *rgGuidProtectionSchemasSupported,
            /* [in] */ DWORD cProtectionSchemasSupported,
            /* [annotation][out] */ 
            __out  IMFCollection **ppRequiredProtectionSchemas);

    HRESULT STDMETHODCALLTYPE GetOriginatorID(/* [annotation][out] */ __out  GUID *pguidOriginatorID);

    HRESULT STDMETHODCALLTYPE GetMinimumGRLVersion(/* [annotation][out] */ __out  DWORD *pdwMinimumGRLVersion);
}; // CTrustedAudioDriversOutputPolicy

class CTrustedAudioDriversOutputSchema : public CMFAttributesImpl<IMFOutputSchema> 
{

friend
    HRESULT CreateTrustedAudioDriversOutputSchema(
        DWORD dwConfigData,
        GUID guidOriginatorID,
        IMFOutputSchema **ppMFOutputSchema
    );

private:
    CTrustedAudioDriversOutputSchema(DWORD dwConfigData, GUID guidOriginatorID);
    ~CTrustedAudioDriversOutputSchema();

    ULONG m_cRefCount;
    DWORD m_dwConfigData;
    GUID m_guidOriginatorID;
    
public:
    // IUnknown methods
    HRESULT STDMETHODCALLTYPE QueryInterface(
       /* [in] */ REFIID riid,
       /* [out] */ LPVOID *ppvObject
    );
    ULONG STDMETHODCALLTYPE AddRef();
    ULONG STDMETHODCALLTYPE Release();

    // IMFOutputSchema methods
    HRESULT STDMETHODCALLTYPE GetConfigurationData(__out DWORD *pdwVal);
    HRESULT STDMETHODCALLTYPE GetOriginatorID(__out GUID *pguidOriginatorID);
    HRESULT STDMETHODCALLTYPE GetSchemaType(__out GUID *pguidSchemaType);

}; // CTrustedAudioDriversOutputSchema

// outputpolicy.cpp

#include <windows.h>
#include <tchar.h>
#include <mfidl.h>
#include <atlstr.h>
#include <attributesbase.h>
#include "OTADSoundSample.h"

#include <Mmdeviceapi.h>
#include "OutputPolicy.h"

#define RETURN_INTERFACE(T, iid, ppOut) \
    if (IsEqualIID(__uuidof(T), (iid))) { \
        this->AddRef(); \
        *(ppOut) = static_cast<T *>(this); \
        return S_OK; \
    } else {} (void)0

//--------------------------------------------------------------------------
// Implementation for CTrustedAudioDriversOutputPolicy
//--------------------------------------------------------------------------
// constructor
CTrustedAudioDriversOutputPolicy::CTrustedAudioDriversOutputPolicy(DWORD dwConfigData, HRESULT &hr)
: m_cRefCount(1), m_dwConfigData(dwConfigData), m_pOutputSchema(NULL)
{
    hr = CoCreateGuid(&m_guidOriginator);
    IF_FAILED_JUMP(hr, Exit);

    hr = CreateTrustedAudioDriversOutputSchema(dwConfigData, m_guidOriginator, &m_pOutputSchema);
    IF_FAILED_JUMP(hr, Exit);

Exit:
    if (FAILED(hr))
    {
        printf("CreateTrustedAudioDriversOutputSchema failed: hr = 0x%08x", hr);
    }
    return;
}

// destructor
CTrustedAudioDriversOutputPolicy::~CTrustedAudioDriversOutputPolicy()
{
    if (NULL != m_pOutputSchema) 
    {
        m_pOutputSchema->Release();
    }
}


// IUnknown::QueryInterface
HRESULT STDMETHODCALLTYPE
    CTrustedAudioDriversOutputPolicy::QueryInterface(
        /* [in] */ REFIID riid,
        /* [out] */ LPVOID *ppvObject)
{
    HRESULT hr = E_NOINTERFACE;

    IF_TRUE_ACTION_JUMP((NULL == ppvObject), hr = E_POINTER, Exit);

    *ppvObject = NULL;

    RETURN_INTERFACE(IUnknown, riid, ppvObject);
    RETURN_INTERFACE(IMFAttributes, riid, ppvObject);
    RETURN_INTERFACE(IMFOutputPolicy, riid, ppvObject);    

Exit:
    return hr;
}

// IUnknown::AddRef
ULONG STDMETHODCALLTYPE CTrustedAudioDriversOutputPolicy::AddRef() 
{
    ULONG uNewRefCount = InterlockedIncrement(&m_cRefCount);
    return uNewRefCount;
}

// IUnknown::Release
ULONG STDMETHODCALLTYPE CTrustedAudioDriversOutputPolicy::Release() 
{
    ULONG uNewRefCount = InterlockedDecrement(&m_cRefCount);
    if (0 == uNewRefCount) 
    {
        delete this;
    }
    return uNewRefCount;
}

// IMFOutputPolicy::GenerateRequiredSchemas
HRESULT STDMETHODCALLTYPE CTrustedAudioDriversOutputPolicy::GenerateRequiredSchemas
( 
        /* [in] */ DWORD dwAttributes,
        /* [in] */ GUID guidOutputSubType,
        /* [in] */ GUID *rgGuidProtectionSchemasSupported,
        /* [in] */ DWORD cProtectionSchemasSupported,
        /* [annotation][out] */ 
        __out  IMFCollection **ppRequiredProtectionSchemas
)
{
    HRESULT hr = S_OK;
    bool bTrustedAudioDriversSupported = false;
    // if we've made it this far then the Output Trust Authority supports Trusted Audio Drivers
    // create a collection and put our output policy in it
    // then give that collection to the caller
    CComPtr<IMFCollection> pMFCollection;

    // sanity checks
    IF_TRUE_ACTION_JUMP((NULL == ppRequiredProtectionSchemas), hr = E_POINTER, Exit); 
    *ppRequiredProtectionSchemas = NULL;

    IF_TRUE_ACTION_JUMP((NULL == rgGuidProtectionSchemasSupported) && (0 != cProtectionSchemasSupported), 
                    hr = E_POINTER, Exit); 

    // log all the supported protection schemas
    for (DWORD i = 0; i < cProtectionSchemasSupported; i++) 
    {
        if (IsEqualIID(MFPROTECTION_TRUSTEDAUDIODRIVERS, rgGuidProtectionSchemasSupported[i])) 
        {
            bTrustedAudioDriversSupported = true;
        }
    }

    if (!bTrustedAudioDriversSupported) 
    {
        return HRESULT_FROM_WIN32(ERROR_RANGE_NOT_FOUND);
    }


    // create the collection
    hr = MFCreateCollection(&pMFCollection);
    if (FAILED(hr)) 
    {
        return hr;
    }

    // add our output policy to the collection
    hr = pMFCollection->AddElement(m_pOutputSchema);
    if (FAILED(hr)) 
    {
        return hr;
    }
Exit:
    // give the collection to the caller
    return pMFCollection.CopyTo(ppRequiredProtectionSchemas); // increments refcount
}// GenerateRequiredSchemas

HRESULT STDMETHODCALLTYPE CTrustedAudioDriversOutputPolicy::GetOriginatorID(__out  GUID *pguidOriginatorID) 
{
    if (NULL == pguidOriginatorID) 
    {
        return E_POINTER;
    }
    *pguidOriginatorID = m_guidOriginator;
    return S_OK;
}

HRESULT STDMETHODCALLTYPE CTrustedAudioDriversOutputPolicy::GetMinimumGRLVersion(__out  DWORD *pdwMinimumGRLVersion) 
{
    if (NULL == pdwMinimumGRLVersion) 
    {
        return E_POINTER;
    }
    *pdwMinimumGRLVersion = 0;
    return S_OK;
}

//--------------------------------------------------------------------------
// Implementation for CTrustedAudioDriversOutputSchema
//--------------------------------------------------------------------------
// constructor
CTrustedAudioDriversOutputSchema::CTrustedAudioDriversOutputSchema
(    
    DWORD dwConfigData, 
    GUID guidOriginatorID
)
: m_cRefCount(1)
, m_dwConfigData(dwConfigData)
, m_guidOriginatorID(guidOriginatorID)
{}

// destructor
CTrustedAudioDriversOutputSchema::~CTrustedAudioDriversOutputSchema() {}

// IUnknown::QueryInterface
HRESULT STDMETHODCALLTYPE CTrustedAudioDriversOutputSchema::QueryInterface
(
        /* [in] */ REFIID riid,
        /* [out] */ LPVOID *ppvObject
) 
{
    HRESULT hr = E_NOINTERFACE;

    IF_TRUE_ACTION_JUMP((NULL == ppvObject), hr = E_POINTER, Exit);
    *ppvObject = NULL;

    RETURN_INTERFACE(IUnknown, riid, ppvObject);
    RETURN_INTERFACE(IMFAttributes, riid, ppvObject);
    RETURN_INTERFACE(IMFOutputSchema, riid, ppvObject);

Exit:
    return hr;
}

// IUnknown::AddRef
ULONG STDMETHODCALLTYPE CTrustedAudioDriversOutputSchema::AddRef() 
{
    ULONG uNewRefCount = InterlockedIncrement(&m_cRefCount);
    return uNewRefCount;
}

// IUnknown::Release
ULONG STDMETHODCALLTYPE CTrustedAudioDriversOutputSchema::Release() 
{
    ULONG uNewRefCount = InterlockedDecrement(&m_cRefCount);
    if (0 == uNewRefCount) 
    {
        delete this;
    }
    return uNewRefCount;
}
// IMFOutputSchema::GetConfigurationData
HRESULT STDMETHODCALLTYPE CTrustedAudioDriversOutputSchema::GetConfigurationData(__out DWORD *pdwVal) 
{
    if (NULL == pdwVal) { return E_POINTER; }
    *pdwVal = m_dwConfigData;
    return S_OK;
}

// IMFOutputSchema::GetOriginatorID
HRESULT STDMETHODCALLTYPE CTrustedAudioDriversOutputSchema::GetOriginatorID(__out GUID *pguidOriginatorID) 
{
    if (NULL == pguidOriginatorID) { return E_POINTER; }
    *pguidOriginatorID = m_guidOriginatorID;
    return S_OK;
}
// IMFOutputSchema::GetSchemaType
HRESULT STDMETHODCALLTYPE CTrustedAudioDriversOutputSchema::GetSchemaType(__out GUID *pguidSchemaType) 
{
    if (NULL == pguidSchemaType) { return E_POINTER; }
    *pguidSchemaType = MFPROTECTION_TRUSTEDAUDIODRIVERS;
    return S_OK;
}

//---------------------------------------------------------------------------------------------------
//
// Other subroutine declarations
//
//---------------------------------------------------------------------------------------------------
HRESULT CreateTrustedAudioDriversOutputPolicy(DWORD dwConfigData, IMFOutputPolicy **ppMFOutputPolicy) 
{
    if (NULL == ppMFOutputPolicy) 
    {
        return E_POINTER;
    }

    *ppMFOutputPolicy = NULL;

    HRESULT hr = S_OK;
    CTrustedAudioDriversOutputPolicy *pPolicy = new CTrustedAudioDriversOutputPolicy(dwConfigData, hr);
    if (NULL == pPolicy) 
    {
        return E_OUTOFMEMORY;
    }
    if (FAILED(hr)) 
    {
        delete pPolicy;
        return hr;
    }
    *ppMFOutputPolicy = static_cast<IMFOutputPolicy *>(pPolicy);
    return S_OK;
}// CreateTrustedAudioDriversOutputPolicy

HRESULT CreateTrustedAudioDriversOutputSchema
(
    DWORD dwConfigData,
    GUID guidOriginatorID,
    IMFOutputSchema **ppMFOutputSchema) 
{
    if (NULL == ppMFOutputSchema) 
    {
        return E_POINTER;
    }

    *ppMFOutputSchema = NULL;

    CTrustedAudioDriversOutputSchema *pSchema =
        new CTrustedAudioDriversOutputSchema(dwConfigData, guidOriginatorID);

    if (NULL == pSchema) 
    {
        return E_OUTOFMEMORY;
    }

    *ppMFOutputSchema = static_cast<IMFOutputSchema *>(pSchema);

    return S_OK;
}// CreateTrustedAudioDriversOutputSchema



HRESULT SetOTAPolicy(IMMDevice *_pMMDevice,
                     DWORD _dwConfigData,
                     IMFTrustedOutput **_ppMFTrustedOutput,
                     IMFOutputTrustAuthority **ppMFOutputTrustAuthority,
                     IMFOutputPolicy **_ppMFOutputPolicy)
{
    HRESULT hr = S_OK;

    DWORD dwCountOfOTAs = 0;
    bool bRet = false;

    hr = CreateTrustedAudioDriversOutputPolicy(_dwConfigData, _ppMFOutputPolicy);
    IF_FAILED_JUMP(hr, Exit);

    // activate IMFTrustedOutput
    hr = _pMMDevice->Activate(__uuidof(IMFTrustedOutput), CLSCTX_ALL, NULL,
                             (void**)_ppMFTrustedOutput);
    IF_FAILED_JUMP(hr, Exit);

    // get count of Output Trust Authorities on this trusted output
    hr = (*_ppMFTrustedOutput)->GetOutputTrustAuthorityCount(&dwCountOfOTAs);
    IF_FAILED_JUMP(hr, Exit);

    // sanity check - fail on endpoints with no output trust authorities
    IF_TRUE_ACTION_JUMP((0 == dwCountOfOTAs), hr = E_NOTFOUND, Exit);

    printf("dwCountOfOTAs = %d\n", dwCountOfOTAs);

     
    // loop over each output trust authority on the endpoint
    for (DWORD i = 0; i < dwCountOfOTAs; i++) 
    {
        // get the output trust authority
        hr = (*_ppMFTrustedOutput)->GetOutputTrustAuthorityByIndex(i, ppMFOutputTrustAuthority);
        IF_FAILED_JUMP(hr, Exit);


        // log the purpose of the output trust authority
        MFPOLICYMANAGER_ACTION action;
        hr = (*ppMFOutputTrustAuthority)->GetAction(&action);
        if (FAILED(hr)) 
        {
            return hr;
        }

        printf(" It's %s.", (PEACTION_PLAY==action) ? "PEACTION_PLAY" :
                            (PEACTION_COPY==action) ? "PEACTION_COPY" :
                            "Others");
 
        // only PEACTION_PLAY Output Trust Authorities are relevant
        if (PEACTION_PLAY != action) 
        {
            printf("Skipping as the OTA action is not PEACTION_PLAY");
            SAFE_RELEASE(*ppMFOutputTrustAuthority);
            continue;
        }

        BYTE *pbTicket = NULL;
        DWORD cbTicket = 0;
        // audio ota does not support ticket, leaving it NULL is ok.
        hr = (*ppMFOutputTrustAuthority)->SetPolicy(_ppMFOutputPolicy, 1, &pbTicket, &cbTicket);
        IF_FAILED_JUMP(hr, Exit);
        printf("SetPolicy succeeded.\n");

        bRet = true;
        break;

    }// for each output trust authority

Exit:
    if (bRet)
    {
        hr = S_OK;
    }
    if (FAILED(hr))
    {
        printf("failure code is 0x%0x\n", hr);
        SAFE_RELEASE(*ppMFOutputTrustAuthority);
        SAFE_RELEASE(*_ppMFTrustedOutput);
        if (*_ppMFOutputPolicy)
        {
            delete (*_ppMFOutputPolicy);
        }
    }

    return hr;
}


HRESULT ClearOTAPolicy(IMFTrustedOutput *_pMFTrustedOutput,
                       IMFOutputTrustAuthority *_pMFOutputTrustAuthority,
                       IMFOutputPolicy *_pMFOutputPolicy)
{
    SAFE_RELEASE(_pMFOutputTrustAuthority);
    SAFE_RELEASE(_pMFTrustedOutput);
    if (_pMFOutputPolicy)
    {
        delete _pMFOutputPolicy;
    }
    return S_OK;
}

//OTADSoundSample.rc
#include "windows.h"

/////////////////////////////////////////////////////////////////////////////
// Version
#include <ntverp.h>

#define VER_FILETYPE                VFT_DLL
#define VER_FILESUBTYPE             VFT2_UNKNOWN
#define VER_FILEDESCRIPTION_STR     "Default Device Heuristic Dumper"
#define VER_INTERNALNAME_STR        "DefaultDeviceDump.exe"
#define VER_ORIGINALFILENAME_STR    "DefaultDeviceDump.exe"

#include "common.ver"

Sources file:

TARGETNAME=OTADSoundSample
TARGETTYPE=PROGRAM
TARGET_DESTINATION=retail
UMTYPE=console
UMENTRY=wmain
UMBASE=0x1000000
#_NT_TARGET_VERSION=$(_NT_TARGET_VERSION_VISTA)
MSC_WARNING_LEVEL=$(MSC_WARNING_LEVEL) /WX
USE_ATL=1
ATL_VER=70
USE_NATIVE_EH=1
USE_MSVCRT=1
C_DEFINES=-DUNICODE -D_UNICODE
INCLUDES=$(INCLUDES);  

SOURCES=OTADSoundSample.cpp \
        OTADSoundSample.rc \
        outputpolicy.cpp\

TARGETLIBS=\
       $(SDK_LIB_PATH)\advapi32.lib         \
       $(SDK_LIB_PATH)\kernel32.lib         \
       $(SDK_LIB_PATH)\User32.lib           \
       $(SDK_LIB_PATH)\shlwapi.lib          \
       $(SDK_LIB_PATH)\ole32.lib            \
       $(SDK_LIB_PATH)\oleaut32.lib         \
       $(SDK_LIB_PATH)\rpcrt4.lib           \
       $(SDK_LIB_PATH)\strmiids.lib         \
       $(SDK_LIB_PATH)\uuid.lib             \
       $(SDK_LIB_PATH)\SetupAPI.lib         \
       $(SDK_LIB_PATH)\mfplat.lib \

programmeerhandleiding voor

User-Mode audioonderdelen

Delen via

Beveiligde gebruikersmodusaudio (PUMA)

DRM-beveiliging in audiostuurprogramma's

Kopieerbeveiligingsregel

Regel voor het uitschakelen van digitale uitvoer

Mechanismen voor inhoudsbeveiliging buiten een beveiligde omgeving inschakelen

Implementatie-instructies

Feedback

Aanvullende resources

Delen via

Beveiligde gebruikersmodusaudio (PUMA)

DRM-beveiliging in audiostuurprogramma's

Kopieerbeveiligingsregel

Regel voor het uitschakelen van digitale uitvoer

Mechanismen voor inhoudsbeveiliging buiten een beveiligde omgeving inschakelen

Implementatie-instructies

Verwante onderwerpen

Feedback

Aanvullende resources