Guia de implementação da câmera da Classe de Vídeo USB (UVC)

A partir do Windows 10, o Windows fornece um driver UVC (Classe de Vídeo USB) nativo para dispositivos compatíveis com a especificação da Classe de Vídeo USB (versões 1.0 a 1.5). Este driver dá suporte a câmeras de cor e de tipo de sensor. Este documento descreve como expor determinadas funcionalidades de uma câmera compatível com UVC para os aplicativos por meio do driver de caixa de entrada.

Terminologia

Câmeras de sensor

O Windows dá suporte a duas categorias de câmeras. Uma é uma câmera colorida e a outra é uma câmera de sensor não colorida. As câmeras RGB ou YUV são categorizadas como câmeras coloridas e câmeras não coloridas, como escala cinza, câmeras IR e Profundidade são categorizadas como câmeras de sensor. O driver UVC dá suporte a ambos os tipos de câmeras. Recomendamos que o firmware de câmera especifique um valor com base no qual o driver UVC registraria a câmera em uma ou ambas as categorias com suporte.

Uma câmera que dá suporte somente a tipos de formato de cor deve ser registrada em KSCATEGORY_VIDEO_CAMERA. Uma câmera que dá suporte a tipos de formato IR ou apenas profundidade deve ser registrada em KSCATEGORY_SENSOR_CAMERA. Uma câmera que suporta formatos de cor e não cor deve ser registrada em KSCATEGORY_VIDEO_CAMERA e KSCATEGORY_SENSOR_CAMERA. Essa categorização ajuda os aplicativos a selecionar a câmera com a qual eles desejam trabalhar.

Uma câmera UVC pode especificar sua preferência de categoria por meio dos atributos SensorCameraMode e SkipCameraEnumeration, conforme detalhado em seu Descritor do BOS MS OS 2.0 nas seções a seguir.

O atributo SensorCameraMode usa um valor 1 ou 2.

Um valor de 1 registrará o dispositivo em KSCATEGORY_SENSOR_CAMERA. Além disso, especifique um valor de 1 para SkipCameraEnumeration para disponibilizar a câmera para aplicativos que procuram apenas câmeras de sensor. Uma câmera que só expõe tipos de mídia da câmera de sensor deve usar esse valor.

Um valor de 2 para SensorCameraMode registrará o dispositivo em KSCATEGORY_SENSOR_CAMERA &KSCATEGORY_VIDEO_CAMERA. Isso disponibiliza a câmera para aplicativos que procuram sensores e câmeras coloridas. Uma câmera que expõe os tipos de mídia de câmera de sensor e de câmera colorida deve usar esse valor.

Recomendamos que você especifique o valor do Registro mencionado acima usando o descritor BOS. Consulte a seção exemplo de dispositivo composto abaixo para obter um descritor BOS de exemplo com um descritor ms os 2.0 específico da plataforma.

Se você não puder atualizar o firmware do dispositivo conforme descrito acima, poderá usar um INF personalizado e especificar que sua câmera precisa ser registrada como uma câmera de sensor especificando um valor para SensorCameraMode e SkipCameraEnumeration da seguinte maneira:

Um arquivo INF personalizado (com base no driver UVC da caixa de entrada) deve incluir as seguintes entradas AddReg:

SensorCameraMode: REG_DWORD: 1 (para registrar-se como uma câmera de sensor)

SkipCameraEnumeration: REG_DWORD: 1 (disponibilize-o apenas para aplicativos IR)

Um exemplo da seção INF personalizada é o seguinte:

[USBVideo.NT.HW]
AddReg=USBVideo.HW.AddReg

[USBVideo.HW.AddReg]
HKR,, SensorCameraMode, 0x00010001,1      ; places the value under device HW
                                          ; Registry key

HKR,, SkipCameraEnumeration, 0x00010001,1 ; This makes the camera available
                                          ; only for application looking for
                                          ; IR cameras

Se os atributos SensorCameraMode e SkipCameraEnumeration não forem especificados no firmware ou no INF, a câmera será registrada como uma câmera colorida e ficará visível apenas para aplicativos com reconhecimento de câmera colorida.

Fluxo de IR

O driver da classe de vídeo USB da caixa de entrada do Windows (UVC) dá suporte a câmeras que capturam a cena no formato YUV e transmitem os dados de pixel por USB como YUV não compactado ou como quadros MJPEG compactados.

Os GUIDs do tipo de formato a seguir devem ser especificados no descritor de formato de vídeo de fluxo, conforme definido no arquivo de cabeçalho ksmedia.h do WDK:

Quando esses GUIDs de tipo de formato são especificados no campo guidFormat do descritor de quadro, o pipeline de captura do Media Foundation marca o fluxo como fluxo IR. Os aplicativos escritos com a API FrameReader do Media Foundation poderão consumir o fluxo de IR. Não há suporte pelo pipeline para dimensionamento ou conversões dos quadros de IR em fluxos de IR.

Um fluxo que expõe tipos de formato IR não deve expor tipos de formato RGB ou Depth.

// Example Format Descriptor for UVC 1.1 frame based format

typedef struct _VIDEO_FORMAT_FRAME
{
    UCHAR bLength;
    UCHAR bDescriptorType;
    UCHAR bDescriptorSubtype;
    UCHAR bFormatIndex;
    UCHAR bNumFrameDescriptors;
    GUID  guidFormat;  // this field should contain the IR subtype GUID
    UCHAR bBitsPerPixel;
    UCHAR bDefaultFrameIndex;
    UCHAR bAspectRatioX;
    UCHAR bAspectRatioY;
    UCHAR bmInterlaceFlags;
    UCHAR bCopyProtect;
    UCHAR bVariableSize;
} VIDEO_FORMAT_FRAME, *PVIDEO_FORMAT_FRAME;

Fluxo de profundidade

O driver da Classe de Vídeo USB da caixa de entrada do Windows dá suporte a câmeras que produzem fluxos de profundidade. Essas câmeras capturam as informações de profundidade (por exemplo, tempo de voo) da cena e transmitem o mapa de profundidade como quadros YUV não compactados por USB. O GUID do tipo de formato a seguir deve ser especificado no descritor de formato de fluxo de vídeo, conforme definido no arquivo de cabeçalho ksmedia.h do WDK.

Quando o GUID do tipo de formato é especificado no membro guidFormat do descritor de quadro, o pipeline de captura do Media Foundation marca o fluxo como fluxo de profundidade. Aplicativos desenvolvidos com a API FrameReader poderão consumir o fluxo de profundidade. Não há suporte para dimensionamento ou conversões dos quadros de profundidade pelo pipeline para fluxos de profundidade.

Um fluxo que exibe tipos de formato Depth não deve exibir tipos de formato RGB ou IR.

// Example Format Descriptor for UVC 1.1 frame based format
typedef struct _VIDEO_FORMAT_FRAME
{
    UCHAR bLength;
    UCHAR bDescriptorType;
    UCHAR bDescriptorSubtype;
    UCHAR bFormatIndex;
    UCHAR bNumFrameDescriptors;
    GUID guidFormat; // this field should contain the IR subtype GUID
    UCHAR bBitsPerPixel;
    UCHAR bDefaultFrameIndex;
    UCHAR bAspectRatioX;
    UCHAR bAspectRatioY;
    UCHAR bmInterlaceFlags;
    UCHAR bCopyProtect;
    UCHAR bVariableSize;
} VIDEO_FORMAT_FRAME, *PVIDEO_FORMAT_FRAME;

Câmeras em Grupos

O Windows dá suporte ao agrupamento de câmeras com base em sua ID de contêiner para ajudar os aplicativos a trabalhar com câmeras relacionadas. Por exemplo, uma câmera IR e uma câmera Color presentes no mesmo dispositivo físico podem ser expostos ao sistema operacional como câmeras relacionadas. Isso faz com que aplicativos como o Windows Hello usem as câmeras relacionadas para seus cenários.

A relação entre as funções de câmera pode ser especificada no descritor BOS da câmera no firmware. O driver UVC usará essas informações e exporá essas funções de câmera como relacionadas. Isso faz com que o sistema de câmeras do sistema operacional as exponha como um grupo relacionado de câmeras para os aplicativos.

O firmware da câmera deve especificar um UVC-FSSensorGroupID, que é um GUID em forma de cadeia de caracteres com os parênteses encaracolados. As câmeras que têm o mesmo UVC-FSSensorGroupID serão agrupadas.

O grupo de sensores pode receber um nome especificando UVC-FSSensorGroupName, uma cadeia de caracteres Unicode, no firmware.

Consulte a seção exemplo de dispositivo composto abaixo para obter um exemplo ilustrativo BOS que especifica UVC-FSSensorGroupID e UVC-FSSensorGroupName.

Se você não puder atualizar o firmware do dispositivo conforme descrito acima, poderá usar um INF personalizado e especificar que sua câmera faz parte de um grupo de sensores especificando uma ID e um nome do grupo de sensores da seguinte maneira. O arquivo INF personalizado (com base no driver UVC da caixa de entrada) deve incluir as seguintes entradas AddReg:

FSSensorGroupID: REG_SZ: "{GUID da ID do grupo de sensores}"

FSSensorGroupName: REG_SZ: "seu nome amigável do grupo de sensores"

Um exemplo para a seção INF personalizada seria o seguinte:

[USBVideo.NT.Interfaces]
AddInterface=%KSCATEGORY_CAPTURE%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_RENDER%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_VIDEO%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_RENDER_EXT%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_VIDEO_CAMERA%,GLOBAL,USBVideo.Interface

[USBVideo.Interface]
AddReg=USBVideo.Interface.AddReg

[USBVideo.Interface.AddReg]
HKR,,CLSID,,%ProxyVCap.CLSID%
HKR,,FriendlyName,,%USBVideo.DeviceDesc%
HKR,,RTCFlags,0x00010001,0x00000010
HKR,, FSSensorGroupID,0x00000000,%FSSensorGroupID%
HKR,, FSSensorGroupName,0x00000000,%FSSensorGroupName%

O método 2 ou o Método 3 ainda capturam o suporte

A especificação UVC fornece um mecanismo para especificar se a interface de streaming de vídeo suporta a captura de imagem estática do tipo método 1/2/3. Para permitir que o sistema operacional aproveite o suporte de captura de imagem estática do método 2/3 do dispositivo por meio do driver UVC, o firmware do dispositivo pode especificar um valor no descritor BOS.

O valor a ser especificado para habilitar a captura de imagem do Método 2/3 é um DWORD chamado UVC-EnableDependentStillPinCapture. Especifique seu valor usando o descritor BOS. O dispositivo composto exemplo abaixo ilustra a habilitação da captura de imagem estática usando um descritor BOS de exemplo.

Se você não puder atualizar o firmware do dispositivo conforme descrito acima, poderá usar um INF personalizado para especificar que sua câmera dá suporte ao Método 2 ou 3 de captura de imagem.

O arquivo INF personalizado (com base no driver UVC personalizado ou no driver UVC da caixa de entrada) deve incluir a seguinte entrada AddReg:

EnableDependentStillPinCapture: REG_DWORD: 0x0 (Desativado) até 0x1 (Ativado)

Quando essa entrada é definida como Habilitada (0x1), o fluxo de captura utiliza o Método 2/3 para captura de imagem fixa (supondo que o firmware também indique suporte para o Método 2/3, como especificado pela UVC).

Um exemplo para a seção INF personalizada é o seguinte:

[USBVideo.NT.Interfaces]
AddInterface=%KSCATEGORY_CAPTURE%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_RENDER%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_VIDEO%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_RENDER_EXT%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_VIDEO_CAMERA%,GLOBAL,USBVideo.Interface

[USBVideo.Interface]
AddReg=USBVideo.Interface.AddReg

[USBVideo.Interface.AddReg]
HKR,,CLSID,,%ProxyVCap.CLSID%
HKR,,FriendlyName,,%USBVideo.DeviceDesc%
HKR,,RTCFlags,0x00010001,0x00000010
HKR,,EnableDependentStillPinCapture,0x00010001,0x00000001

Encadeamento MFT do dispositivo

O MFT do dispositivo é o mecanismo de plug-in de modo de usuário recomendado para IHVs e OEMs para estender a funcionalidade da câmera no Windows.

Antes da versão 1703 do Windows 10, o pipeline de câmera dava suporte apenas para um plug-in de extensão DMFT.

A partir do Windows 10, versão 1703, o pipeline de câmera do Windows dá suporte a uma cadeia opcional de DMFTs com no máximo dois DMFTs.

A partir do Windows 11, versão 22H2, o pipeline de câmera do Windows dá suporte a uma cadeia opcional de DMFTs com no máximo quatro DMFTs.

Isso fornece maior flexibilidade para OEMs e IHVs fornecerem valor agregado na forma de fluxos de câmera pós-processamento. Por exemplo, um dispositivo pode usar PDMFT junto com um DMFT IHV e um DMFT OEM.

A figura a seguir ilustra a arquitetura que envolve uma cadeia de DMFTs.

Cadeia DMFT.

Os exemplos de captura fluem do driver da câmera para o DevProxy e, em seguida, passam pelas cadeias DMFT. Cada DMFT na cadeia tem a chance de processar a amostra. Se o DMFT não quiser processar a amostra, ele poderá atuar como um intermediário, bastando encaminhar a amostra para o próximo DMFT.

Para controles como KsProperty, a chamada é transmitida upstream – o último DMFT na cadeia recebe a chamada primeiro, podendo ser tratada lá ou passada para o DMFT anterior na cadeia.

Os erros são propagados de DMFT para DTM e, em seguida, para aplicativos. Para DMFTs IHV/OEM, se qualquer um dos DMFT não instanciar, será um erro fatal para DTM.

Requisitos para DMFTs:

• A contagem de pinos de entrada do DMFT deve corresponder à contagem de pinos de saída do DMFT anterior; caso contrário, o DTM falharia durante a inicialização. No entanto, o número de pinos de entrada e saída do mesmo DMFT não precisa corresponder.

• O DMFT precisa dar suporte a interfaces - IMFDeviceTransform, IMFShutdown, IMFRealTimeClientEx, IKsControl e IMFMediaEventGenerator; O IMFTransform pode precisar ser suportado se houver MFT0 configurado ou se o próximo DMFT na cadeia exigir suporte à IMFTransform.

• Em sistemas de 64 bits que não fazem uso do Frame Server, tanto os DMFTs de 32 bits quanto os de 64 bits devem ser registrados. Dado que uma câmera USB pode ser conectada a um sistema arbitrário, para câmeras USB "externas" (ou não nativas), o fornecedor da câmera USB deve fornecer DMFTs tanto de 32 bits quanto de 64 bits.

Configurando a cadeia DMFT

Um dispositivo de câmera pode, opcionalmente, fornecer um objeto DMFT COM em uma DLL usando um arquivo INF personalizado que usa seções da caixa de entrada USBVideo.INF.

No arquivo INF personalizado, especifique os CLSIDs DMFT na seção "Interface AddReg", adicionando a seguinte entrada de registro:

CameraDeviceMftCLSIDChain (REG_MULTI_SZ) %Dmft0.CLSID%,%Dmft.CLSID%,%Dmft2.CLSID%

Conforme mostrado nas configurações INF de exemplo abaixo (substitua o %Dmft0.CLSID% e % Dmft1.CLSID% pelas cadeias de caracteres CLSID reais que você está usando para seus DMFTs), há no máximo 2 CLSIDs permitidos no Windows 10, versão 1703, e a primeira é mais próxima de DevProxy e a última é a última DMFT na sequência.

O DMFT CLSID da plataforma é {3D096DDE-8971-4AD5-98F9-C74F56492630}.

Alguns exemplos de configurações de CameraDeviceMftCLSIDChain :

• Sem DMFT IHV/OEM ou DMFT de plataforma

  • CameraDeviceMftCLSIDChain = "" (ou não é necessário especificar esta entrada do Registro)

• IHV/OEM DMFT

  • CameraDeviceMftCLSIDChain = CLSID %Dmft.%

• Plataforma DMFT <–> IHV/OEM DMFT

  • CameraDeviceMftCLSIDChain = "{3D096DDE-8971-4AD5-98F9-C74F56492630}",%Dmft.CLSID%

  • Aqui está uma captura de tela da chave do registro de resultados para uma câmera USB com a Plataforma DMFT e um DMFT (com GUID {D671BE6C-FDB8-424F-81D7-03F5B1CE2CC7}) na cadeia.

• IHV/OEM DMFT0 <–> IHV/OEM DMFT1

  • CameraDeviceMftCLSIDChain = %Dmft0.CLSID%,%Dmft1.CLSID%,

Se CameraDeviceMftCLSIDChain estiver configurado, as configurações herdadas de CameraDeviceMftCLSID serão ignoradas pelo DTM.

Se CameraDeviceMftCLSIDChain não estiver configurado e o CameraDeviceMftCLSID herdado estiver configurado, então a cadeia terá a aparência (se a câmera for USB e for compatível com a Plataforma DMFT e a Plataforma DMFT estiver habilitada) DevProxy <–> Plataforma DMFT <–> OEM/IHV DMFT ou (se a câmera não for compatível com a Plataforma DMFT ou se a Plataforma DMFT estiver desabilitada) DevProxy <–> OEM/IHV DMFT.

Exemplo de configurações de arquivo INF:

[USBVideo.Interface.AddReg]
HKR,,CLSID,,%ProxyVCap.CLSID%
HKR,,FriendlyName,,%USBVideo.DeviceDesc%
HKR,,RTCFlags,0x00010001,0x00000010
HKR,,EnablePlatformDmft,0x00010001,0x00000001
HKR,,DisablePlatformDmftFeatures,0x00010001,0x00000001
HKR,,CameraDeviceMftCLSIDChain, 0x00010000,%Dmft0.CLSID%,%Dmft1.CLSID%

MFT do dispositivo de plataforma

A partir do Windows 10, versão 1703, o Windows fornece um MFT de dispositivo nativo para câmeras UVC, conhecido como PDMFT (Plataforma DMFT), sob demanda. Esse DMFT permite que IHVs e OEMs aproveitem os algoritmos de pós-processamento fornecidos pelo Windows.

Uma câmera UVC pode optar por usar a plataforma DMFT especificando o EnablePlatformDmft por meio do descritor BOS.

O valor a ser especificado para habilitar a Plataforma DMFT é um DWORD por nome UVC-EnablePlatformDmft e especifica seu valor usando o descritor BOS. A seção Exemplo de dispositivo composto abaixo ilustra como habilitar o DMFT da Plataforma com um descritor BOS de exemplo.

Se você não puder atualizar o firmware do dispositivo conforme descrito acima, poderá usar um arquivo INF personalizado para habilitar o DMFT da Plataforma para o dispositivo.

O arquivo INF personalizado (com base no driver UVC personalizado ou no driver UVC da caixa de entrada) deve incluir a seguinte entrada AddReg:

EnablePlatformDmft: REG_DWORD: 0x0 (Desabilitado) para 0x1 (Habilitado)

Quando essa entrada é definida como Habilitada (0x1), o pipeline de captura usa o DMFT da plataforma de inbox para o dispositivo. O seguinte mostra um exemplo desta seção personalizada do INF:

[USBVideo.NT.Interfaces]
AddInterface=%KSCATEGORY_CAPTURE%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_RENDER%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_VIDEO%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_RENDER_EXT%,GLOBAL,USBVideo.Interface
AddInterface=%KSCATEGORY_VIDEO_CAMERA%,GLOBAL,USBVideo.Interface

[USBVideo.Interface]
AddReg=USBVideo.Interface.AddReg

[USBVideo.Interface.AddReg]
HKR,,CLSID,,%ProxyVCap.CLSID%
HKR,,FriendlyName,,%USBVideo.DeviceDesc%
HKR,,RTCFlags,0x00010001,0x00000010
HKR,,EnablePlatformDmft,0x00010001,0x00000001

No Windows 10, versão 1703, se um dispositivo optar por usar o PDMFT, todos os recursos compatíveis com o PDMFT serão habilitados (com base nos recursos do dispositivo). Não há suporte para a configuração granular dos recursos PDMFT.

Perfil de Autenticação facial por meio de descritores do sistema operacional MS

O Windows 10 RS5 agora impõe um requisito de Perfil de Autenticação Facial V2 para qualquer câmera com suporte do Windows Hello. Para sistemas baseados em MIPI com pilha de driver de câmera personalizada, esse suporte pode ser publicado por meio de um INF (ou um INF de extensão) ou através de um plug-in em modo de usuário (Device MFT).

No entanto, para dispositivos de vídeo USB, uma restrição com câmeras baseadas em UVC é que, para o Windows 10 19H1, drivers de câmera personalizados não são permitidos. Todas as câmeras baseadas em UVC devem usar o driver nativo de Classe de Vídeo USB e todas as extensões de fornecedor devem ser implementadas na forma de um dispositivo MFT.

Para muitos OEM/ODMs, a abordagem preferencial para módulos de câmera é implementar grande parte da funcionalidade no firmware do módulo, ou seja, por meio de descritores do sistema operacional da Microsoft.

As câmeras a seguir têm suporte para publicar o Perfil de Autenticação Facial por meio dos Descritores do MSOS (também chamados de descritores BOS):

• Somente câmera RGB para ser usada no Grupo de Sensores com uma câmera infravermelha separada.

• Câmera somente IR usada em um Grupo de Sensores com uma câmera RGB separada.

• Câmera RGB+IR com pinos IR e RGB separados.

Exemplo de Layout do Descritor do Sistema Operacional da Microsoft

Os exemplos estão incluídos abaixo para as seguintes especificações:

• Especificação de descritores estendidos do sistema operacional da Microsoft 1.0

• Especificação de descritores do Microsoft OS 2.0

Especificação do Descritor Estendido do Sistema Operacional da Microsoft 1.0

O descritor de sistema operacional de propriedades estendidas tem dois componentes

• Uma seção de cabeçalho de comprimento fixo
• Uma ou mais seções de propriedades personalizadas de comprimento variável, que seguem a seção de cabeçalho

Seção Cabeçalho do Descritor do Microsoft OS 1.0

A Seção Cabeçalho descreve uma única propriedade personalizada (Perfil de Autenticação Facial).

Seção de Propriedade Personalizada do Descritor do Microsoft OS 1.0

Schema de Payload

A carga de dados UVC-CPV2FaceAuth é um inteiro sem sinal de 32 bits. A ordem alta de 16 bits representa o índice baseado em 0 da lista de tipos de mídia exposta pelo pino RGB. A ordem baixa de 16 bits representa o índice baseado em 0 da lista de tipos de mídia exposta pelo pino de IR.

Por exemplo, uma câmera tipo 3 que expõe os seguintes tipos de mídia, na ordem declarada do pino RGB:

• YUY2, 640x480@30fps

• MJPG, 1280x720@30fps

• MJPG, 800x600@30fps

• MJPG, 1920x1080@30fps

E o seguinte tipo de mídia para IR:

• L8, 480x480@30fps

• L8, 480x480@15fps

• L8, 480x480@10fps

Um valor de carga de 0x00010000 resultará na publicação do seguinte Perfil de Autenticação Facial:

Pin0:(RES==1280,720; FRT==30,1; SUT==MJPG) // Segundo tipo de mídia (0x0001)
Pin1:(RES==480.480; FRT==30,1; SUT==L8) // Primeiro tipo de mídia (0x0000)

Exemplo de câmera do tipo 1

Para uma câmera Tipo 1, já que não há nenhum pino IR (esperando-se que uma câmera Tipo 1 seja emparelhada a uma câmera Tipo 2 na máquina em um grupo de sensores), somente o índice de tipo de mídia RGB é publicado. Para o índice de tipo de mídia IR, o valor de 16 bits de ordem inferior da carga útil deve ser definido como 0xFFFF.

Por exemplo, se uma câmera tipo 1 expôs a seguinte lista de tipos de mídia:

• YUY2, 640x480@30fps

• MJPG, 1280x720@30fps

• MJPG, 800x600@30fps

• MJPG, 1920x1080@30fps

Para publicar o CPV2FaceAuth usando o tipo de mídia de MJPG, 1280x720@30fps, a carga útil deve ser definida como 0x0001FFFF.

Exemplo de câmera do tipo 2

Para uma Câmera tipo 2, a ordem alta de 16 bits deve ser definida como 0xFFFF, com a ordem baixa de 16 bits indicando o tipo de mídia IR a ser usado.

Por exemplo, para uma câmera tipo 2 com os seguintes tipos de mídia:

• L8, 480x480@30fps

• L8, 480x480@15fps

• L8, 480x480@10fps

Se o primeiro tipo de mídia for usado para Autenticação Facial, o valor deverá ser: 0xFFFF0000.

Especificação do Descritor Estendido do Sistema Operacional da Microsoft 2.0

O Descritor Estendido MSOS 2.0 pode ser usado para definir os valores do Registro para adicionar suporte ao Perfil de Autenticação Facial. Isso é feito usando o Descritor de Propriedade do Registro do Microsoft OS 2.0.

Para a entrada do registro UVC-CPV2FaceAuth, o seguinte mostra um conjunto de descritores MSOS 2.0 de exemplo:

UCHAR Example2_MSOS20DescriptorSet_UVCFaceAuthForFutureWindows[0x3C] =
{
    //
    // Microsoft OS 2.0 Descriptor Set Header
    //
    0x0A, 0x00,               // wLength - 10 bytes
    0x00, 0x00,               // MSOS20_SET_HEADER_DESCRIPTOR
    0x00, 0x00, 0x0?, 0x06,   // dwWindowsVersion – 0x060?0000 for future Windows version
    0x3C, 0x00,               // wTotalLength – 60 bytes

    //
    // Microsoft OS 2.0 Registry Value Feature Descriptor
    //
    0x32, 0x00,               // wLength - 50 bytes
    0x04, 0x00,               // wDescriptorType – 4 for Registry Property
    0x04, 0x00,               // wPropertyDataType - 4 for REG_DWORD_LITTLE_ENDIAN
    0x30, 0x00,               // wPropertyNameLength – 36 bytes
    0x55, 0x00, 0x56, 0x00,   // Property Name - "UVC-CPV2FaceAuth"
    0x43, 0x00, 0x2D, 0x00,
    0x43, 0x00, 0x50, 0x00,
    0x56, 0x00, 0x32, 0x00,
    0x46, 0x00, 0x61, 0x00,
    0x63, 0x00, 0x65, 0x00,
    0x41, 0x00, 0x75, 0x00,
    0x74, 0x00, 0x68, 0x00,
    0x00, 0x00, 0x00, 0x00,
    0x04, 0x00,               // wPropertyDataLength – 4 bytes
    0x00, 0x00, 0x01, 0x00    // PropertyData – 0x00010000 (see Payload Schema)
}

Quando a entrada do Registro UVC-CPV2FaceAuth é adicionada, os dispositivos não precisam publicar a entrada do Registro EnableDshowRedirection, conforme descrito nas diretrizes de implementação da Ponte DShow para dispositivos UVC.

No entanto, se o fornecedor do dispositivo precisar dar suporte a versões mais antigas do Windows e/ou precisar habilitar a descompactação do MJPEG no Servidor de Quadros, a entrada do Registro EnableDshowRedirection deverá ser adicionada.

Geração de Grupo de Sensores

Quando os OEMs criam sistemas usando câmeras tipo 1 e tipo 2 para fornecer fluxos RGB e IR para suporte ao Windows Hello, os OEMs devem declarar que as duas câmeras fazem parte de um Grupo de Sensores sintetizado.

Isso é feito declarando uma tag FSSensorGroupId e FSSensorGroupName em um INF de extensão a ser criado na propriedade da interface do dispositivo para cada câmera.

No entanto, se o INF de extensão não for fornecido, os ODMs poderão usar os mesmos descritores MSOS para publicar os valores FSSensorGroupId e FSSensorGroupName. O driver inbox de Classe de Vídeo USB do Windows 10 usará automaticamente qualquer Descritor MSOS cujo Payload Name tenha sido prefixado com "UVC-" e migrará a etiqueta para o repositório de propriedades da interface do dispositivo (removendo o prefixo "UVC-").

Portanto, uma câmera tipo 1 e tipo 2 que publica o seguinte permitirá que o sistema operacional sintetize as câmeras em um Grupo de Sensores de vários dispositivos para uso com o Windows Hello:

UVC-FSSensorGroupId
UVC-FSSensorGroupName

O conteúdo de cada etiqueta deve ser uma string Unicode. O conteúdo do UVC-FSSensorGroupId deve ser uma cadeia de caracteres GUID no seguinte formato:

{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}

O valor do GUID deve ser o mesmo entre as câmeras tipo 1 e tipo 2 e ambas as câmeras devem ser adicionadas ao mesmo chassi físico. Para câmeras internas, o chassi físico é o próprio computador. Para câmeras externas, os módulos câmera tipo 1 e Tipo 2 devem ser integrados ao mesmo dispositivo físico conectado ao computador.

Categorias de interface de dispositivo personalizadas para grupos de sensores

A partir do 19H1, o Windows está fornecendo um mecanismo de extensão especificado por IHV/OEM para permitir a publicação de Grupos de Sensores sintetizados em qualquer categoria personalizada ou predefinida. A geração de um grupo de sensores é definida por IHV/OEMs que fornecem uma chave identificadora do Grupo de Sensores no INF personalizado:

FSSensorGroupId: {GUID Personalizado}
FSSensorGroupName: <Nome amigável usado para o Grupo de Sensores>

Além das duas entradas addreg acima no INF, uma nova entrada AddReg é definida para categorias personalizadas:

FSSensorGroupCategoryList: {GUID}; {GUID};...; {GUID}

Várias categorias são definidas usando uma lista de GUIDs delimitada por ponto e vírgula (;).

Cada dispositivo declarando um FSSensorGroupId correspondente deve declarar o mesmo FSSensorGroupCategoryList. Se a lista não corresponder, todas as listas serão ignoradas e o Grupo de Sensores será publicado por padrão em KSCATEGORY_SENSOR_GROUP como se nenhuma categoria personalizada fosse definida.

Rotação da câmera

Consulte a orientação do dispositivo de câmera

Cache de controle de UVC

Veja o cache de controle UVC

Descritor do BOS e do MS OS 2.0

A câmera compatível com UVC pode especificar valores de configuração de dispositivo específicos do Windows em um descritor BOS de funcionalidade de plataforma em seu firmware usando descritores do Microsoft OS 2.0. Consulte a documentação no descritor do MS OS 2.0 para entender como especificar um descritor BOS válido que transmite a configuração do dispositivo para o sistema operacional.

Cabeçalho do conjunto de descritores do Microsoft OS 2.0

Descritor de propriedade do Registro do Sistema Operacional Microsoft 2.0

Quando um descritor válido do MS OS 2.0 é especificado no firmware, a pilha USB copia os valores de configuração para a chave do registro HW do dispositivo mostrada abaixo:

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Enum\USB\<Device ID>\<Instance ID>\Device Parameters

O driver UVC lê os valores de configuração da chave do Registro HW do dispositivo e configura o dispositivo no sistema operacional adequadamente. Por exemplo, se o firmware especificar o dispositivo a ser registrado como uma câmera de sensor usando um valor de configuração, o driver UVC registrará o dispositivo logo abaixo dessa categoria.

Configurar dispositivos UVC por meio do descritor BOS da plataforma é um mecanismo que foi habilitado no Windows 10, versão 1703, para ajudar os fornecedores de dispositivos UVC a configurar o dispositivo sem a necessidade de um arquivo INF no sistema operacional Windows.

Ainda há suporte para a configuração de dispositivos UVC por meio de INF personalizado e isso tem precedência sobre o mecanismo baseado em descritor BOS. Ao especificar as propriedades do dispositivo por meio do INF, você não precisa adicionar o prefixo "UVC-". Esse prefixo só é necessário para propriedades de dispositivo especificadas por meio do descritor BOS e que são específicas por instância de interface. Se o dispositivo precisar de plug-ins de modo de usuário como DMFT, você precisará fornecer um INF para instalar o DMFT. Ele não pode ser configurado usando firmware.

Valores de configuração com suporte no momento por meio do descritor BOS

Quando o driver UVC vê os valores do registro com o prefixo "UVC-", ele preenche a chave do registro da instância da interface de categoria do dispositivo com os mesmos valores sem o prefixo. O driver faz isso para qualquer variável especificada pelo firmware, não apenas para as listadas acima.

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\DeviceClasses\{e5323777-f976-4f5b-9b55-b94699c46e44}\<Device Symbolic Link>\Device Parameters

Para que o sistema operacional use a funcionalidade de dispositivo da plataforma BOS e os descritores do MS OS 2.0, o descritor do dispositivo deve especificar a versão bcdUSB para ser 0x0210 ou superior.

Exemplo de dispositivo composto

Esta seção fornece um descritor BOS e um descritor ms os 2.0 para um dispositivo composto de exemplo com duas funções de câmera. Uma função é uma câmera colorida UVC e a segunda função é uma câmera UVC IR.

Os descritores de exemplo são os seguintes:

1. Registrar a função de câmera colorida em KSCATEGORY_VIDEO_CAMERA

2. Registrar a função de câmera do IR em KSCATEGORY_SENSOR_CAMERA

3. Habilitar a função de câmera colorida para captura de imagens estáticas

4. Associa as funções da câmera de cor e da câmera IR como um grupo

Após a enumeração do dispositivo, a pilha USB recupera o descritor BOS do dispositivo. Após o descritor BOS, vem uma capacidade de dispositivo específica da plataforma.

#include <usbspec.h>

const BYTE USBVideoBOSDescriptor[0x21] =
{
    /* BOS Descriptor */
    0x05,                       // Descriptor size
    USB_BOS_DESCRIPTOR_TYPE,    // Device descriptor type BOS
    0x21, 0x00,                 // Length 0x21 (33) this and all sub descriptors
    0x01,                       // Number of device capability descriptors

    /* Platform Device Capability Descriptor */
    0x1C,                                   // 28 bytes bLength
    USB_DEVICE_CAPABILITY_DESCRIPTOR_TYPE,  // Platform Descriptor type
    USB_DEVICE_CAPABILITY_PLATFORM,         // bDevCapabilityType PLATFORM
    0,                                      // bReserved
    0xDF, 0x60, 0xDD, 0xD8,                 // PlatformCapabilityUUID
    0x89, 0x45,                             // MS OS2.0 Descriptor
    0xC7, 0x4C,                             // D8DD60DF-4589-4CC7-9CD2-659D9E648A9F
    0x9C, 0xD2, 0x65, 0x9D, 0x9E, 0x64, 0x8A, 0x9F,
                                            // CapabilityData
    0x00, 0x00, 0x00, 0x0A,                 // dwWindowsVersion for Windows 10 and later
    0xC8, 0x02,                             // wLength 0x2C8 (712)
    0x01,                                   // bMS_VendorCode - any value. e.g. 0x01
    0x00                                    // bAltEnumCmd 0
};

O descritor de funcionalidade da plataforma BOS especifica:

1. GUID de funcionalidade da plataforma de descritor do MS OS 2.0

2. Um código de controle do fornecedor bMS_VendorCode (aqui está definido como 1. Pode levar qualquer valor que o fornecedor preferir) para recuperar o descritor ms os 2.0.

3. Esse descritor BOS é aplicável à versão do sistema operacional Windows 10 e posterior.

Depois de visualizar o descritor BOS, a pilha USB emitirá a solicitação de controle específica do fornecedor para recuperar o descritor MS OS 2.0.

Formato da solicitação de controle para recuperar o descritor específico do fornecedor do MS OS 2.0:

bmRequestType

• Direção de transferência de dados – dispositivo para host

• Tipo – Fornecedor

• Destinatário – Dispositivo

bRequest

O valor bMS_VendorCode retornado na estrutura de informações do conjunto de descritores.

wValue

Definido como 0x00.

wIndex

0x7 para MS_OS_20_DESCRIPTOR_INDEX.

wLength

Comprimento do conjunto de descritores do MS OS 2.0, conforme retornado no descritor BOS. 0x25C (604) neste exemplo.

Espera-se que o dispositivo retorne o descritor ms os 2.0 como o especificado em USBVideoMSOS20DescriptorSet.

O USBVideoMSOS20DescriptorSet descreve as funções de cor e IR. Ele especifica os seguintes valores de Descritor do MS OS 2.0:

1. Definir cabeçalho

2. Cabeçalho de subconjunto de configuração

3. Cabeçalho do Subconjunto de Funções da Câmera Colorida

4. Descritor de Características do Valor do Registro para ID do Grupo de Sensores

5. Descritor de recurso de valor do registro para o nome do grupo de sensores

6. Descritor de Recurso de Valor de Registro para habilitar a captura de imagem estática

7. Descritor de valor do registro para ativar o DMFT da plataforma

8. Cabeçalho de Subconjunto de Função da Câmera Infravermelha

9. Descritor de Valor do Registro para ID de grupo de sensores

10. Descritor de recurso do valor de registro para o nome do grupo de sensores

11. Descritor de valor de recurso de registro para registrar a câmera como uma câmera sensora

O firmware terá um manipulador para a solicitação do fornecedor que retornará o descritor ms os 2.0 a seguir para o dispositivo imaginário descrito no início desta seção.

UCHAR USBVideoMSOS20DescriptorSet[0x2C8] =
{
    /* Microsoft OS 2.0 Descriptor Set Header */
    0x0A, 0x00,             // wLength of MSOS20_SET_HEADER_DESCRIPTOR
    0x00, 0x00,             // wDescriptorType == MSOS20_SET_HEADER_DESCRIPTOR
    0x00, 0x00, 0x00, 0x0A, // dwWindowsVersion – 0x10000000 for Windows 10
    0xC8, 0x02,             // wTotalLength - Total length 0x2C8 (712)

    /* Microsoft OS 2.0 Configuration Subset Header */
    0x08, 0x00,             // wLength of MSOS20_SUBSET_HEADER_CONFIGURATION
    0x01, 0x00,             // wDescriptorType == MSOS20_SUBSET_HEADER_CONFIGURATION
    0x00,                   // bConfigurationValue set to the first configuration
    0x00,                   // bReserved set to 0.
    0xBE, 0x02,             // wTotalLength - Total length 0x2BE (702)

    /****************Color Camera Function******************/

    /* Microsoft OS 2.0 Function Subset Header */
    0x08, 0x00,             // wLength of MSOS20_SUBSET_HEADER_FUNCTION
    0x02, 0x00,             // wDescriptorType == MSOS20_SUBSET_HEADER_FUNCTION
    0x00,                   // bFirstInterface field of the first IAD
    0x00,                   // bReserved set to 0.
    0x6E, 0x01,             // wSubsetLength - Length 0x16E (366)

    /****************Register the Color Camera in a sensor group******************/

    /* Microsoft OS 2.0 Registry Value Feature Descriptor */
    0x80, 0x00,             // wLength 0x80 (128) in bytes of this descriptor
    0x04, 0x00,             // wDescriptorType – MSOS20_FEATURE_REG_PROPERTY
    0x01, 0x00,             // wPropertyDataType - REG_SZ
    0x28, 0x00,             // wPropertyNameLength – 0x28 (40) bytes
    'U', 0x00, 'V', 0x00,   // Property Name - "UVC-FSSensorGroupID"
    'C', 0x00, '-', 0x00,
    'F', 0x00, 'S', 0x00,
    'S', 0x00, 'e', 0x00,
    'n', 0x00, 's', 0x00,
    'o', 0x00, 'r', 0x00,
    'G', 0x00, 'r', 0x00,
    'o', 0x00, 'u', 0x00,
    'p', 0x00, 'I', 0x00,
    'D', 0x00, 0x00, 0x00,
    0x4E, 0x00,             // wPropertyDataLength – 0x4E (78) bytes
                            // FSSensorGroupID GUID in string format:
                            // "{20C94C5C-F402-4F1F-B324-0C1CF0257870}"
    '{', 0x00, '2', 0x00,   // This is just an example GUID.
    '0', 0x00, 'C', 0x00,   // You need to generate and use your
    '9', 0x00, '4', 0x00,   // own GUID for the sensor group ID
    'C', 0x00, '5', 0x00,
    'C', 0x00, '-', 0x00,
    'F', 0x00, '4', 0x00,
    '0', 0x00, '2', 0x00,
    '-', 0x00, '4', 0x00,
    'F', 0x00, '1', 0x00,
    'F', 0x00, '-', 0x00,
    'B', 0x00, '3', 0x00,
    '2', 0x00, '4', 0x00,
    '-', 0x00, '0', 0x00,
    'C', 0x00, '1', 0x00,
    'C', 0x00, 'F', 0x00,
    '0', 0x00, '2', 0x00,
    '5', 0x00, '7', 0x00,
    '8', 0x00, '7', 0x00,
    '0', 0x00, '}', 0x00,
    0x00, 0x00,

    /* Microsoft OS 2.0 Registry Value Feature Descriptor */
    0x56, 0x00,             // wLength 0x56 (86) in bytes of this descriptor
    0x04, 0x00,             // wDescriptorType – MSOS20_FEATURE_REG_PROPERTY
    0x01, 0x00,             // wPropertyDataType - REG_SZ
    0x2C, 0x00,             // wPropertyNameLength – 0x2C (44) bytes
    'U', 0x00, 'V', 0x00,   // Property Name - "UVC-FSSensorGroupName"
    'C', 0x00, '-', 0x00,
    'F', 0x00, 'S', 0x00,
    'S', 0x00, 'e', 0x00,
    'n', 0x00, 's', 0x00,
    'o', 0x00, 'r', 0x00,
    'G', 0x00, 'r', 0x00,
    'o', 0x00, 'u', 0x00,
    'p', 0x00, 'N', 0x00,
    'a', 0x00, 'm', 0x00,
    'e', 0x00, 0x00, 0x00,
    0x20, 0x00,             // wPropertyDataLength – 0x20 (32) bytes
                            // FSSensorGroupName "YourCameraGroup"
    'Y', 0x00, 'o', 0x00,
    'u', 0x00, 'r', 0x00,
    'C', 0x00, 'a', 0x00,
    'm', 0x00, 'e', 0x00,
    'r', 0x00, 'a', 0x00,
    'G', 0x00, 'r', 0x00,
    'o', 0x00, 'u', 0x00,
    'p', 0x00, 0x00, 0x00,

    /****************Enable Still Image Capture for Color Camera************/

    /* Microsoft OS 2.0 Registry Value Feature Descriptor */
    0x54, 0x00,             // wLength 0x54 (84) in bytes of this descriptor
    0x04, 0x00,             // wDescriptorType – MSOS20_FEATURE_REG_PROPERTY
    0x04, 0x00,             // wPropertyDataType - REG_DWORD
    0x46, 0x00,             // wPropertyNameLength – 0x46 (70) bytes
    'U', 0x00, 'V', 0x00,   // Property Name - "UVC-EnableDependentStillPinCapture"
    'C', 0x00, '-', 0x00,
    'E', 0x00, 'n', 0x00,
    'a', 0x00, 'b', 0x00,
    'l', 0x00, 'e', 0x00,
    'D', 0x00, 'e', 0x00,
    'p', 0x00, 'e', 0x00,
    'n', 0x00, 'd', 0x00,
    'e', 0x00, 'n', 0x00,
    't', 0x00, 'S', 0x00,
    't', 0x00, 'i', 0x00,
    'l', 0x00, 'l', 0x00,
    'P', 0x00, 'i', 0x00,
    'n', 0x00, 'C', 0x00,
    'a', 0x00, 'p', 0x00,
    't', 0x00, 'u', 0x00,
    'r', 0x00, 'e', 0x00,
    0x00, 0x00,
    0x04, 0x00,              // wPropertyDataLength – 4 bytes
    0x01, 0x00, 0x00, 0x00,   // Enable still pin capture using Method 2 or Method 3

    /****************Enable Platform DMFT for ROI-capable USB Camera************/

    /* Microsoft OS 2.0 Registry Value Feature Descriptor */
    0x3C, 0x00,             // wLength 0x3C (60) in bytes of this descriptor
    0x04, 0x00,             // wDescriptorType – MSOS20_FEATURE_REG_PROPERTY
    0x04, 0x00,             // wPropertyDataType - REG_DWORD
    0x2E, 0x00,             // wPropertyNameLength – 0x2E (46) bytes
    'U', 0x00, 'V', 0x00,   // Property Name - "UVC-EnablePlatformDmft"
    'C', 0x00, '-', 0x00,
    'E', 0x00, 'n', 0x00,
    'a', 0x00, 'b', 0x00,
    'l', 0x00, 'e', 0x00,
    'P', 0x00, 'l', 0x00,
    'a', 0x00, 't', 0x00,
    'f', 0x00, 'o', 0x00,
    'r', 0x00, 'm', 0x00,
    'D', 0x00, 'm', 0x00,
    'f', 0x00, 't', 0x00,
    0x00, 0x00,
    0x04, 0x00,              // wPropertyDataLength – 4 bytes
    0x01, 0x00, 0x00, 0x00,  // Enable Platform DMFT

    /****************IR Camera Function*********************************************/

    /* Microsoft OS 2.0 Function Subset Header */
    0x08, 0x00,             // wLength of MSOS20_SUBSET_HEADER_FUNCTION
    0x02, 0x00,             // wDescriptorType == MSOS20_SUBSET_HEADER_FUNCTION
    0x01,                   // bFirstInterface set of the second function
    0x00,                   // bReserved set to 0.
    0x48, 0x01,             // wSubsetLength - Length 0x148 (328)

    /********Register the IR Camera to the same sensor group as the Color Camera*****/

    /* Microsoft OS 2.0 Registry Value Feature Descriptor */
    0x80, 0x00,             // wLength 0x80 (128) in bytes of this descriptor
    0x04, 0x00,             // wDescriptorType – MSOS20_FEATURE_REG_PROPERTY
    0x01, 0x00,             // wPropertyDataType - REG_SZ
    0x28, 0x00,             // wPropertyNameLength – 0x28 (40) bytes
    'U', 0x00, 'V', 0x00,   // Property Name - "UVC-FSSensorGroupID"
    'C', 0x00, '-', 0x00,
    'F', 0x00, 'S', 0x00,
    'S', 0x00, 'e', 0x00,
    'n', 0x00, 's', 0x00,
    'o', 0x00, 'r', 0x00,
    'G', 0x00, 'r', 0x00,
    'o', 0x00, 'u', 0x00,
    'p', 0x00, 'I', 0x00,
    'D', 0x00, 0x00, 0x00,
    0x4E, 0x00,             // wPropertyDataLength – 78 bytes
                            // FSSensorGroupID GUID in string format:
                            // "{20C94C5C-F402-4F1F-B324-0C1CF0257870}"
    '{', 0x00, '2', 0x00,
    '0', 0x00, 'C', 0x00,
    '9', 0x00, '4', 0x00,
    'C', 0x00, '5', 0x00,
    'C', 0x00, '-', 0x00,
    'F', 0x00, '4', 0x00,
    '0', 0x00, '2', 0x00,
    '-', 0x00, '4', 0x00,
    'F', 0x00, '1', 0x00,
    'F', 0x00, '-', 0x00,
    'B', 0x00, '3', 0x00,
    '2', 0x00, '4', 0x00,
    '-', 0x00, '0', 0x00,
    'C', 0x00, '1', 0x00,
    'C', 0x00, 'F', 0x00,
    '0', 0x00, '2', 0x00,
    '5', 0x00, '7', 0x00,
    '8', 0x00, '7', 0x00,
    '0', 0x00, '}', 0x00,
    0x00, 0x00,

    /* Microsoft OS 2.0 Registry Value Feature Descriptor */
    0x56, 0x00,             // wLength 0x56 (86) in bytes of this descriptor
    0x04, 0x00,             // wDescriptorType – MSOS20_FEATURE_REG_PROPERTY
    0x01, 0x00,             // wPropertyDataType - REG_SZ
    0x2C, 0x00,             // wPropertyNameLength – 0x2C (44) bytes
    'U', 0x00, 'V', 0x00,   // Property Name - "UVC-FSSensorGroupName"
    'C', 0x00, '-', 0x00,
    'F', 0x00, 'S', 0x00,
    'S', 0x00, 'e', 0x00,
    'n', 0x00, 's', 0x00,
    'o', 0x00, 'r', 0x00,
    'G', 0x00, 'r', 0x00,
    'o', 0x00, 'u', 0x00,
    'p', 0x00, 'N', 0x00,
    'a', 0x00, 'm', 0x00,
    'e', 0x00, 0x00, 0x00,
    0x20, 0x00,             // wPropertyDataLength – 32 bytes
                            // FSSensorGroupName "YourCameraGroup"
    'Y', 0x00, 'o', 0x00,
    'u', 0x00, 'r', 0x00,
    'C', 0x00, 'a', 0x00,
    'm', 0x00, 'e', 0x00,
    'r', 0x00, 'a', 0x00,
    'G', 0x00, 'r', 0x00,
    'o', 0x00, 'u', 0x00,
    'p', 0x00, 0x00, 0x00,

    /****************Make IR camera visible to applications*********************/

    /* Microsoft OS 2.0 Registry Value Feature Descriptor */
    0x30, 0x00,             // wLength 0x30 (48) in bytes of this descriptor
    0x04, 0x00,             // wDescriptorType – MSOS20_FEATURE_REG_PROPERTY
    0x04, 0x00,             // wPropertyDataType - REG_DWORD
    0x22, 0x00,             // wPropertyNameLength – 0x22 (34) bytes
    'S', 0x00, 'e', 0x00,
    'n', 0x00, 's', 0x00,
    'o', 0x00, 'r', 0x00,
    'C', 0x00, 'a', 0x00,
    'm', 0x00, 'e', 0x00,
    'r', 0x00, 'a', 0x00,
    'M', 0x00, 'o', 0x00,
    'd', 0x00, 'e', 0x00,
    0x00, 0x00,
    0x04, 0x00,              // wPropertyDataLength – 4 bytes
    0x01, 0x00, 0x00, 0x00, // This exposes the camera to OS as an IR only camera
                            // i.e. KSCATEGORY_SENSOR_CAMERA

    /* Microsoft OS 2.0 Registry Value Feature Descriptor */
    0x3A, 0x00,             // wLength 0x3A (58) in bytes of this descriptor
    0x04, 0x00,             // wDescriptorType – MSOS20_FEATURE_REG_PROPERTY
    0x04, 0x00,             // wPropertyDataType - REG_DWORD
    0x2C, 0x00,             // wPropertyNameLength – 0x2C (44) bytes
    'S', 0x00, 'k', 0x00,
    'i', 0x00, 'p', 0x00,
    'C', 0x00, 'a', 0x00,
    'm', 0x00, 'e', 0x00,
    'r', 0x00, 'a', 0x00,
    'E', 0x00, 'n', 0x00,
    'u', 0x00, 'm', 0x00,
    'e', 0x00, 'r', 0x00,
    'a', 0x00, 't', 0x00,
    'i', 0x00, 'o', 0x00,
    'n', 0x00, 0x00, 0x00,
    0x04, 0x00,             // wPropertyDataLength – 4 bytes
    0x01, 0x00, 0x00, 0x00  // This exposes the camera to applications looking for IR only cameras
};