Vue d’ensemble de l’extensibilité des métadonnées
Cette rubrique présente les conditions requises pour la création de gestionnaires de métadonnées personnalisés pour le composant WIC (Windows Imaging Component), y compris les lecteurs et les enregistreurs de métadonnées. Il décrit également les conditions requises pour étendre la découverte de composants d’exécution WIC afin d’inclure vos gestionnaires de métadonnées personnalisés.
Cette rubrique contient les sections suivantes.
- Composants requis
- Introduction
- Création d’un lecteur de métadonnées
- Création d’un enregistreur de métadonnées
- Installation et inscription d’un gestionnaire de métadonnées
- Considérations spéciales
- Rubriques connexes
Prérequis
Pour comprendre cette rubrique, vous devez avoir une compréhension approfondie de WIC, de ses composants et des métadonnées pour les images. Pour plus d’informations sur les métadonnées WIC, consultez vue d’ensemble des métadonnées WIC. Pour plus d’informations sur les composants WIC, consultez Vue d’ensemble des composants d’acquisition d’images Windows.
Introduction
Comme indiqué dans la vue d’ensemble des métadonnées WIC, il existe souvent plusieurs blocs de métadonnées dans une image, chacun exposant différents types d’informations dans différents formats de métadonnées. Pour interagir avec un format de métadonnées incorporé dans une image, une application doit utiliser un gestionnaire de métadonnées approprié. WIC fournit plusieurs gestionnaires de métadonnées (lecteurs et rédacteurs de métadonnées) qui vous permettent de lire et d’écrire des types de métadonnées spécifiques, tels qu’Exif ou XMP.
En plus des gestionnaires natifs fournis, WIC fournit des API qui vous permettent de créer de nouveaux gestionnaires de métadonnées qui participent à la découverte de composants d’exécution de WIC. Cela permet aux applications qui utilisent WIC de lire et d’écrire vos formats de métadonnées personnalisés.
Les étapes suivantes permettent à vos gestionnaires de métadonnées de participer à la découverte des métadonnées d’exécution de WIC.
- Implémentez une classe de gestionnaire de lecteur de métadonnées (IWICMetadataReader) qui expose les interfaces WIC requises pour lire votre format de métadonnées personnalisé. Cela permet aux applications WIC de lire votre format de métadonnées de la même façon qu’elles lisent les formats de métadonnées natifs.
- Implémentez une classe de gestionnaire d’enregistreur de métadonnées (IWICMetadataWriter) qui expose les interfaces WIC requises pour l’encodage de votre format de métadonnées personnalisé. Cela permet aux applications WIC de sérialiser votre format de métadonnées dans des formats d’image pris en charge.
- Signez et inscrivez numériquement vos gestionnaires de métadonnées. Cela permet de découvrir vos gestionnaires de métadonnées au moment de l’exécution en faisant correspondre le modèle d’identification dans le Registre avec le modèle incorporé dans le fichier image.
Création d’un lecteur de métadonnées
La main’accès aux blocs de métadonnées dans un codec est via l’interface IWICMetadataBlockReader que chaque codec WIC implémente. Cette interface énumère chacun des blocs de métadonnées incorporés dans un format d’image afin que le gestionnaire de métadonnées approprié puisse être découvert et instancié pour chaque bloc. Les blocs de métadonnées qui ne sont pas reconnus par WIC sont considérés comme inconnus et sont définis comme le GUID CLSID_WICUnknownMetadataReader. Pour que le format de vos métadonnées soit reconnu par WIC, vous devez créer une classe qui implémente trois interfaces : IWICMetadataReader, IWICPersistStream et IWICStreamProvider.
Notes
Si le format de vos métadonnées comporte des restrictions qui rendent certaines méthodes des interfaces requises inappropriées, ces méthodes doivent retourner WINCODEC_ERR_UNSUPPORTEDOPERATION.
IWICMetadataReader, interface
L’interface IWICMetadataReader doit être implémentée lors de la création d’un lecteur de métadonnées. Cette interface permet d’accéder aux éléments de métadonnées sous-éléments dans le flux de données d’un format de métadonnées.
Le code suivant montre la définition de l’interface de lecteur de métadonnées telle que définie dans le fichier 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
);
};
La méthode GetMetadataFormat retourne le GUID de votre format de métadonnées.
La méthode GetMetadataHandlerInfo retourne une interface IWICMetadataHandlerInfo qui fournit des informations sur votre gestionnaire de métadonnées. Cela inclut des informations telles que les formats d’image qui prennent en charge le format des métadonnées et si votre lecteur de métadonnées a besoin d’accéder au flux de métadonnées complet.
La méthode GetCount retourne le nombre d’éléments de métadonnées individuels (y compris les blocs de métadonnées incorporés) trouvés dans le flux de métadonnées.
La méthode GetValueByIndex retourne un élément de métadonnées par une valeur d’index. Cette méthode permet aux applications de parcourir en boucle chaque élément de métadonnées d’un bloc de métadonnées. Le code suivant montre comment une application peut utiliser cette méthode pour récupérer chaque élément de métadonnées dans un bloc de métadonnées.
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);
}
}
La méthode GetValue récupère un élément de métadonnées spécifique par schéma et/ou ID. Cette méthode est similaire à la méthode GetValueByIndex , sauf qu’elle récupère un élément de métadonnées qui a un schéma ou un ID spécifique.
La méthode GetEnumerator retourne un énumérateur de chaque élément de métadonnées dans le bloc de métadonnées. Cela permet aux applications d’utiliser un énumérateur pour parcourir le format de vos métadonnées.
Si votre format de métadonnées n’a pas de notion de schémas pour les éléments de métadonnées, getValue... les méthodes doivent ignorer cette propriété. Si, toutefois, votre format prend en charge l’affectation de noms de schéma, vous devez prévoir une valeur NULL .
Si un élément de métadonnées est un bloc de métadonnées incorporé, créez un gestionnaire de métadonnées à partir du sous-flux du contenu incorporé et retournez le nouveau gestionnaire de métadonnées. Si aucun lecteur de métadonnées n’est disponible pour le bloc imbriqué, instanciez et retournez un lecteur de métadonnées inconnu. Pour créer un lecteur de métadonnées pour le bloc incorporé, appelez les méthodes CreateMetadataReaderFromContainer ou CreateMetadataReader de la fabrique de composants, ou appelez la fonction WICMatchMetadataContent .
Si le flux de métadonnées contient du contenu big-endian, le lecteur de métadonnées est responsable de l’échange des valeurs de données qu’il traite. Il est également chargé d’informer tous les lecteurs de métadonnées imbriqués qu’ils travaillent avec un flux de données big-endian. Toutefois, toutes les valeurs doivent être retournées au format little endian.
Implémentez la prise en charge de la navigation dans l’espace de noms en prenant en charge les requêtes où l’ID d’élément de métadonnées est un VT_CLSID (GUID) correspondant à un format de métadonnées. Si un lecteur de métadonnées imbriqué pour ce format est identifié pendant l’analyse, il doit être retourné. Cela permet aux applications d’utiliser un lecteur de requête de métadonnées pour rechercher votre format de métadonnées.
Lorsque vous obtenez un élément de métadonnées par ID, vous devez utiliser la fonction PropVariantChangeType pour forcer l’ID dans le type attendu. Par exemple, le lecteur IFD force un ID à taper VT_UI2 pour qu’il coïncide avec le type de données d’un ID de balise IFD USHORT. Le type d’entrée et le type attendu doivent être PROPVARIANT pour ce faire. Cela n’est pas obligatoire, mais cette contrainte simplifie le code qui appelle le lecteur à interroger les éléments de métadonnées.
IWICPersistStream Interface
L’interface IWICPersistStream hérite d’IPersistStream et fournit des méthodes supplémentaires pour enregistrer et charger des objets à l’aide de l’énumération WICPersistOptions.
Le code suivant montre la définition de l’interface IWICPersistStream telle que définie dans le fichier 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
);
};
La méthode LoadEx fournit à votre lecteur de métadonnées un flux de données contenant votre bloc de métadonnées. Votre lecteur analyse ce flux pour accéder aux éléments de métadonnées sous-jacents. Votre lecteur de métadonnées est initialisé avec un sous-flux qui est positionné au début du contenu des métadonnées brutes. Si votre lecteur n’a pas besoin du flux complet, le sous-flux est limité dans la plage uniquement au contenu du bloc de métadonnées ; sinon, le flux de métadonnées complet est fourni avec la position définie au début de votre bloc de métadonnées.
La méthode SaveEx est utilisée par les enregistreurs de métadonnées pour sérialiser votre bloc de métadonnées. Lorsque SaveEx est utilisé dans un lecteur de métadonnées, il doit retourner WINCODEC_ERR_UNSUPPORTEDOPERATION.
IWICStreamProvider Interface
L’interface IWICStreamProvider permet à votre lecteur de métadonnées de fournir des références à son flux de contenu, de fournir des informations sur le flux et d’actualiser les versions mises en cache du flux.
Le code suivant montre la définition de l’interface IWICStreamProvider telle que définie dans le fichier wincodecsdk.idl.
interface IWICStreamProvider : IUnknown
{
HRESULT GetStream(
[out] IStream **ppIStream
);
HRESULT GetPersistOptions(
[out] DWORD *pdwPersistOptions
);
HRESULT GetPreferredVendorGUID(
[out] GUID *pguidPreferredVendor
);
HRESULT RefreshStream(
);
};
La méthode GetStream récupère une référence à votre flux de métadonnées. Le flux que vous retournez doit avoir le pointeur de flux réinitialisé à la position de début. Si le format de vos métadonnées nécessite un accès complet au flux de données, la position de début doit être le début de votre bloc de métadonnées.
La méthode GetPersistOptions retourne les options actuelles du flux à partir de l’énumération WICPersistOptions .
La méthode GetPreferredVendorGUID retourne le GUID du fournisseur du lecteur de métadonnées.
La méthode RefreshStream actualise le flux de métadonnées. Cette méthode doit appeler LoadEx avec un flux NULL pour tous les blocs de métadonnées imbriqués. Cela est nécessaire, car les blocs de métadonnées imbriqués et leurs éléments peuvent ne plus exister, en raison d’une modification sur place.
Création d’un enregistreur de métadonnées
Un enregistreur de métadonnées est un type de gestionnaire de métadonnées qui permet de sérialiser un bloc de métadonnées dans un cadre d’image, ou en dehors d’un cadre individuel si le format d’image le prend en charge. L’accès main aux enregistreurs de métadonnées au sein d’un codec est via l’interface IWICMetadataBlockWriter que chaque encodeur WIC implémente. Cette interface permet aux applications d’énumérer chacun des blocs de métadonnées incorporés dans une image afin que l’enregistreur de métadonnées approprié puisse être découvert et instancié pour chaque bloc de métadonnées. Les blocs de métadonnées qui n’ont pas d’enregistreur de métadonnées correspondant sont considérés comme inconnus et sont définis comme le CLSID_WICUnknownMetadataReader GUID. Pour permettre aux applications compatibles WIC de sérialiser et d’écrire votre format de métadonnées, vous devez créer une classe qui implémente les interfaces suivantes : IWICMetadataWriter, IWICMetadataReader, IWICPersistStream et IWICStreamProvider.
Notes
Si le format de vos métadonnées comporte des restrictions qui rendent certaines méthodes des interfaces requises inappropriées, ces méthodes doivent retourner WINCODEC_ERR_UNSUPPORTEDOPERATION.
IWICMetadataWriter, interface
L’interface IWICMetadataWriter doit être implémentée par votre enregistreur de métadonnées. En outre, étant donné que IWICMetadataWriter hérite de IWICMetadataReader, vous devez également implémenter toutes les méthodes d’IWICMetadataReader. Étant donné que les deux types de gestionnaires nécessitent le même héritage d’interface, vous pouvez créer une classe unique qui fournit à la fois des fonctionnalités de lecture et d’écriture.
Le code suivant montre la définition de l’interface d’enregistreur de métadonnées telle que définie dans le fichier 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
);
};
La méthode SetValue écrit l’élément de métadonnées spécifié dans le flux de métadonnées.
La méthode SetValueByIndex écrit l’élément de métadonnées spécifié dans l’index spécifié dans le flux de métadonnées. L’index ne fait pas référence à l’ID, mais à la position de l’élément dans le bloc de métadonnées.
La méthode RemoveValue supprime l’élément de métadonnées spécifié du flux de métadonnées.
La méthode RemoveValueByIndex supprime l’élément de métadonnées à l’index spécifié du flux de métadonnées. Après avoir supprimé un élément, on s’attend à ce que les éléments de métadonnées restants occupent l’index libéré si l’index n’est pas le dernier index. Il est également prévu que le nombre change une fois l’élément supprimé.
Il incombe au rédacteur de métadonnées de convertir les éléments PROPVARIANT dans la structure sous-jacente requise par votre format. Toutefois, contrairement au lecteur de métadonnées, les types VARIANT ne doivent normalement pas être utilisés sous la force de différents types, car l’appelant indique spécifiquement le type de données à utiliser.
Votre enregistreur de métadonnées doit valider tous les éléments de métadonnées dans le flux d’images, y compris les valeurs masquées ou non reconnues. Cela inclut les blocs de métadonnées imbriqués inconnus. Toutefois, il incombe à l’encodeur de définir tous les éléments de métadonnées critiques avant de lancer l’opération d’enregistrement.
Si le flux de métadonnées contient du contenu big-endian, l’enregistreur de métadonnées est responsable de l’échange des valeurs de données qu’il traite. Il est également chargé d’informer tous les rédacteurs de métadonnées imbriqués qu’ils travaillent avec un flux de données big-endian lors de leur enregistrement.
Implémentez la prise en charge de la création et de la suppression d’espaces de noms en prenant en charge les opérations de définition et de suppression sur les éléments de VT_CLSID métadonnées avec un type (GUID) correspondant à un format de métadonnées. L’enregistreur de métadonnées appelle la fonction WICSerializeMetadataContent pour incorporer correctement le contenu de l’enregistreur de métadonnées imbriqué dans l’enregistreur de métadonnées parent.
Si votre format de métadonnées prend en charge l’encodage sur place, vous êtes responsable de la gestion du remplissage requis. Pour plus d’informations sur l’encodage sur place, consultez Vue d’ensemble des métadonnées WIC et Vue d’ensemble de la lecture et de l’écriture de métadonnées d’image.
IWICPersistStream Interface
L’interface IWICPersistStream hérite d’IPersistStream et fournit des méthodes supplémentaires pour enregistrer et charger des objets à l’aide de l’énumération WICPersistOptions.
Le code suivant montre la définition de l’interface IWICPersistStream telle que définie dans le fichier 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
);
};
La méthode LoadEx fournit à votre gestionnaire de métadonnées un flux de données contenant votre bloc de métadonnées.
La méthode SaveEx sérialise les métadonnées dans un flux. Si le flux fourni est identique au flux d’initialisation, vous devez effectuer un encodage sur place. Si l’encodage sur place est pris en charge, cette méthode doit retourner WINCODEC_ERR_TOOMUCHMETADATA lorsque le remplissage est insuffisant pour effectuer l’encodage sur place. Si l’encodage sur place n’est pas pris en charge, cette méthode doit retourner WINCODEC_ERR_UNSUPPORTEDOPERATION.
La méthode IPersistStream::GetSizeMax doit être implémentée et doit retourner la taille exacte du contenu de métadonnées qui serait écrit lors de l’enregistrement suivant.
La méthode IPersistStream::IsDirty doit être implémentée si l’enregistreur de métadonnées est initialisé via un flux, afin qu’une image puisse déterminer de manière fiable si son contenu a changé.
Si votre format de métadonnées prend en charge les blocs de métadonnées imbriqués, votre enregistreur de métadonnées doit déléguer aux enregistreurs de métadonnées imbriqués la sérialisation de son contenu lors de l’enregistrement dans un flux.
IWICStreamProvider Interface
L’implémentation de l’interface IWICStreamProvider pour un enregistreur de métadonnées est identique à celle d’un lecteur de métadonnées. Pour plus d’informations, consultez la section Création d’un lecteur de métadonnées dans ce document.
Installation et inscription d’un gestionnaire de métadonnées
Pour installer un gestionnaire de métadonnées, vous devez fournir l’assembly du gestionnaire et l’inscrire dans le registre système. Vous pouvez décider comment et quand les clés de Registre sont remplies.
Notes
Pour plus de lisibilité, les GUID hexadécimaux réels ne sont pas affichés dans les clés de Registre indiquées dans les sections suivantes de ce document. Pour rechercher la valeur hexadécimale d’un nom convivial spécifié, consultez les fichiers wincodec.idl et wincodecsdk.idl.
Clés de Registre du gestionnaire de métadonnées
Chaque gestionnaire de métadonnées est identifié par un CLSID unique, et chaque gestionnaire doit inscrire son CLSID sous le GUID de l’ID de catégorie du gestionnaire de métadonnées. L’ID de catégorie de chaque type de gestionnaire est défini dans wincodec.idl ; le nom de l’ID de catégorie pour les lecteurs est CATID_WICMetadataReader et le nom de l’ID de catégorie pour les rédacteurs est CATID_WICMetadataWriter.
Chaque gestionnaire de métadonnées est identifié par un CLSID unique, et chaque gestionnaire doit inscrire son CLSID sous le GUID de l’ID de catégorie du gestionnaire de métadonnées. L’ID de catégorie de chaque type de gestionnaire est défini dans wincodec.idl ; le nom de l’ID de catégorie pour les lecteurs est CATID_WICMetadataReader et le nom de l’ID de catégorie pour les rédacteurs est CATID_WICMetadataWriter.
Notes
Dans les listes de clés de Registre suivantes, {Lecteur CLSID} fait référence au CLSID unique que vous fournissez pour votre lecteur de métadonnées. {Writer CLSID} fait référence au CLSID unique que vous fournissez pour votre enregistreur de métadonnées. {Handler CLSID} fait référence au CLSID du lecteur, au CLSID de l’enregistreur ou aux deux, selon les gestionnaires que vous fournissez. {GUID de conteneur} fait référence à l’objet conteneur (format d’image ou format de métadonnées) qui peut contenir le bloc de métadonnées.
Les clés de Registre suivantes inscrivent votre gestionnaire de métadonnées avec les autres gestionnaires de métadonnées disponibles :
[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"
En plus d’inscrire vos gestionnaires dans leurs catégories respectives, vous devez également inscrire des clés supplémentaires qui fournissent des informations spécifiques au gestionnaire. Les lecteurs et les rédacteurs partagent des exigences de clé de Registre similaires. La syntaxe suivante montre comment inscrire un gestionnaire. Le gestionnaire de lecteurs et le gestionnaire d’enregistreur doivent être inscrits de cette manière, à l’aide de leurs CLSID respectifs :
[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"
Lecteurs de métadonnées
L’inscription du lecteur de métadonnées comprend également des clés qui décrivent comment le lecteur peut être incorporé dans un format conteneur. Un format de conteneur peut être un format d’image tel que TIFF ou JPEG ; il peut également s’agir d’un autre format de métadonnées, tel qu’un bloc de métadonnées IFD. Les formats de conteneur d’images pris en charge en mode natif sont répertoriés dans wincodec.idl ; chaque format de conteneur d’images est défini en tant que GUID dont le nom commence par GUID_ContainerFormat. Les formats de conteneur de métadonnées pris en charge en mode natif sont répertoriés dans wincodecsdk.idl ; chaque format de conteneur de métadonnées est défini en tant que GUID dont le nom commence par GUID_MetadataFormat.
Les clés suivantes inscrivent un conteneur que le lecteur de métadonnées prend en charge et les données nécessaires pour lire à partir de ce conteneur. Chaque conteneur pris en charge par le lecteur doit être inscrit de cette manière.
[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
La clé de modèle décrit le modèle binaire utilisé pour faire correspondre le bloc de métadonnées au lecteur. Lors de la définition d’un modèle pour votre lecteur de métadonnées, il doit être suffisamment fiable pour qu’une correspondance positive signifie que le lecteur de métadonnées peut comprendre les métadonnées dans le bloc de métadonnées en cours de traitement.
La clé DataOffset décrit le décalage fixe des métadonnées de l’en-tête de bloc. Cette clé est facultative et, si elle n’est pas spécifiée, signifie que les métadonnées réelles ne peuvent pas être localisées à l’aide d’un décalage fixe de l’en-tête de bloc.
Enregistreurs de métadonnées
L’inscription de l’enregistreur de métadonnées inclut également des clés qui décrivent comment écrire l’en-tête précédant le contenu des métadonnées incorporé dans un format conteneur. Comme pour le lecteur, un format conteneur peut être un format d’image ou un autre bloc de métadonnées.
Les clés suivantes inscrivent un conteneur que l’enregistreur de métadonnées prend en charge, ainsi que les données nécessaires pour écrire l’en-tête et les métadonnées. Chaque conteneur pris en charge par l’enregistreur doit être inscrit de cette manière.
[HKEY_CLASSES_ROOT\CLSID\{Writer CLSID}\Containers\{Container GUID}]
"WritePosition"=dword:00000000
"WriteHeader"=hex:ff,ff,ff,...
"WriteOffset"=dword:00000000
La clé WriteHeader décrit le modèle binaire de l’en-tête de bloc de métadonnées à écrire. Ce modèle binaire coïncide avec la clé de modèle de lecteur du format de métadonnées.
La clé WriteOffset décrit le décalage fixe de l’en-tête de bloc à partir duquel les métadonnées doivent être écrites. Cette clé est facultative et, si elle n’est pas spécifiée, signifie que les métadonnées réelles ne doivent pas être écrites avec l’en-tête.
Signature d’un gestionnaire de métadonnées
Tous les gestionnaires de métadonnées doivent être signés numériquement pour participer au processus de découverte WIC. WIC ne charge pas de gestionnaire qui n’est pas signé par une autorité de certification approuvée. Pour plus d’informations sur la signature numérique, consultez Présentation de la signature de code.
Points particuliers à prendre en compte
Les sections suivantes incluent des informations supplémentaires que vous devez prendre en compte lors de la création de vos propres gestionnaires de métadonnées.
PROPVARIANTS
WIC utilise un PROPVARIANT pour représenter un élément de métadonnées pour la lecture et l’écriture. Un PROPVARIANT fournit un type de données et une valeur de données pour un élément de métadonnées utilisé dans un format de métadonnées. En tant que rédacteur d’un gestionnaire de métadonnées, vous disposez d’une grande flexibilité quant à la façon dont les données sont stockées dans le format de métadonnées et à la façon dont les données sont représentées dans un bloc de métadonnées. Le tableau suivant fournit des instructions pour vous aider à choisir le type PROPVARIANT approprié à utiliser dans différentes situations.
| Le type de métadonnées est... | Utiliser le type PROPVARIANT | PROPVARIANT, propriété |
|---|---|---|
| Vide ou inexistant. | VT_EMPTY | Non applicable. |
| Non défini. | VT_BLOB | Utilisez la propriété blob pour définir la taille et le pointeur vers l’objet BLOB alloué à l’aide de CoTaskMemAlloc. |
| Bloc de métadonnées. | VT_UNKNOWN | Ce type utilise la propriété punkVal. |
| Tableau de types. | VT_VECTOR | VT_{type} | Utilisez la propriété ca{type} pour définir le nombre et le pointeur vers le tableau alloué à l’aide de CoTaskMemAlloc. |
| Tableau de blocs de métadonnées. | VT_VECTOR | VT_VARIANT | Utilisez la propriété capropvar pour définir le tableau de variantes. |
| Valeur rationnelle signée. | VT_I8 | Utilisez la propriété hVal pour définir la valeur. Définissez le mot haut sur le dénominateur et le mot bas sur le numérateur. |
| Valeur rationnelle. | VT_UI8 | Utilisez la propriété uhVal pour définir la valeur. Définissez HighPart sur le dénominateur et LowPart sur le numérateur. Notez que lowPart est un int non signé. Le numérateur doit être converti d’un int non signé en int pour garantir que le bit de signe est conservé s’il est présent. |
Pour éviter la redondance dans la représentation d’éléments de tableau, n’utilisez pas de tableaux sécurisés ; utiliser uniquement des tableaux simples. Cela réduit le travail qu’une application doit effectuer lors de l’interprétation des types PROPVARIANT .
Évitez d’utiliser VT_BYREF et de stocker des valeurs inline chaque fois que possible. VT_BYREF est inefficace pour les petits types (courant pour les éléments de métadonnées) et ne fournit pas d’informations de taille.
Avant d’utiliser un PROPVARIANT, appelez toujours PropVariantInit pour initialiser la valeur. Lorsque vous avez terminé avec PROPVARIANT, appelez toujours PropVariantClear pour libérer la mémoire allouée pour la variable.
8 gestionnairesBIM
Lors de l’écriture d’un gestionnaire de métadonnées pour un bloc de métadonnées 8BIM, vous devez utiliser une signature qui encapsule à la fois la signature 8BIM et l’ID. Par exemple, le lecteur de métadonnées 8BIMIPTC natif fournit les informations de Registre suivantes pour la découverte des lecteurs :
[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
Le lecteur 8BIMIPTC a un modèle inscrit de 0x38, 0x42, 0x49, 0x4D, 0x04, 0x04. Les quatre premiers octets (0x38, 0x42, 0x49, 0x4D) sont la signature 8BIM, et les deux derniers octets (0x04, 0x04) sont l’ID de l’enregistrement IPTC.
Par conséquent, pour écrire un lecteur de métadonnées 8BIM pour les informations de résolution, vous avez besoin d’un modèle inscrit de 0x38, 0x42, 0x49, 0x4D, 0x03, 0xED. Là encore, les quatre premiers octets (0x38, 0x42, 0x49, 0x4D) sont la signature 8BIM. Toutefois, les deux derniers octets (0x03, 0xED) sont l’ID d’informations de résolution tel que défini par le format PSD.
Rubriques connexes
-
Conceptuel
-
Vue d’ensemble de la lecture et de l’écriture de métadonnées d’image
-
Autres ressources
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour