Visão geral da extensibilidade de metadados
Este tópico apresenta os requisitos para criar manipuladores de metadados personalizados para o WIC (Componente de Imagem do Windows), incluindo leitores de metadados e gravadores. Ele também discute os requisitos para estender a descoberta de componentes em tempo de execução do WIC para incluir seus manipuladores de metadados personalizados.
Este tópico inclui as seções a seguir.
- Pré-requisitos
- Introdução
- Criando um leitor de metadados
- Criando um gravador de metadados
- Instalando e registrando um manipulador de metadados
- Considerações especiais
- Tópicos relacionados
Pré-requisitos
Para entender este tópico, você deve ter uma compreensão detalhada do WIC, seus componentes e metadados para imagens. Para obter mais informações sobre metadados do WIC, consulte a Visão geral dos metadados do WIC. Para obter mais informações sobre componentes WIC, consulte Visão geral do componente de imagem do Windows.
Introdução
Conforme discutido na Visão Geral de Metadados do WIC, geralmente há vários blocos de metadados dentro de uma imagem, cada um expondo diferentes tipos de informações em formatos de metadados diferentes. Para interagir com um formato de metadados inserido em uma imagem, um aplicativo deve usar um manipulador de metadados apropriado. O WIC fornece vários manipuladores de metadados (leitores de metadados e gravadores) que permitem ler e gravar tipos específicos de metadados, como Exif ou XMP.
Além dos manipuladores nativos fornecidos, o WIC fornece APIs que permitem criar novos manipuladores de metadados que participam da descoberta de componentes em tempo de execução do WIC. Isso permite que aplicativos que usam WIC leiam e escrevam seus formatos de metadados personalizados.
As etapas a seguir permitem que os manipuladores de metadados participem da descoberta de metadados em tempo de execução do WIC.
- Implemente uma classe de manipulador de leitor de metadados (IWICMetadataReader) que expõe as interfaces WIC necessárias para ler o formato de metadados personalizado. Isso permite que aplicativos baseados em WIC leiam o formato de metadados da mesma forma que leem formatos de metadados nativos.
- Implemente uma classe de manipulador de gravador de metadados (IWICMetadataWriter) que expõe as interfaces WIC necessárias para codificar seu formato de metadados personalizado. Isso permite que aplicativos baseados em WIC serializem seu formato de metadados em formatos de imagem com suporte.
- Assine e registre digitalmente seus manipuladores de metadados. Isso permite que os manipuladores de metadados sejam descobertos em tempo de execução, correspondendo ao padrão de identificação no Registro com o padrão inserido no arquivo de imagem.
Criando um leitor de metadados
O acesso main a blocos de metadados dentro de um codec é por meio da interface IWICMetadataBlockReader implementada por cada codec WIC. Essa interface enumera cada um dos blocos de metadados inseridos em um formato de imagem para que o manipulador de metadados apropriado possa ser descoberto e instanciado para cada bloco. Os blocos de metadados que não são reconhecidos pelo WIC são considerados desconhecidos e são definidos como o GUID CLSID_WICUnknownMetadataReader. Para ter o formato de metadados reconhecido pelo WIC, você deve criar uma classe que implemente três interfaces: IWICMetadataReader, IWICPersistStream e IWICStreamProvider.
Observação
Se o formato de metadados tiver restrições que renderizam alguns métodos das interfaces necessárias inadequadas, esses métodos deverão retornar WINCODEC_ERR_UNSUPPORTEDOPERATION.
IWICMetadataReader Interface
A interface IWICMetadataReader deve ser implementada ao criar um leitor de metadados. Essa interface fornece acesso aos itens de metadados subjacentes no fluxo de dados de um formato de metadados.
O código a seguir mostra a definição da interface do leitor de metadados, conforme definido no arquivo wincodecsdk.idl.
interface IWICMetadataReader : IUnknown
{
HRESULT GetMetadataFormat(
[out] GUID *pguidMetadataFormat
);
HRESULT GetMetadataHandlerInfo(
[out] IWICMetadataHandlerInfo **ppIHandler
);
HRESULT GetCount(
[out] UINT *pcCount
);
HRESULT GetValueByIndex(
[in] UINT nIndex,
[in, out, unique] PROPVARIANT *pvarSchema,
[in, out, unique] PROPVARIANT *pvarId,
[in, out, unique] PROPVARIANT *pvarValue
);
HRESULT GetValue(
[in, unique] const PROPVARIANT *pvarSchema,
[in] const PROPVARIANT *pvarId,
[in, out, unique] PROPVARIANT *pvarValue
);
HRESULT GetEnumerator(
[out] IWICEnumMetadataItem **ppIEnumMetadata
);
};
O método GetMetadataFormat retorna o GUID do formato de metadados.
O método GetMetadataHandlerInfo retorna uma interface IWICMetadataHandlerInfo que fornece informações sobre o manipulador de metadados. Isso inclui informações como quais formatos de imagem dão suporte ao formato de metadados e se o leitor de metadados requer acesso ao fluxo completo de metadados.
O método GetCount retorna o número de itens de metadados individuais (incluindo blocos de metadados inseridos) encontrados no fluxo de metadados.
O método GetValueByIndex retorna um item de metadados por um valor de índice. Esse método permite que os aplicativos passem por cada item de metadados em um bloco de metadados. O código a seguir demonstra como um aplicativo pode usar esse método para recuperar cada item de metadados em um bloco de metadados.
PROPVARIANT readerValue;
IWICMetadataBlockReader *blockReader = NULL;
IWICMetadataReader *reader = NULL;
PropVariantInit(&readerValue);
hr = pFrameDecode->QueryInterface(IID_IWICMetadataBlockReader, (void**)&blockReader);
if (SUCCEEDED(hr))
{
// Retrieve the third block in the image. This is image specific and
// ideally you should call this by retrieving the reader count
// first.
hr = blockReader->GetReaderByIndex(2, &reader);
}
if (SUCCEEDED(hr))
{
UINT numValues = 0;
hr = reader->GetCount(&numValues);
// Loop through each item and retrieve by index
for (UINT i = 0; SUCCEEDED(hr) && i < numValues; i++)
{
PROPVARIANT id, value;
PropVariantInit(&id);
PropVariantInit(&value);
hr = reader->GetValueByIndex(i, NULL, &id, &value);
if (SUCCEEDED(hr))
{
// Do something with the metadata item.
//...
}
PropVariantClear(&id);
PropVariantClear(&value);
}
}
O método GetValue recupera um item de metadados específico por esquema e/ou ID. Esse método é semelhante ao método GetValueByIndex , exceto que recupera um item de metadados que tem um esquema ou ID específico.
O método GetEnumerator retorna um enumerador de cada item de metadados no bloco de metadados. Isso permite que os aplicativos usem um enumerador para navegar no formato de metadados.
Se o formato de metadados não tiver uma noção de esquemas para itens de metadados, o GetValue... os métodos devem ignorar essa propriedade. No entanto, se o formato der suporte à nomenclatura de esquema, você deverá prever um valor NULL .
Se um item de metadados for um bloco de metadados inserido, crie um manipulador de metadados do substream do conteúdo inserido e retorne o novo manipulador de metadados. Se não houver nenhum leitor de metadados disponível para o bloco aninhado, instancie e retorne um leitor de metadados desconhecido. Para criar um novo leitor de metadados para o bloco inserido, chame os métodos CreateMetadataReaderFromContainer ou CreateMetadataReader da fábrica de componentes ou chame a função WICMatchMetadataContent .
Se o fluxo de metadados contiver conteúdo big-endian, o leitor de metadados será responsável por trocar todos os valores de dados que processar. Ele também é responsável por informar todos os leitores de metadados aninhados de que eles estão trabalhando com o fluxo de dados big-endian. No entanto, todos os valores devem ser retornados no formato little-endian.
Implemente o suporte para navegação de namespace dando suporte a consultas em que a ID do item de metadados é um VT_CLSID (um GUID) correspondente a um formato de metadados. Se um leitor de metadados aninhado para esse formato for identificado durante a análise, ele deverá ser retornado. Isso permite que os aplicativos usem um leitor de consulta de metadados para pesquisar o formato de metadados.
Ao obter um item de metadados por ID, você deve usar a função PropVariantChangeType para coagir a ID para o tipo esperado. Por exemplo, o leitor IFD forçará uma ID a digitar VT_UI2 para coincidir com o tipo de dados de uma ID de marca IFD USHORT. O tipo de entrada e o tipo esperado devem ser PROPVARIANT para fazer isso. Isso não é necessário, mas fazer essa coerção simplifica o código que chama o leitor para consultar itens de metadados.
IWICPersistStream Interface
A interface IWICPersistStream herda de IPersistStream e fornece métodos adicionais para salvar e carregar objetos usando a enumeração WICPersistOptions .
O código a seguir mostra a definição da interface IWICPersistStream , conforme definido no arquivo wincodecsdk.idl.
interface IWICPersistStream : IPersistStream
{
HRESULT LoadEx(
[in, unique] IStream *pIStream,
[in, unique] const GUID *pguidPreferredVendor,
[in] DWORD dwPersistOptions
);
HRESULT SaveEx(
[in] IStream *pIStream,
[in] DWORD dwPersistOptions,
[in] BOOL fClearDirty
);
};
O método LoadEx fornece ao leitor de metadados um fluxo de dados que contém o bloco de metadados. Seu leitor analisa esse fluxo para acessar os itens de metadados subjacentes. O leitor de metadados é inicializado com um substream posicionado no início do conteúdo de metadados brutos. Se o leitor não exigir o fluxo completo, o substream será limitado no intervalo apenas ao conteúdo do bloco de metadados; caso contrário, o fluxo de metadados completo é fornecido com a posição definida no início do bloco de metadados.
O método SaveEx é usado por gravadores de metadados para serializar o bloco de metadados. Quando SaveEx é usado em um leitor de metadados, ele deve retornar WINCODEC_ERR_UNSUPPORTEDOPERATION.
IWICStreamProvider Interface
A interface IWICStreamProvider permite que o leitor de metadados forneça referências ao fluxo de conteúdo, forneça informações sobre o fluxo e atualize as versões armazenadas em cache do fluxo.
O código a seguir mostra a definição da interface IWICStreamProvider , conforme definido no arquivo wincodecsdk.idl.
interface IWICStreamProvider : IUnknown
{
HRESULT GetStream(
[out] IStream **ppIStream
);
HRESULT GetPersistOptions(
[out] DWORD *pdwPersistOptions
);
HRESULT GetPreferredVendorGUID(
[out] GUID *pguidPreferredVendor
);
HRESULT RefreshStream(
);
};
O método GetStream recupera uma referência ao fluxo de metadados. O fluxo retornado deve ter o ponteiro de fluxo redefinido para a posição inicial. Se o formato de metadados exigir acesso completo ao fluxo, a posição inicial deverá ser o início do bloco de metadados.
O método GetPersistOptions retorna as opções atuais do fluxo da enumeração WICPersistOptions .
O método GetPreferredVendorGUID retorna o GUID do fornecedor do leitor de metadados.
O método RefreshStream atualiza o fluxo de metadados. Esse método deve chamar LoadEx com um fluxo NULL para quaisquer blocos de metadados aninhados. Isso é necessário porque os blocos de metadados aninhados e seus itens podem não existir mais devido à edição in-loco.
Criando um gravador de metadados
Um gravador de metadados é um tipo de manipulador de metadados que fornece uma maneira de serializar um bloco de metadados para um quadro de imagem ou fora de um quadro individual se o formato de imagem der suporte a ele. O acesso main aos gravadores de metadados em um codec é por meio da interface IWICMetadataBlockWriter que cada codificador WIC implementa. Essa interface permite que os aplicativos enumerem cada um dos blocos de metadados inseridos em uma imagem para que o gravador de metadados apropriado possa ser descoberto e instanciado para cada bloco de metadados. Os blocos de metadados que não têm um gravador de metadados correspondente são considerados desconhecidos e são definidos como o GUID CLSID_WICUnknownMetadataReader. Para habilitar aplicativos habilitados para WIC para serializar e gravar seu formato de metadados, você deve criar uma classe que implemente as seguintes interfaces: IWICMetadataWriter, IWICMetadataReader, IWICPersistStream e IWICStreamProvider.
Observação
Se o formato de metadados tiver restrições que renderizam alguns métodos das interfaces necessárias inadequadas, esses métodos deverão retornar WINCODEC_ERR_UNSUPPORTEDOPERATION.
IWICMetadataWriter Interface
A interface IWICMetadataWriter deve ser implementada pelo gravador de metadados. Além disso, como IWICMetadataWriter herda de IWICMetadataReader, você também deve implementar todos os métodos de IWICMetadataReader. Como ambos os tipos de manipulador exigem a mesma herança de interface, talvez você queira criar uma única classe que forneça a funcionalidade de leitura e gravação.
O código a seguir mostra a definição da interface do gravador de metadados, conforme definido no arquivo wincodecsdk.idl.
interface IWICMetadataWriter : IWICMetadataReader
{
HRESULT SetValue(
[in, unique] const PROPVARIANT *pvarSchema,
[in] const PROPVARIANT *pvarId,
[in] const PROPVARIANT *pvarValue
);
HRESULT SetValueByIndex(
[in] UINT nIndex,
[in, unique] const PROPVARIANT *pvarSchema,
[in] const PROPVARIANT *pvarId,
[in] const PROPVARIANT *pvarValue
);
HRESULT RemoveValue(
[in, unique] const PROPVARIANT *pvarSchema,
[in] const PROPVARIANT *pvarId
);
HRESULT RemoveValueByIndex(
[in] UINT nIndex
);
};
O método SetValue grava o item de metadados especificado no fluxo de metadados.
O método SetValueByIndex grava o item de metadados especificado no índice especificado no fluxo de metadados. O índice não se refere à ID, mas à posição do item dentro do bloco de metadados.
O método RemoveValue remove o item de metadados especificado do fluxo de metadados.
O método RemoveValueByIndex remove o item de metadados no índice especificado do fluxo de metadados. Depois de remover um item, espera-se que os itens de metadados restantes ocupem o índice desocupado se o índice não for o último índice. Espera-se também que a contagem seja alterada depois que o item for removido.
É responsabilidade do gravador de metadados converter os itens PROPVARIANT na estrutura subjacente exigida pelo formato. No entanto, ao contrário do leitor de metadados, os tipos VARIANT normalmente não devem ser coagidos a tipos diferentes, pois o chamador está indicando especificamente qual tipo de dados usar.
O gravador de metadados deve confirmar todos os itens de metadados no fluxo de imagem, incluindo valores ocultos ou não reconhecidos. Isso inclui blocos de metadados aninhados desconhecidos. No entanto, é responsabilidade do codificador definir quaisquer itens de metadados críticos antes de iniciar a operação de salvamento.
Se o fluxo de metadados contiver conteúdo big-endian, o gravador de metadados será responsável por trocar todos os valores de dados que processar. Ele também é responsável por informar todos os gravadores de metadados aninhados de que eles estão trabalhando com um fluxo de dados big-endian quando eles salvam.
Implemente o suporte para criação e remoção de namespace dando suporte ao conjunto e à remoção de operações em itens de metadados com um tipo de VT_CLSID (um GUID) correspondente a um formato de metadados. O gravador de metadados chama a função WICSerializeMetadataContent para inserir corretamente o conteúdo aninhado do gravador de metadados no gravador de metadados pai.
Se o formato de metadados der suporte à codificação in-loco, você será responsável por gerenciar o preenchimento necessário. Para obter mais informações sobre codificação in-loco, consulte Visão geral e visão geral de metadados wicde leitura e gravação de metadados de imagem.
IWICPersistStream Interface
A interface IWICPersistStream herda de IPersistStream e fornece métodos adicionais para salvar e carregar objetos usando a enumeração WICPersistOptions .
O código a seguir mostra a definição da interface IWICPersistStream , conforme definido no arquivo wincodecsdk.idl.
interface IWICPersistStream : IPersistStream
{
HRESULT LoadEx(
[in, unique] IStream *pIStream,
[in, unique] const GUID *pguidPreferredVendor,
[in] DWORD dwPersistOptions
);
HRESULT SaveEx(
[in] IStream *pIStream,
[in] DWORD dwPersistOptions,
[in] BOOL fClearDirty
);
};
O método LoadEx fornece ao manipulador de metadados um fluxo de dados que contém o bloco de metadados.
O método SaveEx serializa os metadados em um fluxo. Se o fluxo fornecido for o mesmo que o fluxo de inicialização, você deverá executar a codificação in-loco. Se houver suporte para codificação in-loco, esse método deverá retornar WINCODEC_ERR_TOOMUCHMETADATA quando não houver preenchimento suficiente para executar a codificação in-loco. Se não houver suporte para codificação in-loco, esse método deverá retornar WINCODEC_ERR_UNSUPPORTEDOPERATION.
O método IPersistStream::GetSizeMax deve ser implementado e deve retornar o tamanho exato do conteúdo de metadados que seria gravado em salvamento subsequente.
O método IPersistStream::IsDirty deve ser implementado se o gravador de metadados for inicializado por meio de um fluxo, para que uma imagem possa determinar de forma confiável se seu conteúdo foi alterado.
Se o formato de metadados der suporte a blocos de metadados aninhados, o gravador de metadados deverá delegar aos gravadores de metadados aninhados a serialização de seu conteúdo ao salvar em um fluxo.
IWICStreamProvider Interface
A implementação da interface IWICStreamProvider para um gravador de metadados é a mesma de um leitor de metadados. Para obter mais informações, consulte a seção Criando um leitor de metadados neste documento.
Instalando e registrando um manipulador de metadados
Para instalar um manipulador de metadados, você deve fornecer o assembly do manipulador e registrá-lo no registro do sistema. Você pode decidir como e quando as chaves do Registro são preenchidas.
Observação
Para legibilidade, os GUIDs hexadecimal reais não são mostrados nas chaves do Registro mostradas nas seções a seguir deste documento. Para localizar o valor hexadecimal de um nome amigável especificado, consulte os arquivos wincodec.idl e wincodecsdk.idl.
Chaves do Registro do Manipulador de Metadados
Cada manipulador de metadados é identificado por um CLSID exclusivo e cada manipulador é necessário para registrar seu CLSID no GUID de ID da categoria do manipulador de metadados. A ID da categoria de cada tipo de manipulador é definida no wincodec.idl; o nome da ID da categoria para leitores é CATID_WICMetadataReader e o nome da ID da categoria para gravadores é CATID_WICMetadataWriter.
Cada manipulador de metadados é identificado por um CLSID exclusivo e cada manipulador é necessário para registrar seu CLSID no GUID de ID da categoria do manipulador de metadados. A ID da categoria de cada tipo de manipulador é definida no wincodec.idl; o nome da ID da categoria para leitores é CATID_WICMetadataReader e o nome da ID da categoria para gravadores é CATID_WICMetadataWriter.
Observação
Nas listagens de chave do Registro a seguir, {Reader CLSID} refere-se ao CLSID exclusivo que você fornece para o leitor de metadados. {Writer CLSID} refere-se ao CLSID exclusivo que você fornece para o gravador de metadados. {Handler CLSID} refere-se ao CLSID do leitor, ao CLSID do gravador ou a ambos, dependendo de quais manipuladores você está fornecendo. {GUID do Contêiner} refere-se ao objeto de contêiner (formato de imagem ou formato de metadados) que pode conter o bloco de metadados.
As seguintes chaves do Registro registram o manipulador de metadados com os outros manipuladores de metadados disponíveis:
[HKEY_CLASSES_ROOT\CLSID\{CATID_WICMetadataReaders}\Instance\{Reader CLSID}]
CLSID={Reader CLSID}
Friendly Name="Reader Name"
[HKEY_CLASSES_ROOT\CLSID\{CATID_ WICMetadataWriters}\Instance\{Writer CLSID}]
CLSID={Writer CLSID}
Friendly Name="Writer Name"
Além de registrar seus manipuladores em suas respectivas categorias, você também deve registrar chaves adicionais que fornecem informações específicas para o manipulador. Leitores e gravadores compartilham requisitos de chave do Registro semelhantes. A sintaxe a seguir mostra como registrar um manipulador. O manipulador de leitor e o manipulador de gravador devem ser registrados dessa forma, usando seus respectivos CLSIDs:
[HKEY_CLASSES_ROOT\CLSID\{CLSID}]
"Vendor"={VendorGUID}
"Date"="yyyy-mm-dd"
"Version"="Major.Minor.Build.Number"
"SpecVersion"="Major.Minor.Build.Number"
"MetadataFormat"={MetadataFormatGUID}
"RequiresFullStream"=dword:1|0
"SupportsPadding"= dword:1|0
"FixedSize"=0
[HKEY_CLASSES_ROOT\CLSID\{CLSID}\InProcServer32]
@="drive:\path\yourdll.dll"
"ThreadingModel"="Apartment"
[HKEY_CLASSES_ROOT\CLSID\{CLSID}\{LCID}]
Author="Author's Name"
Description = " Metadata Description"
DeviceManufacturer ="Manufacturer Name"
DeviceModels="Device,Device"
FriendlyName="Friendly Name"
Leitores de metadados
O registro do leitor de metadados também inclui chaves que descrevem como o leitor pode ser inserido em um formato de contêiner. Um formato de contêiner pode ser um formato de imagem, como TIFF ou JPEG; também pode ser outro formato de metadados, como um bloco de metadados IFD. Os formatos de contêiner de imagem com suporte nativo são listados em wincodec.idl; cada formato de contêiner de imagem é definido como um GUID com um nome que começa com GUID_ContainerFormat. Os formatos de contêiner de metadados com suporte nativo são listados em wincodecsdk.idl; cada formato de contêiner de metadados é definido como um GUID com um nome que começa com GUID_MetadataFormat.
As chaves a seguir registram um contêiner compatível com o leitor de metadados e os dados necessários para ler desse contêiner. Cada contêiner com suporte do leitor deve ser registrado dessa forma.
[HKEY_CLASSES_ROOT\CLSID\{Reader CLSID}\Containers\{Container GUID}\0]
"Position"=dword:00000000
"Pattern"=hex:ff,ff,ff,...
"Mask"=hex:ff,ff,ff,...
"DataOffset"=dword:00000006
A chave Pattern descreve o padrão binário usado para corresponder o bloco de metadados ao leitor. Ao definir um padrão para o leitor de metadados, ele deve ser confiável o suficiente para que uma correspondência positiva signifique que o leitor de metadados pode entender os metadados no bloco de metadados que está sendo processado.
A chave DataOffset descreve o deslocamento fixo dos metadados do cabeçalho de bloco. Essa chave é opcional e, se não especificada, significa que os metadados reais não podem ser localizados usando um deslocamento fixo do cabeçalho do bloco.
Gravadores de Metadados
O registro do gravador de metadados também inclui chaves que descrevem como gravar o cabeçalho anterior ao conteúdo de metadados inserido em um formato de contêiner. Assim como acontece com o leitor, um formato de contêiner pode ser um formato de imagem ou outro bloco de metadados.
As chaves a seguir registram um contêiner compatível com o gravador de metadados e os dados necessários para gravar o cabeçalho e os metadados. Cada contêiner com suporte do gravador deve ser registrado dessa forma.
[HKEY_CLASSES_ROOT\CLSID\{Writer CLSID}\Containers\{Container GUID}]
"WritePosition"=dword:00000000
"WriteHeader"=hex:ff,ff,ff,...
"WriteOffset"=dword:00000000
A chave WriteHeader descreve o padrão binário do cabeçalho do bloco de metadados a ser gravado. Esse padrão binário coincide com a chave padrão do leitor do formato de metadados.
A chave WriteOffset descreve o deslocamento fixo do cabeçalho de bloco no qual os metadados devem ser gravados. Essa chave é opcional e, se não especificada, significa que os metadados reais não devem ser gravados com o cabeçalho.
Assinando um manipulador de metadados
Todos os manipuladores de metadados devem ser assinados digitalmente para participar do processo de descoberta do WIC. O WIC não carregará nenhum manipulador que não seja assinado por uma autoridade de certificação confiável. Para obter mais informações sobre assinatura digital, consulte Introdução à Assinatura de Código.
Considerações especiais
As seções a seguir incluem informações adicionais que você deve considerar ao criar seus próprios manipuladores de metadados.
PROPVARIANTES
O WIC usa um PROPVARIANT para representar um item de metadados para leitura e gravação. Um PROPVARIANT fornece um tipo de dados e um valor de dados para um item de metadados usado em um formato de metadados. Como gravador de um manipulador de metadados, você tem muita flexibilidade sobre como os dados são armazenados no formato de metadados e como os dados são representados em um bloco de metadados. A tabela a seguir fornece diretrizes para ajudá-lo a decidir sobre o tipo PROPVARIANT apropriado a ser usado em situações diferentes.
| O tipo de metadados é... | Usar o tipo PROPVARIANT | Propriedade PROPVARIANT |
|---|---|---|
| Vazio ou inexistente. | VT_EMPTY | Não aplicável. |
| Indefinido. | VT_BLOB | Use a propriedade blob para definir o tamanho e o ponteiro para o objeto BLOB alocado usando CoTaskMemAlloc. |
| Um bloco de metadados. | VT_UNKNOWN | Esse tipo usa a propriedade punkVal. |
| Uma matriz de tipos. | VT_VECTOR | VT_{type} | Use a propriedade ca{type} para definir a contagem e o ponteiro para a matriz alocada usando CoTaskMemAlloc. |
| Uma matriz de blocos de metadados. | VT_VECTOR | VT_VARIANT | Use a propriedade capropvar para definir a matriz de variantes. |
| Um valor racional assinado. | VT_I8 | Use a propriedade hVal para definir o valor. Defina a palavra alta como o denominador e a palavra baixa para o numerador. |
| Um valor racional. | VT_UI8 | Use a propriedade uhVal para definir o valor. Defina a HighPart como o denominador e a LowPart como o numerador. Observe que LowPart é um int sem sinal. O numerador deve ser convertido de um int sem sinal em um int para garantir que o bit de sinal seja preservado se estiver presente. |
Para evitar redundância na representação de itens de matriz, não use matrizes seguras; use apenas matrizes simples. Isso reduz o trabalho que um aplicativo precisa executar ao interpretar tipos PROPVARIANT .
Evite usar VT_BYREF e armazenar valores embutidos sempre que possível. VT_BYREF é ineficiente para tipos pequenos (comum para itens de metadados) e não fornece informações de tamanho.
Antes de usar um PROPVARIANT, sempre chame PropVariantInit para inicializar o valor. Quando terminar de usar o PROPVARIANT, sempre chame PropVariantClear para liberar qualquer memória alocada para a variável.
Manipuladores 8BIM
Ao escrever um manipulador de metadados para um bloco de metadados 8BIM, você deve usar uma assinatura que encapsula a assinatura 8BIM e a ID. Por exemplo, o leitor nativo de metadados 8BIMIPTC fornece as seguintes informações do Registro para descoberta de leitores:
[HKEY_CLASSES_ROOT\CLSID\{0010668C-0801-4DA6-A4A4-826522B6D28F}\Containers\{16100D66-8570-4BB9-B92D-FDA4B23ECE67}\0]
"Position"=dword:00000000
"Pattern"=hex:38,42,49,4d,04,04
"Mask"=hex:ff,ff,ff,ff,ff,ff
"DataOffset"=dword:00000006
O leitor 8BIMIPTC tem um padrão registrado de 0x38, 0x42, 0x49, 0x4D, 0x04 0x04. Os quatro primeiros bytes (0x38, 0x42, 0x49 0x4D) são a assinatura 8BIM e os dois últimos bytes (0x04, 0x04) são a ID do registro IPTC.
Portanto, para escrever um leitor de metadados 8BIM para obter informações de resolução, você precisaria de um padrão registrado de 0x38, 0x42, 0x49, 0x4D, 0x03 0xED. Novamente, os quatro primeiros bytes (0x38, 0x42, 0x49 0x4D) são a assinatura 8BIM. Os dois últimos bytes (0x03, 0xED), no entanto, são a ID de informações de resolução, conforme definido pelo formato PSD.
Tópicos relacionados
-
Conceitual
-
Outros recursos
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de