Procédure d'écriture d'un CODEC avec WIC activé et procédure d'obtention d'un support de plate-forme complet pour le format image

Paru le 14 novembre 2006

Peggi Goodwin
directrice de programme, plate-forme
cliente Windows Imaging

S'applique à :
Microsoft WIC (Microsoft Windows Imaging Component)
Microsoft .NET Framework 3.0
Microsoft Windows Vista

Résumé : Le WIC (Windows Imaging Component) est une plate-forme extensible pour l'imagerie numérique dans Windows Vista (également disponible dans Windows XP et dans Windows Server 2003), soit comme partie de .NET Framework 3.0, soit comme composant séparé que vous pouvez redistribuer. Le WIC fournit une couche d'abstraction entre les applications et les CODEC, éliminant la nécessité pour les applications de posséder des connaissances spécialisées concernant les formats d'images spécifiques. Si un CODEC avec WIC activé existe pour le format de l'image installé sur la machine, toute application utilisant le WIC (Windows Imaging Component) peut accéder à des images, les afficher, les traiter, les sauvegarder et les imprimer à l'aide d'un ensemble unique d'interfaces cohérentes, indépendamment du format de l'image.

Windows Vista Explorer, la galerie photos et le visualiseur d'images sont construit sur le WIC. Une fois qu'un CODEC avec WIC activé est installé dans un système Windows Vista, Windows Vista fournit alors le même niveau de support pour le format d'image associé que pour les formats d'image standard intégrés à la plate-forme. Parce que vous écrivez le CODEC pour votre propre format d'image, vous pouvez assurer une qualité cohérente à chaque utilisation du format d'image. Vous tirez ainsi profit d'un support de plate-forme complet tout en protégeant votre investissement IP. (45 pages imprimées)

How to Write a WIC-Enabled CODEC and Get Full Platform Support for Your Image Format Aa905327.us(fr-fr,MSDN.10).gif.

*

Sur cette page

Fonctionnement du WIC (Windows Imaging Component)
Décodage
Codage
Durée de vie du CODEC
Étapes pour rendre un CODEC compatible avec le WIC
Implémentation d'un décodeur avec WIC activé
Interfaces de décodeur
IWICBitmapDecoder
IWICBitmapCodecProgressNotification
IWICMetadataBlockReader
IWICBitmapSourceTransform
IWICDevelopRaw
Implémentation d'un codeur compatible avec le WIC
Interfaces de codeur
IWICBitmapEncoder
IWICBitmapCodecProgressNotification
IWICBitmapFrameEncode
IWICMetadataBlockWriter
Installation et inscription des CODEC
Signature de votre CODEC
Inscription de votre CODEC
Intégration avec l'Explorateur Windows et la Galerie de photos Windows Vista
Installation et désinstallation de votre CODEC
Mise à disposition du CODEC avec WIC activé pour les utilisateurs
Conclusion

Fonctionnement du WIC (Windows Imaging Component)

Découverte et arbitrage

Avant qu'une image puisse être décodée, il faut trouver le CODEC approprié afin de décoder le format de l'image. Dans la plupart des systèmes, les formats d'image pris en charge sont codés en dur. Aucun traitement de découverte n'est donc requis. La plate-forme WIC étant extensible, il est nécessaire de pouvoir identifier le format d'une image et de le faire correspondre à un CODEC approprié.

Pour prendre en charge la découverte lors de l'exécution, chaque format d'image doit posséder un modèle d'identification utilisable pour identifier le décodeur approprié pour ce format. (Nous vous recommandons fortement d'utiliser un GUID pour le modèle d'identification quand il s'agit de nouveaux formats de fichier, ce qui garantie leur caractère unique.) Le modèle d'identification doit être intégré dans chaque fichier image se conformant à ce format d'image. Chaque décodeur possède une entrée de registre qui spécifie quel(s) modèle(s) d'identification du/des format(s) d'image peu(ven)t être décodé(s). Lorsqu'une application doit ouvrir une image, elle fait la demande d'un décodeur du WIC. Le WIC recherche les décodeurs disponibles dans le registre et recherche un modèle d'identification dans chaque entrée de registre, correspondant au modèle intégré dans le fichier image. Nous aborderons ce thème dans Entrées de registre spécifiques au décodeur.

Lorsque le WIC trouve un décodeur unique qui correspond au modèle d'identification de l'image, il instancie le décodeur et lui transfère le fichier image. S'il trouve plusieurs correspondances, une méthode nommée QueryCapability est appelée sur chaque décodeur correspondant pour en faire le tri et pour trouver celui qui correspond le mieux. Nous aborderons ce thème plus en détail dans le chapitre sur la méthode QueryCapability de l'interface IWICBitmapDecoder.

Remarque : Seuls les CODEC protégés peuvent participer au traitement de découverte WIC.

Décodage

Une fois que le décodeur approprié a été sélectionné et instancié, l'application s'adresse directement au décodeur. Le décodeur a plusieurs responsabilités, qu'il implémente par l'intermédiaire de plusieurs interfaces. Ces services peuvent être classés de la sorte :

  • Services du niveau du conteneur

  • Services du niveau de trame

  • Services d'énumération des métadonnées

  • Transformations du décodeur natif

  • Notifications de progression et support d'annulation

  • Services de traitement Raw

Les services au niveau du conteneur incluent la récupération des miniatures de niveau supérieur (si pris en charge), de l'aperçu, de(s) contexte(s) couleur, de la palette (si applicable) et du format conteneur, ainsi que l'accès aux trames d'image individuelles dans le conteneur. (Certains conteneurs ne contiennent qu'une trame unique pendant que d'autres, les TIFF par exemple, peuvent contenir des trames multiples.) Cet ensemble de services inclut également des informations sur le décodeur lui-même et sur ses possibilités quant à un fichier image spécifique.

Les trames individuelles possèderont leurs propres miniatures et leurs contextes couleur, leurs palettes, etc. peuvent également être exposés au niveau de la trame. Toutefois, l'opération la plus importante effectuée au niveau de la trame est le décodage réel des octets image de ce cadre.

Le WIC fournit des lecteurs de métadonnées pour les formats de métadonnées les plus communs (IFD, EXIF, IPTC, XMP, APP0, APP1, etc.), et prend également en charge l'extensibilité pour les formats de métadonnées tiers. Cela évite au CODEC la responsabilité d'analyser les métadonnées. Cependant, le CODEC est responsable de l'énumération des blocs de métadonnées et de la requête du lecteur de métadonnées pour chaque bloc. Le WIC effectue la découverte des gestionnaires de métadonnées de la même manière que pour les CODEC, basée sur un modèle dans l'en-tête de bloc correspondant à un modèle dans l'entrée de registre du gestionnaire de métadonnées. Nous aborderons le sujet dans le chapitre Entrées de registre spécifiques au décodeur, dans Installation et enregistrement de CODEC.

Les décodeurs ne sont pas nécessaires aux opérations de transformation de support en mode natif. Cela permet cependant des optimisations de performance significatives, donc une meilleure expérience utilisateur. Par exemple, une application peut créer un canal de transformations diverses (dimensionnement, découpage, rotation, conversion dans le format pixel) pour effectuer sur une image avant que l'image ne s'affiche. (Nous aborderons le thème des canaux de transformation dans le chapitre IWICBitmapSource.) Après avoir créé un canal de transformation, l'application fait la demande de transformation finale dans le canal, afin de produire le bitmap résultant de l'application de toutes les transformations sur la source de l'image. À ce stade, si le décodeur lui-même peut effectuer des opérations de transformation, le WIC lui demande quelle(s) sont les transformation(s) qui peu(ven)t être effectuée(s). Toute transformation demandée que le décodeur ne peut effectuer, sera effectuée par le WIC sur l'image décodée avant d'être retournée à l'appelant. Ce canal de transformation optimisé fournit une meilleure performance que lorsque chaque transformation est effectuée de manière séquentielle en mémoire, particulièrement lorsque toutes ou partie des transformations peuvent être accomplies lors du traitement de décodage.

Les services de traitement Raw incluent des paramètres de réglages de l'appareil photo, tels que l'exposition, le contraste, l'accentuation de la netteté, etc. ou la modification de l'espace de couleur avant le traitement de bits bruts.

Les notifications de progression et le support d'annulation permettent à une application de demander des notifications de progression pour des opérations longues. Elles permettent également à l'application de donner à l'utilisateur la possibilité d'annuler une opération trop longue. C'est une fait important car si un utilisateur ne peut annuler une opération, il peut avoir l'impression que le traitement est suspendu et va tenter de l'annuler en fermant l'application.

Ces interfaces sont décrites en détail dans la section Implémentation d'un décodeur avec WIC activé.

Codage

Tout comme les décodeurs, les codeurs ont des responsabilités qu'ils implémentent par des interfaces. Les services fournis par les codeurs sont complémentaires des services fournis par les décodeurs, sauf qu'ils écrivent des donnés d'image au lieu de les lire. Les codeurs fournissent également des services dans les catégories suivantes :

  • Services du niveau du conteneur

  • Services du niveau de trame

  • Services d'énumération et de mise à jour des métadonnées

  • Notifications de progression et support d'annulation

Les services au niveau du conteneur pour un codeur, incluent le paramétrage de la miniature de niveau supérieur (si pris en charge), de l'aperçu, de la palette (si applicable) et de l'itération par les trames d'image individuelles afin qu'elles puissent être sérialisées dans le conteneur.

Les services au niveau de la trame pour un codeur reflètent ceux pour un décodeur, sauf qu'ils écrivent les données d'image, les miniatures et toute palette associée, etc., au lieu de les lire.

De la même façon, les services d'énumération des métadonnées pour un codeur incluent l'itération par les blocs de métadonnées à écrire et l'appel des enregistreurs de métadonnées appropriés pour sérialiser les métadonnées sur le disque.

Ces interfaces sont décrites en détail dans la section Implémentation d'un décodeur avec WIC activé.

Durée de vie du CODEC

Un CODEC WIC est instancié pour gérer une seule image et sa durée de vie est généralement courte. Il est créé lorsque une image est chargée et publié lorsque l'image est fermée. Il se peut qu'une application utilise un grand nombre de CODEC au même moment qu'un chevauchement des durées de vie (pensez à dérouler à l'aide d'un répertoire contenant des centaines d'images). De même, il se peut que des applications multiples le fassent également au même moment.

Il se peut que vous ayez préalablement écrit des CODEC dont la durée de vie est définie sur celle du traitement dans lequel ils vivent. Ce n'est pas le cas avec les CODEC WIC. La galerie photos, l'explorateur et le visualiseur photos de Windows Vista, de même que de nombreuses autres applications, sont construits sur le WIC et utiliseront votre CODEC pour afficher des images et des miniatures. Si la durée de vie de votre CODEC a été définie sur celle du traitement, à chaque fois qu'une image ou une miniature a été affichée dans Windows Vista Explorer, le CODEC instancié pour décoder cette image, est resté en mémoire jusqu'à ce que l'utilisateur redémarre sa machine. Si votre CODEC n'est jamais déchargé, cela peut en effet entraîner une fuite dans ses ressources qui ne peuvent être utilisées par un autre composant du système.

Étapes pour rendre un CODEC compatible avec le WIC

  1. Implémentez une classe de décodeur au niveau du conteneur et une classe de décodeur au niveau de la trame qui exposent les interfaces WIC requises pour décoder les images et itérer par les blocs de métadonnées. Cela permet à toutes les applications basées sur le WIC d'interagir avec votre CODEC de la même manière qu'elles interagissent avec des formats d'image standards.

  2. Implémentez une classe de décodeur au niveau du conteneur et une classe de décodeur au niveau de la trame qui exposent les interfaces WIC requises pour encoder les images et sérialiser les blocs de métadonnées dans un fichier image.

  3. Si votre format de conteneur n'est pas basé sur un conteneur TIFF ou JPEG, il se peut que vous ayez besoin d'écrire des gestionnaires de métadonnées pour les formats de métadonnées de base (EXIF, XMP). Cependant, si vous utilisez un format de conteneur basé sur TIFF ou JPEG, cela n'est pas nécessaire car vous pouvez déléguer aux gestionnaires de métadonnées fournis par le système. (La plupart des auteurs de CODEC n'auront pas besoin d'implémenter leurs propres gestionnaires de métadonnées, ce livre blanc ne décrira pas la procédure d'écriture d'un gestionnaire de métadonnées.)

  4. Intégrez un modèle d'identification unique (un GUID est recommandé) dans tous vos fichiers d'images. Cela permet à votre format d'image d'être mis en correspondance avec votre CODEC lors de la découverte. (Si vous écrivez un wrapper de WIC pour un format d'image existant, il vous faut trouver un modèle de bits que le codeur écrit toujours dans ses fichiers image qui soit unique à ce format d'image et l'utilise en tant que modèle d'identification.)

  5. Protéger votre CODEC.

  6. Enregistrer votre CODEC au moment de l'installation. Cela permet à votre CODEC d'être découvert au moment de l'exécution en faisant correspondre le modèle d'identification dans le registre avec le modèle intégré dans le fichier image.

Remarque importante

Dans les descriptions d'interface de cet article, chaque fois qu'une méthode est répertoriée avec la valeur Requis, cela signifie que la méthode nécessite une implémentation complète. Lorsqu'une méthode est répertoriée avec la valeur Facultatif, il faut que la méthode soit encore incluse dans les classes qui implémentent l'interface, mais il vaut mieux renvoyer un code d'erreur approprié plutôt que de fournir une implémentation en cours.

Pour certaines méthodes, vous devrez renvoyer un code d'erreur spécifique pour prévenir l'appelant que la fonctionnalité demandée n'est pas prise en charge. Par exemple, si vous ne prenez pas en charge les miniatures d'ensemble, vous devez renvoyer WINCODEC_ERR_CODECNOTHUMBNAIL depuis la méthode GetThumbnail. Si l'image que vous codez/décodez n'utilise pas un format de pixel indexé ou si vous ne prenez pas en charge une palette au niveau du conteneur, vous devez renvoyer WINCODEC_ERR_PALETTEUNAVAILABLE depuis la méthode SetPalette. Pour toute autre méthode non prise en charge, renvoyez WINCODEC_ERR_UNSUPPORTEDOPERATION.

Tout au long de cet article, j'utiliserai parfois des exemples de code pour illustrer une procédure. Pou rester bref, j'ai omis toutes les vérifications d'erreur et tous les comptages de référence. Si vous coupez-collez l'un de ces exemples, veuillez vous rappeler que le code est incomplet sans la vérification d'erreur et le comptage de référence.

Implémentation d'un décodeur avec WIC activé

Implémenter un décodeur WIC nécessite l'écriture de deux classes. Les interfaces sur ces classes correspondent directement aux responsabilités du décodeur détaillées plus haut dans la section Décodage dans Fonctionnement du WIC (Windows Imaging Component).

L'une de ces classes fournit des services au niveau du conteneur comme décrit ci-dessus et implémente l'interface IWICBitmapDecoder. Si votre format d'image supporte des métadonnées au niveau du conteneur, vous aurez également besoin d'implémenter l'interface IWICMetadataBlockReader sur cette classe. Nous vous recommandons de prendre en charge l'interface IWICBitmapCodecProgressNotification sur le décodeur et le codeur pour supporter une meilleure expérience utilisateur.

L'autre classe que vous implémenterez fournit des services du niveau de trame et effectue le décodage en cours des bits de l'image pour chaque trame dans le conteneur. Cette classe implémente l'interface IWICBitmapFrameDecode et l'interface IWICMetadataBlockReader. Si vous écrivez un décodeur pour un format brut, vous implémenterez également l'interface IWICDevelopRaw sur cette classe. En plus des interfaces requises, il est fortement recommandé d'implémenter l'interface IWICBitmapSourceTransform sur cette classe pour obtenir la meilleure performance possible pour votre format d'image.

L'un des objets fournis par WIC est ImagingFactory. Vous utiliserez fréquemment l'interface IWICComponentFactory sur cet objet pour créer des composants variés. Puisque vous l'utiliserez fréquemment, vous voudrez probablement en garder une référence en tant que propriété de membre sur les classes de décodeur et de codeur.

      IWICImagingFactory* m_piImagingFactory = NULL;
      IWICComponentFactory* m_piComponentFactory = NULL;
      HRESULT hr;

      hr = CoCreateInstance(CLSID_WICImagingFactory, NULL,
      CLSCTX_INPROC_SERVER, IID_IWICImagingFactory,
      (LPVOID*) m_piImagingFactory);

      hr = m_piImagingFactory->QueryInterface(
      IID_IWICComponentFactory, (void**)&m_piComponentFactory);

Interfaces de décodeur

Les tableaux suivants montrent les interfaces implémentées par les décodeurs WIC. Le diagramme pour la classe en montre une hiérarchie d'héritage.

Interfaces de décodeur au niveau du conteneur

Interface

Responsabilités

Implémentation

IWICBitmapDecoder

Services du niveau du conteneur

Requis

IWICBitmapCodecProgressNotification

Notification de progression & support d'annulation

Recommandé

IWICMetadataBlockReader

Énumération des métadonnées

Facultatif (Requis seulement pour les formats qui prennent en charge les métadonnées au niveau du conteneur)

Interfaces de décodeur du niveau de trame

Interface

Responsabilités

Implémentation

IWICBitmapFrameDecode

Services du niveau de trame

Requis

IWICMetadataBlockReader

Énumération des métadonnées

Requis

IWICBitmapSourceTransform

Transformations du décodeur natif

Recommandé

IWICDevelopRaw

Services de traitement Raw

Requis pour les formats bruts seulement

Aa905327.wiccodec01(fr-fr,MSDN.10).jpg

Figure 1. Interfaces de décodeur WIC

IWICBitmapDecoder

Lorsqu'une application demande un décodeur, le premier point d'interaction avec le CODEC se fait par l'interface IWICBitmapDecoder. Il s'agit de l'interface au niveau du conteneur qui fournit un accès aux propriétés de niveau supérieur du conteneur et le plus important, aux trames qu'elle contient. Il s'agit de l'interface principale sur votre classe de décodeur au niveau du conteneur.

Interface IWICBitmapDecoder : |Inconnu

{
// Méthodes requises
HRESULT QueryCapability ( IStream *pIStream, DWORD *pdwCapabilities );
HRESULT Initialize ( IStream *pIStream, WICDecodeOptions cacheOptions );
HRESULT GetContainerFormat ( GUID *pguidContainerFormat);
HRESULT GetDecoderInfo ( IWICBitmapDecoderInfo *pguidIDecoderInfo);
HRESULT GetFrameCount ( UINT *pguidIDecoderInfo);
HRESULT GetFrame ( UINT index, IWICBitmapFrameDecode **ppIBitmapFrame );
// Méthodes facultatives
HRESULT GetPreview ( IWICBitmapSource **ppIPreview );
HRESULT GetThumbnail ( IWICBitmapSource **ppIThumbnail );
HRESULT GetColorContexts ( UINT cCount, IWICColorContext **ppIColorContexts, UINT *pcActualCount );
HRESULT GetMetadataQueryReader ( IWICMetadataQueryReader **ppIMetadataQueryReader );
HRESULT CopyPalette ( IWICPalette **ppIPalette );
}
        

Certains formats d'image ont des miniatures, des contextes couleur et/ou des métadonnées d'ensemble, tandis que de nombreux formats d'images ne proposent ces éléments qu'en fonction de la trame. C'est pourquoi les méthodes d'accès à ces éléments sont facultatives sur IWICBitmapDecoder, mais elles sont obligatoires sur IWICBitmapFrameDecode. De la même manière, certains CODEC n'utilisent pas les formats pixel indexé et ils n'ont donc pas besoin d'implémenter les méthodes CopyPalette sur chaque interface. Nous évoquerons les méthodes facultatives sur IWICBitmapDecoder dans la section IWICBitmapFrameDecode, où elles sont plus généralement implémentées.

QueryCapability est la méthode utilisée pour l'arbitrage des CODEC. (Voir Découverte et arbitrage dans la section Fonctionnement du WIC (Windows Imaging Component) au début de cet article.) Cette méthode est très importante car, lorsque deux CODEC sont capables de décoder le même format d'image ou lorsque, dans un conflit de modèle, deux CODEC utilisent le même modèle d'identification, elle nous permet de sélectionner le CODEC qui peut le mieux traiter une image spécifique.

En évoquant cette méthode, WIC vous transmettra le flux réel contenant l'image. Il est de votre responsabilité de vérifier si vous pouvez décoder chaque trame dans l'image et énumérer via les blocs de métadonnées afin de déclarer précisément quelles capacités ce décodeur possède par rapport au fichier spécifique qui lui est transmis. Cette étape est importante pour tous les décodeurs, mais elle l'est d'autant plus pour les formats d'images basés sur des conteneurs TIFF. Le processus de découverte consiste à faire correspondre les modèles associés aux décodeurs dans le registre avec les modèles présents dans le fichier image réel. Le fait de déclarer votre modèle d'identification dans le registre garantit que votre décodeur sera toujours détecté pour les images dans votre format d'image, mais cela ne garantit pas que le décodeur ne sera pas détecté pour les images dans d'autres formats. Par exemple, tous les conteneurs TIFF incluent le modèle TIFF, qui est un modèle d'identification valide pour le format d'image TIFF. Cela signifie que les fichiers d'image comporteront au moins deux modèles d'identification pendant la découverte, pour tout format d'image basé sur un conteneur de style TIFF. L'un de ces modèles constituera le modèle TIFF tandis que le second sera le modèle du format d'image réel. Même si cela reste peut probable, des conflits entre d'autres formats d'image pourraient également avoir lieu. C'est pourquoi le processus de découverte et d'arbitrage est un processus à deux étapes. Vous devez toujours vérifier que le flux d'image transmis à QueryCapabilities est réellement une instance valide de votre propre format d'image. Par ailleurs, si votre CODEC décode un format d'image pour lequel vous ne possédez pas la spécification, l'implémentation de QueryCapabilities devrait vérifier la présence de tout élément pouvant être valide sous la spécification du format d'image que votre CODEC n'implémente pas. Ceci garantira que les utilisateurs auront une bonne expérience de votre CODEC et qu'ils ne seront pas confrontés à des pannes de décodage inutiles ou n'obtiendront pas de résultats inattendus.

Avant de procéder à quelconque opération sur l'image, vous devez enregistrer la position actuelle du flux afin de pouvoir le restaurer dans sa position d'origine avant le renvoi de la méthode.

L'énumération qui spécifie les capacités est définie comme suit :

 
enum WICBitmapDecoderCapabilities
{         
  WICBitmapDecoderCapabilitySameEncoder,
	WICBitmapDecoderCapabilityCanDecodeAllImages,
	WICBitmapDecoderCapabilityCanDecodeSomeImages,
	WICBitmapDecoderCapabilityCanEnumerateMetadata,
	WICBitmapDecoderCapabilityCanDecodeThumbnail    
}
        

Vous devez seulement déclarer WICBitmapDecoderCapabilitySameEncoder si l'image a été codée par votre codeur. Après avoir vérifié si vous pouvez décoder chaque trame dans le conteneur, déclarez WICBitmapDecoderCapabilityCanDecodeSomeImages si vous pouvez décoder certains trames mais pas toutes ou WICBitmapDecoderCapabilityCanDecodeAllImages si vous pouvez décoder la totalité des trames ou ne déclarez rien si vous ne pouvez décoder aucune trame. (Ces deux énumérations sont réciproquement exclusives ; si vous renvoyez WICBitmapDecoderCapabilityCanDecodeAllImages, WICBitmapDecoderCapabilityCanDecodeSomeImages sera ignoré.) Déclarez WICBitmapDecoderCapabilityCanEnumerateMetadata après avoir vérifié si vous pouvez énumérer via les blocs de métadonnées dans le conteneur d'image. Il n'est pas nécessaire de rechercher une miniature dans toutes les trames. S'il y a une miniature d'ensemble et que vous pouvez la décoder, vous pouvez déclarer WICBitmapDecoderCapabilityCanDecodeThumbnail. S'il n'y a pas de miniature d'ensemble, essayez de décoder la miniature pour la trame 0. S'il n'y a pas de miniature à ces emplacements, ne déclarez pas cette capacité.

Après avoir déterminé les capacités du décodeur par rapport au flux d'image transmis à cette méthode, liez les capacités WICBitmapDecoderCapabilities avec un opérateur logique OR (|) après avoir vérifié que ce décodeur peut effectuer ces capacités sur cette image, puis renvoyez le résultat. Pensez à restaurer le flux dans sa position originale avant de renvoyer !

Initialize est appelé par une application après qu'un décodeur a été sélectionné pour décoder une image spécifique. Le flux d'image est transmis au décodeur et de manière facultative, un appelant peut spécifier l'option de cache pour traiter les métadonnées dans le fichier.

enum WICDecodeOptions      
{          
  WICDecodeMetadataCacheOnDemand,               
  WICDecodeMetadataCacheOnLoad            
}
        

Certaines applications utilisent les métadonnées plus que d'autres. La plupart des applications n'ont pas besoin d'accéder à toutes les métadonnées dans un fichier d'image et elles demanderont les métadonnées spécifiques si nécessaire. D'autres applications mettront en cache toutes les métadonnées au départ plutôt que de garder le flux de fichier ouvert et d'exécuter des opérations d'E/S à chaque fois qu'elles ont besoin d'accéder aux métadonnées. Si l'appelant ne spécifie pas une option de cache de métadonnées, le comportement de mise en cache par défaut doit être à la demande. Cela signifie qu'aucune métadonnée ne devra être chargée dans la mémoire jusqu'à ce que l'application fasse une demande spécifique pour cette métadonnée. Si l'application spécifie WICDecodeMetadataCacheOnLoad, les métadonnées doivent être immédiatement chargées dans la mémoire puis mises en cache. Lorsque les métadonnées sont mises en cache en chargement, le flux de fichier peut être libéré après que les métadonnées ont été mises en cache.

GetContainerFormat est une méthode simple à implémenter. Renvoyez simplement le GUID du format d'image de l'image pour laquelle le décodeur est instancié. Cette méthode est également implémentée sur IWICMetadataBlockReader et IWICBitmapEncoder.

GetDecoderInfo renvoie un objet IWICBitmapDecoderInfo. Pour obtenir l'objet IWICBitmapDecoderInfo, transmettez simplement le GUID de votre décodeur à la méthode CreateComponentInfo sur IWICComponentFactory, puis demandez l'interface IWICDecoderInfo comme illustré ci-dessous.

        IWICComponentInfo* piComponentInfo = NULL;
        HRESULT hr;

        hr = m_piComponentFactory->CreateComponentInfo(CLSID_This,
        &piComponentInfo);
        hr = piComponentInfo->QueryInterface(IID_IWICBitmapDecoderInfo,
        (void**)ppIDecoderInfo);

GetFrameCount renvoie simplement le nombre de trames présentes dans le conteneur. Certains formats de conteneurs prennent en charge plusieurs trames et d'autres prennent seulement en charge une seule trame par conteneur.

GetFrame est probablement la méthode la plus importante sur l'interface IWICBitmapDecoder car la trame contient les bits de l'image réelle et l'objet du décodeur de trame renvoyé par cette méthode correspond à l'objet qui effectue le décodage réel de l'image demandée. Il s'agit de l'autre objet que vous devez implémenter lors de l'écriture d'un décodeur. Reportez-vous à IWICBitmapFrameDecode ci-dessous pour plus d'informations sur cette interface.

GetPreview renvoie un aperçu de l'image. Pour une description détaillée des aperçus, veuillez vous référer à la méthode SetPreview sur l'interface IWICBitmapEncoder.

Si votre format d'image contient un aperçu JPEG intégré, il n'est pas nécessaire de rédiger un décodeur JPEG pour le décoder. En fait, nous vous recommandons fortement de ne pas le faire. Il est plutôt conseillé de déléguer le décodage des aperçus et des miniatures au décodeur JPEG fourni avec la plate-forme WIC. Pour ce faire, accédez au début des données de l'image d'aperçu dans le flux et appelez la méthode CreateDecoderFromStream sur la fabrique d'image.

        IWICBitmapDecoder* piPreviewDecoder = NULL;
        IWICBitmapFrameDecode* piPreviewFrame = NULL;
        IWICBitmapSource* piPreview = NULL;
        HRESULT hr;

        hr = m_piImagingFactory->CreateDecoderFromStream(m_piStream,
        NULL, WICDecodeMetadataCacheOnDemand, &piPreviewDecoder);
        hr = piPreviewDecoder->GetFrame(0, piPreviewFrame);
        hr = piPreviewFrame->QueryInterface(IID_IWICBitmapSource,
        (void**)&piPreview);

IWICBitmapCodecProgressNotification

Lorsqu'un CODEC effectue une opération d'E/S telles que CopyPixels ou WritePixels sur une image de grande taille, cela peut demander plusieurs minutes. À propos des applications, les utilisateurs finaux se plaignent généralement du fait que lorsqu'ils ne peuvent pas interrompre une opération de longue durée, ils pensent que l'application est suspendue. Parfois, l'utilisateur fermera l'application ou redémarrera la machine dans le but de reprendre le contrôle de l'ordinateur lorsqu'une application ne répond plus.

Cette interface permet à une application de spécifier une fonction de rappel que le CODEC peut utiliser à des intervalles spécifiés pour avertir l'appelant de la progression de l'opération en cours. L'application peut utiliser la fonction de rappel pour afficher l'IU progression pour notifier l'utilisateur de l'état de l'opération. Si un utilisateur clique sur le bouton Annuler sur la boîte de dialogue de progression, l'application renvoie WINCODEC_ERR_ABORTED à partir de la fonction de rappel. Lorsque cela se produit, le CODEC doit annuler l'opération spécifiée et propager ce HRESULT vers l'appelant de la méthode qui a effectué cette opération.

Cette interface doit être implémentée sur votre classe de décodeur au niveau du conteneur.

        interface IWICBitmapCodecProgressNotification : public IUnknown
        {
               HRESULT RegisterProgressNotification (
        PFNProgressNotification pfnProgressNotification,
        LPVOID pvData,
        DWORD dwProgressFlags );
        }

RegisterProgressNotification est appelé par une application pour enregistrer une fonction de rappel que le CODEC peut appeler à des intervalles spécifiés. Le premier paramètre, pfnProgressNotification, est un pointeur vers la fonction de rappel que le CODEC doit appeler à des intervalles réguliers.

Le paramètre pvData pointe vers un objet que l'appelant souhaite transmettre à la fonction de rappel via le CODEC, chaque fois que la fonction de rappel est appelée. Cet objet n'a probablement rien de particulier et il n'a aucune importance pour le CODEC.

Le paramètre dwProgressFlags indique le moment où le CODEC doit appeler la fonction de rappel. Il existe deux énumérations qui peuvent être liés par un opérateur logique OR (|) pour ce paramètre. Il s'agit de WICProgressOperation et WICProgressNotification.

L'énumération enum WICProgressOperation indique s'il faut appeler la fonction de rappel pendant le décodage (WICProgressOperationCopyPixels), pendant le codage (WICProgressOperationWritePixels) ou les deux (WICProgressOperationAll).

          enum WICProgressOperation
        
        
          {        WICProgressOperationCopyPixels,
        
        
                    WICProgressOperationWritePixels,
        
        
                    WICProgressOperationAll            };
        

Le CODEC doit appeler la fonction de rappel à des intervalles réguliers tout au long de l'opération, mais l'appelant peut spécifier certains besoins spécifiques. L'énumération enum WICProgressNotification indique à quel moment de l'opération la fonction de rappel doit être appelée. Si l'appelant spécifie WICProgressNotificationBegin, vous devez l'appeler au début de l'opération (0.0). Si l'appelant ne le spécifie pas, cette opération est facultative. De la même manière, si l'appelant spécifie WICProgressNotificationEnd, vous devez l'appeler lorsque l'opération est terminée (1.0). Si l'appelant spécifie WICProgressNotificationAll, vous devez l'appeler au début et à la fin, mais également à des intervalles réguliers tout au long de l'opération. L'appelant peut également spécifier WICProgressNotificationFrequent, qui indique qu'il souhaite être rappelé à des intervalles fréquents, peut-être après quelques lignes de numérisation. (Un appelant utilisera généralement cet indicateur pour une image de très grande taille.) Dans le cas contraire, il est raisonnable de rappeler à des intervalles d'environ 10 pour cent du nombre total des lignes de numérisation à traiter.

enum WICProgressNotification
{        
  WICProgressNotificationBegin,
  WICProgressNotificationEnd,
  WICProgressNotificationFrequent,
  WICProgressNotificationAll            
};
        

Un seul rappel peut être enregistré à la fois pour un décodeur ou une instance de codage donnée. Si une application appelle plusieurs fois RegisterProgressNotification, remplacez le rappel précédemment enregistré par un nouveau. Pour annuler un enregistrement de rappel, un appelant attribuera la valeur NULL au paramètre pfnProgressNotification.

PFNProgressNotification

La fonction de rappel portera la signature suivante.

typedef HRESULT (*PFNProgressNotification) ( LPVOID pvData, ULONG uFrameNum, 
WICProgressOperation operation, double dblProgress );
        

Lorsque vous appelez la fonction de rappel, utilisez le paramètre pvData pour transmettre le même pvData que l'application a spécifié lorsqu'elle a enregistré la fonction de rappel.

Le paramètre uFrameNum doit indiquer l'index de la trame qui est en cours de traitement.

Réglez le paramètre operation(opération) sur WICProgressOperationCopyPixels pendant le décodage et WICProgressOperationWritePixels pendant le codage.

Le paramètre dblProgress doit être un nombre entre 0.0 (le début de l'opération) et 1.0 (la fin de l'opération). La valeur doit représenter la proportion de lignes de numérisation déjà traitées par rapport au nombre total de lignes de numérisation restant à traiter.

IWICBitmapSource

IWICBitmapSource est une interface très importante pour traiter les images au niveau d'une application. Elle représente le niveau d'abstraction le plus élevé pour une source d'image et toutes les interfaces WIC qui représentent une image, notamment IWICBitmapFrameDecode, IWICBitmap et toutes les interfaces de transformation (IWICBitmapScaler, IWICBitmapClipper, IWICBitmapFlipRotator, et IWICFormatConverter) en sont issues. À un moment précis, un objet IWICBitmapSource peut être sauvegardé dans la mémoire ou pas. Ceci permet un traitement très efficace de la part d'une application, car une image peut être traitée en tant qu'abstraction et les opérations de transformation peuvent être chaînées dans un pipeline de transformation sans consommer des ressources de la mémoire jusqu'à ce que l'application soit prête à afficher ou à imprimer l'image, moment auquel elle appelle la méthode CopyPixels sur la transformation finale pour mettre un bitmap en mémoire de l'image avec les transformations sélectionnées appliquées.

interface IWICBitmapSource : |Inconnu

{
// Méthodes requises
HRESULT GetSize ( UINT *puiWidth,  UINT *puiHeight );
HRESULT GetPixelFormat ( WICPixelFormatGUID *pPixelFormat );
HRESULT GetResolution ( double *pDpiX,  double *pDpiY );
HRESULT CopyPixels ( const WICRect *prc,  UINT cbStride, UINT cbBufferSize,  BYTE *pbBuffer );
// Méthode facultative
HRESULT CopyPalette ( IWICPalette *pIPalette );
}
        

Au niveau du CODEC, les méthodes IWICBitmapSource sont implémentées sur l'objet décodeur de trame. Nous décrirons donc ces méthodes ci-après de même que les autres méthodes sur IWICBitmapFrameDecode, qui est issu deIWICBitmapSource.

IWICBitmapFrameDecode

IWICBitmapFrameDecode est l'interface au niveau de la trame qui permet d'accéder aux bits de l'image réelle. Vous implémenterez cette interface sur votre classe de décodage au niveau de la trame. Elle est issue de IWICBitmapSource, donc l'implémentation de IWICBitmapFrameDecode inclura l'implémentation des méthodes IWICBitmapSource. Les méthodes supplémentaires sur IWICBitmapFrameDecode permettent d'accéder à la miniature au niveau de la trame, aux) contexte(s) couleur pour l'image et au lecteur de requêtes des métadonnées pour la trame.

interface IWICBitmapFrameDecode : IWICBitmapSource

{
// Méthodes requises
HRESULT GetThumbnail ( IWICBitmapSource **ppIThumbnail );
HRESULT GetColorContexts ( UINT cCount, IWICColorContext **ppIColorContexts,  UINT *pcActualCount );
HRESULT GetMetadataQueryReader ( IWICMetadataQueryReader**ppIMetadataQueryReader );
// Methods inherited from IWICBitmapSource (required)
HRESULT GetSize ( UINT *puiWidth, UINT *puiHeight );
HRESULT GetPixelFormat ( WICPixelFormatGUID *pPixelFormat );
HRESULT GetResolution ( double *pDpiX, double *pDpiY );
HRESULT CopyPixels ( const WICRect *prc, UINT cbStride,UINT cbBufferSize, BYTE *pbBuffer );
// Méthode facultative
HRESULT CopyPalette ( IWICPalette **ppIPalette );
 }
        

GetThumbnail renvoie la miniature pour la trame actuelle. Pour des raisons de performance, les miniatures sont généralement codées au format JPEG. Comme avec l'Aperçu sur le décodeur, il n'est pas nécessaire ni conseillé de fournir votre propre décodeur JPEG pour les miniatures. Vous devrez plutôt déléguer au décodeur JPEG fourni avec WIC.

Pour plus d'informations sur les miniatures, veuillez vous référer à la méthode SetThumbnail sur l'interface WICBitmapFrameEncode.

GetColorContexts renvoie le(s) contexte(s) couleur également appelé(s) profil(s) couleur associé(s) à l'image dans cette trame. Dans la plupart des cas, il n'y en aura qu'un seul, mais il pourrait arriver qu'il y en ait deux ou, plus rarement, plusieurs. L'appelant transmettra un ou plusieurs objets IWICColorContext, en réglant le paramètre cCount pour indiquer combien d'entre eux sont transmis. Cette méthode renseigne le(s) objet(s) IWICColorContext avec le(s) profil(s) associé(s) à l'image. Réglez le paramètre pcActualCount sur le nombre réel de contexte couleur associé à l'image, même s'il est supérieur au nombre que vous pouvez retourner. (Dans le cas où il y a plus de contextes couleur disponibles que le nombre d'objets IWICColorContext transmis par l'appelant, ce dernier est informé de ceux qui restent disponibles.)

GetMetadataQueryReader renvoie un IWICMetadataQueryReader qu'une application peut utiliser pour extraire les métadonnées à partir de la trame d'image. Cette interface est implémentée par un gestionnaire de métadonnées et elle permet à une application de demander les propriétés de métadonnées spécifiques qui appartiennent à un format de métadonnées particulier. Nous traiterons des gestionnaires de métadonnées plus en détails dans la section sur IWICMetadataBlockReader.

Pour instancier un MetadataQueryReader, appelez CreateQueryReaderFromBlockReader sur le ComponentFactory.

        IWICMetadataQueryReader* piQueryReader = NULL;
        HRESULT hr;

        hr = m_piComponentFactory->CreateQueryReaderFromBlockReader(
        static_cast<IWICMetadataBlockWriter*>(this),&piQueryReader);

GetSize , GetPixelFormat et GetResolution sont explicites et renvoient simplement les propriétés demandées de l'image.

CopyPixels est la méthode la plus intéressante sur IWICBitmapSource. Il s'agit de la méthode appelée par une application lorsque celle-ci souhaite créer un bitmap en mémoire qui peut être affiché sur l'écran ou l'imprimante. Voici la méthode qui procède au décodage réel des bits de l'image. Les paramètres sont un rectangle, qui représente la zone d'intérêt dans l'image source à copier dans la mémoire, le stride, qui spécifie le nombre d'octets sur une ligne de numérisation, la taille du tampon en mémoire qui a été alloué par l'application et un pointeur vers le tampon dans lequel les bits de l'image demandés doivent être copiés. (Pour empêcher des saturations potentielles du tampon d'introduire des failles de sécurité, assurez-vous de ne copier dans le tampon que la quantité de données d'image spécifiée dans le paramètre cbBufferSize.)

CopyPalette ne doit être implémenté que par des CODEC aux formats pixel indexés. Si une image utilise un format indexé, utilisez cette méthode pour renvoyer la palette de couleurs utilisée dans l'image. Si votre CODEC n'a pas de format indexé, renvoyez WINCODEC_ERR_PALETTEUNAVAILABLE.

IWICMetadataBlockReader

Une image comprend souvent plusieurs blocs de métadonnées, dont chacun présente différents types d'informations dans différents formats. Dans le modèle WIC, les gestionnaires de métadonnées sont des composants distincts qui, comme les décodeurs, peuvent être découverts au moment de l'exécution. Il existe un gestionnaire différent pour chaque format de métadonnées et chacun de ces gestionnaires de métadonnées peut être utilisé avec tout format d'image qui prend en charge le format de métadonnées qu'il gère. Ainsi, si le format de votre image prend en charge EXIF, XMP, IPTC, etc., vous pourrez tirer parti des gestionnaires de métadonnées standards pour ces formats qui sont fournis avec le WIC et vous n'aurez pas besoin d'écrire le vôtre. Bien sûr, si vous créez un nouveau format de métadonnées, vous devrez écrire un gestionnaire de métadonnées pour ce format et ce gestionnaire sera découvert et appelé lors de l'exécution tout comme les gestionnaires standards, mais cela n'entre pas dans le cadre de cet article.

Remarque   Si le format de votre image est basé sur un conteneur TIFF ou JPEG, vous n'aurez pas besoin d'écrire de gestionnaire de métadonnées (à moins de développer un nouveau format de métadonnées ou un format de métadonnées propriétaire). Dans des conteneurs TIFF et JPEG, les blocs de métadonnées sont situés dans des IFD et chaque conteneur possède une structure IFD différente. WIC fournit des gestionnaires IFD pour ces deux formats de conteneur qui parcourent la structure IFD et délèguent aux gestionnaires de métadonnées standards afin d'accéder aux métadonnées qu'ils contiennent. Ainsi, si le format de votre image est basé sur l'un des ces deux conteneurs, vous pouvez automatiquement tirer parti des gestionnaires IFD WIC. Cependant, si l'un de vos formats de conteneur propriétaires possède sa propre structure supérieure unique de métadonnées, vous devrez écrire un gestionnaire qui puisse parcourir cette structure supérieure et déléguer aux gestionnaires de métadonnées appropriés, tout comme le font les gestionnaires IFD.

De la même façon que WIC fournit une couche d'abstraction aux applications qui leur permet de gérer tous les formats d'image de la même manière via un jeu d'interfaces cohérent, WIC fournit aux auteurs de CODEC une couche d'abstraction pour les formats de métadonnées. Comme cela a été dit précédemment, les auteurs de CODEC n'ont généralement pas besoin de gérer directement les divers formats de métadonnées qui peuvent être présents dans une image. Cependant, chaque auteur de CODEC est en charge de fournir un moyen pour énumérer les blocs de métadonnées, de sorte qu'un gestionnaire de métadonnées approprié puisse être découvert et instancié pour chaque bloc. C'est là l'objectif de l'interface IWICMetadataBlockReader.

Vous devez implémenter cette interface sur votre classe de décodage au niveau de la trame. Vous devez également l'implémenter sur votre classe de décodeur au niveau du conteneur si le format de votre image présente des métadonnées globales hors de toute trame d'image individuelle.

interface IWICMetadataBlockReader : |Inconnu

        {
        // All methods required
        HRESULT GetContainerFormat ( GUID *pguidContainerFormat);
        HRESULT GetEnumerator ( IEnumUnknown **ppIEnumMetadata );
        HRESULT GetReaderByIndex ( UINT nIndex, IWICMetadataReader **ppIMetadataReader );
        }
        

GetContainerFormat est identique à la méthode GetContainerFormat sur IWICBitmapDecoder.

GetCount renvoie le nombre de blocs de métadonnées supérieurs associés à la trame.

GetEnumerator renvoie un énumérateur que l'appelant peut utiliser pour énumérer les blocs de métadonnées dans la trame et lire leurs métadonnées. Pour implémenter cette méthode, vous devez créer un lecteur de métadonnées pour chaque bloc de métadonnées et implémenter un objet d'énumération qui énumère la collection de lecteurs de métadonnées. L'objet d'énumération doit implémenter IEnumUnknown afin que vous puissiez le convertir en IEnumUnknown lorsque vous le renvoyez dans le paramètre ppIEnumMetadata.

Lors de l'implémentation de l'objet d'énumération, vous pouvez créer tous les lecteurs de métadonnées en créant d'abord l'objet IWICMetadataBlockReader ou en créant d'abord l'objet d'énumération ou vous pouvez simplement les créer dans l'implémentation de la méthode IEnumUnknown::Next . Il est souvent plus efficace de les créer simplement mais, dans l'exemple suivant (juste pour économiser de l'espace), je vais tous les créer dans le constructeur.

        public class MetadataReaderEnumerator : public IEnumUnknown
        {
        UINT m_current;
        UINT m_blockCount;
        IWICMetadataReader** m_apiMetadataReader;
        IStream* m_piStream;
        MetadataReaderEnumerator()
        {
        // Set m_blockCount to the number of metadata blocks
        //in the frame.
        ...
        m_apiMetadataReader =
        WICMetadataReader*[m_blockCount];
        m_current = 0;
        for (UINT x=0; x < m_blockCount; x++)
        {
        // Find the position in the file where the xth
        // block of metadata lives and seek m_piStream
        // to that position.
        ...
        m_piComponentFactory->
        CreateMetadataReaderFromContainer(
        GUID_ContainerFormatTiff, NULL,
        WICPersistOptions.WICPersistOptionsDefault |
        WICMetadataCreationOptions.WICMetadataCreationDefault   ,
        m_piStream, &m_apiMetadataReader[x]);
        }
        }

        // Implementation of IEnumUnknown and IUnknown interfaces
        ...
        }

Pour créer les lecteurs de métadonnées, vous utilisez la méthode IWICComponentFactory:: CreateMetadataReaderFromContainer . Lors de l'appel de cette méthode, vous transmettrez le GUID du format de conteneur au paramètre guidContainerFormat. Si vous avez une préférence en matière de fournisseur de lecteurs de métadonnées, vous pouvez transmettre le GUID de votre vendeur favori au paramètre pGuidVendor. Par exemple, si votre entreprise écrit des gestionnaires de métadonnées et que vous préfèreriez utiliser vos propres gestionnaires s'ils sont présents, vous pouvez transmettre le GUID de votre fournisseur. Dans la plupart des cas, vous devez juste transmettre NULL et laisser le système sélectionner le lecteur de métadonnées approprié. Si vous demandez un fournisseur spécifique et qu'un lecteur de métadonnées de ce fournisseur est installé sur la machine, WIC renverra le lecteur de ce fournisseur. Cependant, si aucun lecteur de métadonnées du fournisseur requis n'est installé sur la machine et si un lecteur de métadonnées approprié est disponible, ce lecteur sera renvoyé même s'il ne s'agit pas d'un lecteur du fournisseur favori. Si aucun lecteur de métadonnées n'est installé sur la machine pour le type de métadonnées présentes dans le bloc, la fabrique de composant renverra Unknown Metadata Handler, qui considérera le bloc de métadonnées comme un objet BLOB et désérialisera le bloc de métadonnées à partir du fichier sans faire de tentative pour l'analyser.

Pour le paramètre dwOptions, vous lierez les WICPersistOptions appropriés avec les WICMetadataCreationOptions appropriées à l'aide de l'opérateur OR. Les options WICPersistOptions décrivent la façon dont votre conteneur est disposé. LittleEndian est l'élément par défaut.

       enum WICPersistOptions {
          WICPersistOptionDefault,
          WICPersistOptionLittleEndian,
          WICPersistOptionBigEndian,
          WICPersistOptionStrictFormat,
          WICPersistOptionNoCacheStream,
          WICPersistOptionPreferUTF8
          };
        

Les options WICMetadataCreationOptions spécifient si vous souhaitez récupérer le gestionnaire UnknownMetadataHandler dans le cas où aucun lecteur de métadonnées n'est détecté sur la machine pour lire le format de métadonnées d'un bloc particulier. AllowUnknown est la valeur par défaut et vous devez toujours autoriser la création de UnknownMetadataHandler. UnknownMetadataHandler considère les métadonnées non reconnues comme un objet BLOB. Il ne peut pas les analyser, mais il les écrit dans le flux en tant que BLOB et les conserve intactes lors de leur réécriture dans le flux au cours du codage. Cette opération sécurise la création de gestionnaires de métadonnées pour les formats de métadonnées ou de métadonnées propriétaires qui ne sont pas livrés avec le système. Même si aucun gestionnaire n'est présent sur la machine pour reconnaître les métadonnées, celles-ci sont conservées intactes et lorsqu'un gestionnaire de métadonnées approprié sera installé ultérieurement, les métadonnées seront encore présentes et pourront être lues. Si vous n'autorisez pas la création de UnknownMetadataHandler, l'autre possibilité consiste à supprimer ou à écraser les métadonnées non reconnues. Il s'agit d'une forme de perte de données. (Notez que si vous écrivez votre propre gestionnaire de métadonnées pour les métadonnées propriétaires, vous ne devez jamais inclure de références à un élément autre que le bloc de métadonnées lui-même. Même si UnknownMetadataHandler conserve les métadonnées intactes, celles-ci sont déplacées lorsque les fichiers sont modifiés et toute référence à un élément autre que leur propre bloc ne sera plus valide lors de ces modifications.)

        enum WICMetadataCreationOptions
          {       WICMetadataCreationDefault,
        
        
                   WICMetadataCreationAllowUnknown,
        
        
                   WICMetadataCreationFailUnknown            }
        

Le paramètre pIStream est le flux réel que vous décodez. Avant de transmettre le flux, vous devez rechercher le début du bloc de métadonnées pour lequel vous demandez un lecteur. Le lecteur de métadonnées approprié au bloc de métadonnées dans sa position actuelle au sein de IStream sera renvoyé au paramètre ppiReader.

GetReaderByIndex renvoie le lecteur de métadonnées à l'index demandé de la collection.

IWICBitmapSourceTransform

Bien que ce soit facultatif, nous recommandons fortement que tout décodeur implémente cette interface sur votre classe de décodage au niveau de la trame car ceci peut offrir de grands avantages en matière de performances. L'idée derrière cette interface est que lorsqu'une application demande une zone d'intérêt, une taille, une orientation ou un format de pixel spécifique, au lieu de simplement décoder l'image entière en résolution maximale et d'appliquer ensuite les transformations demandées, WIC va appeler QI (QueryInterface) pour cette interface sur l'objet IWICBitmapFrameDecode. Si le décodeur de trame le prend en charge, WIC va appeler la méthode ou les méthodes appropriées pour déterminer si le décodeur de trame peut effectuer la transformation demandée ou rendre compte de la taille ou du format de pixel le plus proche que le décodeur puisse fournir pour la transformation demandée. Si le décodeur peut effectuer la ou les transformations demandées, WIC va appeler IWICBitmapSourceTransform::CopyPixels en utilisant les paramètres appropriés. Si le décodeur peut effectuer certaine des transformations, mais pas toutes, WIC va demander au décodeur de procéder aux transformations possibles et va utiliser les objets de transformation WIC (IWICBitmapScaler, IWICBitmapClipper, IWICBitmapFlipRotator et IWICFormatConverter) pour effectuer les transformations restantes qui n'ont pas pu être effectuées par le décodeur de trame en se basant sur le résultat de l'appel IWICBitmapSourceTransform::CopyPixels. Si le décodeur ne prend pas en charge IWICBitmapSourceTransform, WIC devra alors utiliser les objets de transformation pour effectuer toutes les transformations. Il est en général plus efficace pour le décodeur d'effectuer les transformations au cours du processus de décodage, plutôt que de décoder l'image entière et d'effectuer ensuite les transformations. Cette affirmation est particulièrement vraie pour des opérations telles que les conversions lors du dimensionnement en un format de pixel ou une taille beaucoup plus petite.

interface IWICBitmapSourceTransform : |Inconnu

{
  // Required methods
  HRESULT DoesSupportTransform ( WICTransformOptions dstTransform,BOOL *pfIsSupported);
  HRESULT CopyPixels ( WICRect *prcSrc, UINT uiWidth, UINT uiHeight, 
    WICPixelFormatGUID * pguidDstFormat, WICBitmapTransformOptions dstTransform, UINT nStride, 
    UINT cbBufferSize, BYTE *pbBuffer );
  // Méthodes facultatives
  HRESULT GetClosestSize ( UINT *puiWidth, UINT *puiHeight);
  HRESULT GetClosestPixelFormat ( WICPixelFormatGUID *pguidDstFormat);
}
            

DoesSupportTransform demande si le décodeur prend en charge l'opération de rotation ou de retournement demandée. Les options WICBitmapTransformOptions qui peuvent être demandées sont :

              enum WICBitmapTransformOptions
              {       WICBitmapTransformRotate0,
					  WICBitmapTransformRotate90,
					  WICBitmapTransformRotate180,
					  WICBitmapTransformRotate270,
					  WICBitmapTransformFlipHorizontal,
					  WICBitmapTransformFlipVertical                }
            

CopyPixels est la méthode qui effectue le travail réel de décodage des bits de l'image, tout comme la méthode CopyPixels sur l'interface IWICBitmapSource, à la différence que la méthode CopyPixels sur IWICBitmapSourceTransform est bien plus intéressante et puissante et peut améliorer les performances de traitement de l'image de façon significative.

Lorsque plusieurs opérations de transformation sont demandées, le résultat dépend de l'ordre dans lequel les opérations sont effectuées. Afin d'assurer la prévisibilité et la cohérence des CODEC, il est important que tous les CODEC effectuent ces opérations dans le même ordre. Ces opérations sont effectuées selon l'ordre canonique.

  1. Dimensionner

  2. Recadrer

  3. Faire pivoter

La conversion du format de pixel peut être effectuée à tout moment, car elle n'a pas d'effet sur les autres transformations.

Le premier paramètre, prcSrc,est utilisé pour spécifier la zone d'intérêt pour le découpage de l'image. Par convention, le dimensionnement est effectué avant le découpage ; ainsi, si l'image doit être redimensionnée et découpée, la zone d'intérêt doit être déterminée après que l'image a été dimensionnée.

Les deuxième et troisième paramètres indiquent la taille à laquelle dimensionner l'image.

Le paramètre pguidDstFormat indique le format de pixel demandé pour l'image décodée. WIC ayant déjà appelé GetClosestPixelFormat, il doit s'agir d'un format de pixel que le décodeur a déclaré prendre en charge.

Le paramètre dstTransform indique l'angle de rotation demandé et/ou s'il faut faire pivoter l'image verticalement et/ou horizontalement. Une fois encore, WIC a déjà appelé

DoesSupportTransform ; la transformation demandée doit donc être une transformation que le décodeur a déjà déclarée prendre en charge. Rappelez-vous que l'opération de rotation doit toujours être effectuée après les opérations de dimensionnement et de découpage.

GetClosestSize accepte deux paramètres d'entrée/de sortie. L'appelant utilisera les paramètres puiWidth et puiHeight pour spécifier la taille idéale à laquelle l'appelant souhaiterait que l'image soit décodée. Cependant, un décodeur ne peut décoder une image que vers une taille qui est un multiple de sa taille DCT et des formats d'image différents peuvent avoir différentes tailles DCT. Le décodeur doit donc déterminer, en fonction de sa propre taille DCT, la taille qui peut le plus se rapprocher de la taille demandée et définir la valeur de puiWidth et de puiHeight sur ces dimensions en retour. Si une taille plus grande est demandée mais que le CODEC ne prend pas en charge le dimensionnement vers la taille supérieure, la taille d'origine doit être renvoyée.

GetClosestPixelFormat est utilisé pour déterminer le format de pixel le plus proche du format de pixel demandé que le décodeur peut fournir sans que cela n'entraîne de perte de données. Le point clé à connaître est qu'il vaut toujours mieux convertir à un format de pixel plus large que plus étroit, même si cela va augmenter la taille de l'image, car il est toujours possible de la reconvertir à un format plus petit si nécessaire ; dans le cas contraire, une fois que les données sont perdues, elles ne sont pas récupérables.

IWICDevelopRaw

Cette interface présente des options de traitement spécifiques au traitement d'images RAW. Tous les CODEC Raw doivent prendre en charge l'interface IWICDevelopRaw. Certains CODEC Raw n'ont parfois pas la capacité de prendre en charge tous les paramètres présentés par l'interface, mais vous devez prendre en charge l'ensemble des paramètres que votre CODEC peut effectuer. Chaque CODEC Raw doit au minimum implémenter les méthodes SetRotation et SetRenderQuality.

En outre, certaines méthodes et interfaces qui sont optionnelles pour d'autres CODEC sont fortement recommandées avec les CODEC Raw. Cela comprend les méthodes GetPreview et GetThumbnail de la classe de décodeur au niveau du conteneur et l'interface IWICBitmapSourceTransform de la classe de décodage au niveau de la trame.

Les paramètres définis à l'aide des méthodes IWICDevelopRaw doivent être conservés par le CODEC de façon à ce qu'ils soient cohérents par rapport à la façon dont les autres métadonnées sont conservées, mais vous ne devez jamais écraser les paramètres originaux « As Shot » (identique à l'image). En conservant les métadonnées et en implémentant LoadParameterSet et GetCurrentParameterSet, vous permettez aux applications de traitement Raw de récupérer et d'appliquer les paramètres de traitement sur les sessions.

L'un des objectifs clé de l'interface IWICDevelopRaw est de permettre aux développeurs d'applications de construire une interface utilisateur afin de régler les paramètres Raw qui fonctionneront de façon aussi cohérente que possible sur différents CODEC. Supposons qu'un utilisateur final règle les paramètres à l'aide d'un curseur, en mappant les valeurs minimale et maximale sur les plages minimale et maximale du paramètre. Pour prendre en charge ces valeurs, vous devez faire tout votre possible pour traiter toutes les plages de paramètre de façon linéaire. Pour être sûr que les curseurs ne sont pas trop sensibles, vous devez également prendre en charge une plage aussi large que possible pour chaque paramètre, couvrant au moins 50% de la plage maximale possible. Par exemple, si la plage maximale possible de contraste va de gris pur à noir/blanc pur, avec une valeur par défaut mappée sur 0.0, la plage minimale prise en charge par un CODEC doit au minimum aller de la moitié de la plage inférieure (-1.0) entre gris pur et la valeur par défaut à la moitié de la plage supérieure (+1.0) entre la valeur par défaut et noir/blanc pur.

            interface IWICDevelopRaw : IWICBitmapFrameDecode
            {
            
              HRESULT QueryRawCapabilitiesInfo ( WICRawCapabilitiesInfo *pInfo );
            
            
              HRESULT LoadParameterSet ( WICRawParameterSet parameterSet );
            
            
              HRESULT GetCurrentParameterSet ( IPropertyBag2 **ppCurrentParameterSet );
            
            
              HRESULT SetExposureCompensation ( UINT *pcCount );
            
            
              HRESULT GetExposureCompensation ( double *pEV );
            
            
              HRESULT SetWhitePointRGB ( UINT Red, UINT Green, UINT Blue );
            
            
              HRESULT GetWhitePointRGB ( UINT *pRed, UINT *pGreen, UINT *pBlue );
            
            
              HRESULT SetNamedWhitePoint ( WICNamedWhitePoint whitePoint );
            
            
              HRESULT GetNamedWhitePoint ( WICNamedWhitePoint *pWhitePoint );
            
            
              HRESULT SetWhitePointKelvin ( UINT whitePointKelvin );
            
            
              HRESULT GetWhitePointKelvin ( UINT *pWhitePointKelvin );
            
            
              HRESULT GetKelvinRangeInfo ( UINT *pMinKelvinTemp, UINT *pMaxKelvinTemp, 
              UINT *pKelvinTempStepValue );
                        
              HRESULT SetContrast ( double contrast );
            
            
              HRESULT GetContrast (double *pContrast );
            
            
              HRESULT SetGamma ( double gamma );
            
            
              HRESULT GetGamma (double *pGamma );
            
            
              HRESULT SetSharpness ( double sharpness );
            
            
              HRESULT GetSharpness ( double *pSharpness );
            
            
              HRESULT SetSaturation ( double saturation );
            
            
              HRESULT GetSaturation ( double *pSaturation );
            
            
              HRESULT SetTint ( double tint );
            
            
              HRESULT GetTint ( double *pTint );
            
            
              HRESULT SetNoiseReduction ( double noiseReduction );
            
            
              HRESULT GetNoiseReduction ( double *pNoiseReduction );
            
            
              HRESULT SetDestinationColorContext (const IWICColorContext  *pColorContext );
            
            
              HRESULT SetToneCurve ( UINT cbToneCurveSize, const WICRawToneCurve *pToneCurve );
            
            
              HRESULT GetToneCurve ( UINT cbToneCurveBufferSize, 
              WICRawToneCurve *pToneCurve, UINT *pcbActualToneCurveBufferSize );
            
            
              HRESULT SetRotation ( double rotation );
            
            
              HRESULT GetRotation ( double *pRotation );
            
            
              HRESULT SetRenderQuality ( WICRawRenderQuality renderQuality );
            
            
              HRESULT GetRenderQuality ( WICRawRenderQuality *pRenderQuality );
            
            
              HRESULT SetNotificationCallback ( IWICDevelopRawNotificationCallback  *pCallback );
            
            }
            

QueryRawCapabilitiesInfo renvoie l'ensemble des capacités prises en charges pour ce fichier brut. La structure IWICRawCapabilitiesInfo est définie comme suit.

              struct WICRawCapabilitiesInfo
                          
            
              {
            
            
                       UINT cbSize;
            
            
                       UINT CodecMajorVersion;
            
            
                       UINT CodecMinorVersion;
            
            
                       WICRawCapabilities ExposureCompensationSupport;
            
            
                       WICRawCapabilities ContrastSupport;
            
            
                       WICRawCapabilities RGBWhitePointSupport;
            
            
                       WICRawCapabilities NamedWhitePointSupport;
            
            
                       UINT NamedWhitePointSupportMask;
            
            
                       WICRawCapabilities KelvinWhitePointSupport;
            
            
                       WICRawCapabilities GammaSupport;
            
            
                       WICRawCapabilities TintSupport;
            
            
                       WICRawCapabilities SaturationSupport;
            
            
                       WICRawCapabilities SharpnessSupport;
            
            
                       WICRawCapabilities NoiseReductionSupport;
            
            
                       WICRawCapabilities DestinationColorProfileSupport;
            
            
                       WICRawCapabilities ToneCurveSupport;
            
            
                       WICRawRotationCapabilities RotationSupport;
            
            
              }
            

L'énumération WICRawCapabilities utilisée dans cette structure est définie comme suit :

                       enum WICRawCapabilities
                        {       WICRawCapabilityNotSupported,
                       		    WICRawCapabilityGetSupported,
                       		    WICRawCapabilityFullySupported        }
            

Le champ final est une énumération WICRawRotationCapabilities, définie comme suit :

                       enum WICRawRotationCapabilities
                       {       WICRawRotationCapabilityNotSupported,
                       		   WICRawRotationCapabilityGetSupported,
                       		   WICRawRotationCapabilityNinetyDegreesSupported
                       		   WICRawRotationCapabilityFullySupported            }
            

LoadParameterSet permet à l'utilisateur de spécifier s'il faut utiliser les paramètres As Shot (identique à l'image), les paramètres ajustés par l'utilisateur ou demander au décodeur de corriger automatiquement l'image.

                       enum WICRawParameterSet
                        {       WICAsShotParameterSet,
                       			WICUserAdjustedParameterSet,
                       			WICAutoAdjustedParameterSet        }
            

GetCurrentParameterSet renvoie un IPropertyBag2 avec l'ensemble de paramètres actuel. L'appelant peut alors transmettre cet ensemble de paramètres au codeur pour l'utiliser en tant qu'options du codeur.

Set/GetExposureCompensation indique la compensation de l'exposition à appliquer à la sortie finale. La plage valide pour EV s'étend des points -5.0 à +5.0.

Set/GetWhitePointRGB , Set/GetNamedWhitePoint, Set/GetWhitePointKelvin et GetKelvinRangeInfo offrent tous les moyens d'obtenir et de définir le point blanc comme valeur RVB, valeur nommée prédéfinie ou valeur Kelvin. La plage acceptable pour la valeur Kelvin s'étend de 1,500 à 30,000.

SetContrast/GetContrast indique le niveau de contraste à appliquer à la sortie. La plage valide pour spécifier le contraste s'étend de -1.0 à +1.0, le contraste par défaut étant fixé à 0.0.

Set/GetGamma indique le gamma à appliquer. La plage valide pour le Gamma s'étend de 0.2 à 5.0, 1.0 étant la valeur par défaut. Le Gamma est généralement implémenté à l'aide de la fonction de puissance traditionnelle Gamma (fonction de puissance linéaire avec gain d'unité). La luminosité augmente lorsque le Gamma augmente et diminue lorsque le Gamma s'approche de zéro. (Notez que la valeur minimale est non-nulle, car une valeur égale à zéro engendrerait une erreur de division par zéro des calculs traditionnels de Gamma. La limite minimale logique est de 1/max ; c'est la raison pour laquelle le minimum est de 0.2.)

Set/GetSharpness indique le niveau de netteté à appliquer. La plage valide s'étend de -1.0 à +1.0, 0.0 étant la valeur par défaut du niveau de netteté et -1.0 indiquant une netteté nulle.

Set/GetSaturation indique le niveau de saturation à appliquer. La plage valide spécifiant la saturation s'étend de -1.0 à +1.0, 0.0 correspondant à la saturation normale, -1.0 représentant la désaturation complète et +1.0 représentant une saturation totale.

Set/GetTint indique la teinte à appliquer sur une palette vert/magenta. La plage valide s'étend de -1.0 à +1.0, vert étant du côté négatif de l'échelle et magenta du côté positif. L'échelle de teinte est définie comme étant orthogonale à la température de couleur.

Set/GetNoiseReduction indique le niveau de réduction de bruit à appliquer. La plage valide s'étend de -1.0 à +1.0, 0.0 indiquant le niveau de réduction de bruit par défaut, -1.0 n'indiquant aucune réduction du bruit et +1.0 indiquant la réduction de bruit maximale.

SetDestinationColorContext spécifie le profil couleur à appliquer à l'image. Vous pouvez appeler

IWICBitmapFrameDecode::GetColorContext

pour récupérer le profil couleur actuel.

=Set/GetToneCurve spécifie la courbe de tonalité à appliquer. Tenez compte de l'interpolation linéaire entre les points. pToneCurve est une structure WICRawToneCurve qui contient un tableau de structures WICRawToneCurvePoint et un décompte du nombre de points du tableau.

              struct WICRawToneCurve                        
              {
            
            
                        UINT cPoints;
            
            
                        WICRawToneCurvePoint aPoints[];
            
            
              }
            

Une structure WICRawToneCurvePoint contient une valeur d'entrée et une valeur de sortie.

              struct WICRawToneCurvePoint
            
            
              {
            
            
                        double Input;
            
            
                        double Output;
            
            
              }
            

Lorsque l'appelant transmet NULL au paramètre pToneCurve, vous devez transmettre en retour la taille requise pour le WICRawToneCurve au paramètre pcbActualToneCurveBufferSize.

Set/GetRotation indique le degré de rotation à appliquer. Une rotation de 90.0 indiquera une rotation de 90 degrés dans le sens des aiguilles d'une montre. (La différence entre utiliser IWICDevelopRaw::SetRotation et définir une rotation via la méthode IWICBitmapSourceTransform::CopyPixels est que l'angle de rotation défini à l'aide de IWICDevelopRaw::SetRotation sera conservé par le CODEC, alors que lorsque la rotation est définie via la méthode IWICBitmapSourceTransform::CopyPixels, seule l'image en mémoire pivote.

Set/GetRenderQuality indique le niveau de qualité de sortie requis par l'appelant. Lorsqu'un utilisateur met des paramètres au point, l'application souhaite pouvoir afficher une approximation rapide de ce à quoi l'image réelle va ressembler en cas d'application des modifications. À cet effet, l'image est habituellement affichée à la résolution de l'écran ou en plus petit plutôt qu'à la résolution de l'image réelle et le point essentiel réside dans le fait d'apporter une réponse immédiate à l'utilisateur. La réponse doit être particulièrement rapide lorsqu'une application demande la qualité Mode brouillon. Lorsque l'utilisateur a procédé à toutes les modifications des paramètres, a obtenu un aperçu de ces modifications en mode brouillon et a décidé qu'il souhaitait décoder l'image complète en fonction des paramètres actuels, l'application envoie une demande de décodage en Qualité optimale. En général, cette opération est également requise pour l'impression. Lorsqu'il est nécessaire d'établir un compromis raisonnable entre la vitesse et la qualité demandée, l'application demandera une Qualité Normale.

              enum WICRawRenderQuality
              {       WICRawRenderQualityDraftMode,
					  WICRawRenderQualityNormalQuality,
					  WICRawRenderQualityBestQuality        }
            

SetNotificationCallback enregistre une fonction de rappel que le décodeur doit appeler pour toute modification des paramètres de traitement Raw. La signature pour IWICDevelopRawNotificationCallback ne possède qu'une seule méthode, appelée Notify. Notify possède un seul paramètre, un masque qui indique les paramètres de traitement Raw qui ont changé.

HRESULT Notify ( UINT NotificationMask );

Les valeurs suivantes peuvent être liées par un opérateur OR pour le NotificationMask.

              WICRawChangeNotification_ExposureCompensation
            
            
              WICRawChangeNotification_NamedWhitePoint
            
            
              WICRawChangeNotification_KelvinWhitePoint
            
            
              WICRawChangeNotification_RGBWhitePoint
            
            
              WICRawChangeNotification_Contrast
            
            
              WICRawChangeNotification_Gamma
            
            
              WICRawChangeNotification_Sharpness
            
            
              WICRawChangeNotification_Saturation
            
            
              WICRawChangeNotification_Tint
            
            
              WICRawChangeNotification_NoiseReduction
            
            
              WICRawChangeNotification_DestinationColorContext
            
            
              WICRawChangeNotification_ToneCurve
            
            
              WICRawChangeNotification_Rotation
            
            
              WICRawChangeNotification_RenderMode
            

Implémentation d'un codeur compatible avec le WIC

Tout comme l'implémentation d'un décodeur WIC, l'implémentation d'un codeur WIC nécessite l'écriture de deux classes. Les interfaces sur ces classes correspondent directement aux responsabilités du codeur définies dans la section Encodage du Fonctionnement du WIC (Windows Imaging Component).

L'une des classes fournit des services au niveau du conteneur et gère la sérialisation des trames d'images individuelles au sein du conteneur. Cette classe implémente l'interface IWICBitmapEncoder. Si votre format d'image prend en charge les métadonnées au niveau du conteneur, vous aurez également besoin d'implémenter l'interface IWICMetadataBlockWriter sur cette classe.

L'autre classe fournit des services au niveau de la trame et effectue le codage réel des bits d'images pour chaque trame dans le conteneur. Elle effectue également une itération par les blocs de métadonnées pour chaque trame et demande aux enregistreurs de métadonnées appropriés de sérialiser les blocs. Cette classe implémente l'interface IWICBitmapFrameEncode et l'interface IWICMetadataBlockWriter. Cette classe devrait posséder un membre IStream que la classe au niveau du conteneur initialise en instanciation, dans laquelle la méthode Commit sérialisera les données de trame.

Dans certains cas, tels que les formats Raw, l'auteur ne désire pas forcément que les applications puissent coder ou recoder le format Raw car le but d'un fichier Raw est de contenir les données de capteur identiques à ce qu'elles étaient lors de la réception depuis l'appareil photo. Dans les cas où l'auteur du CODEC ne désire pas permettre le codage, il est encore nécessaire d'implémenter un codeur rudimentaire simplement pour permettre l'ajout de métadonnées. Dans ce cas, le codeur a seulement besoin de prendre en charge les méthodes nécessaires et peut copier les bits d'images inexploités par le décodeur.

Interfaces de codeur

Le tableau suivant affiche les interfaces implémentées par les codeurs WIC et le diagramme pour la classe, la hiérarchie d'héritage.

Interfaces de codeur au niveau du conteneur

Interface

Responsabilités

Implémentation

IWICBitmapEncoder

Services du niveau du conteneur

Requis

IWICBitmapCodecProgressNotification

Notifications de progression et support d'annulation

Recommandé

IWICMetadataBlockWriter

Services de sérialisation des métadonnées

Facultatif (Requis seulement si le format prend en charge des métadonnées au niveau du conteneur)

Interfaces de codeur au niveau de la trame

Interface

Responsabilités

Implémentation

IWICBitmapFrameEncode

Services du niveau de trame

Requis

IWICMetadataBlockWriter

Services de sérialisation des métadonnées

Requis

Aa905327.wiccodec02(fr-fr,MSDN.10).jpg

Figure 2. Interfaces du codeur WIC

Vous remarquerez que les interfaces de codeur sont des copies quasi conformes des interfaces de décodeur et que la plupart des méthodes de ces interfaces correspondent à des méthodes des interfaces de décodeur associées. Maintenant que vous vous êtes familiarisé avec l'implémentation d'un décodeur avec WIC activé, l'implémentation d'un codeur avec WIC activé vous sera également familière.

IWICBitmapEncoder

Cette interface est l'équivalent de l'interface IWICBitmapDecoder et le point de départ pour le codage d'un fichier image. Tout comme IWICBitmapDecoder est utilisée pour récupérer les propriétés au niveau du conteneur et les trames individuelles pour le conteneur d'image, IWICBitmapEncoder est utilisée pour définir les propriétés au niveau du conteneur et pour sérialiser les trames d'images individuelles dans le conteneur. Vous implémenterez cette interface sur votre classe de codeur au niveau du conteneur.

        interface IWICBitmapEncoder : public |Inconnu
			{
			// Méthodes requises
			
          HRESULT Initialize ( IStream *pIStream, WICBitmapEncoderCacheOption cacheOption );
        
			
          HRESULT GetContainerFormat ( GUID *pguidContainerFormat );
        
			
          HRESULT GetEncoderInfo ( IWICBitmapEncoderInfo **pIEncoderInfo );
        
			
          HRESULT CreateNewFrame ( IWICBitmapFrameEncode **ppIFrameEncode, 
          IPropertyBag2 **ppIEncoderOptions );
        
			
          HRESULT Commit ( void );
        
			// Méthodes facultatives
			
          HRESULT SetPreview ( IWICBitmapSource *pIPreview );
        
			
          HRESULT SetThumbnail ( IWICBitmapSource *pIThumbnail );
        
			
          HRESULT SetColorContexts ( UINT cCount, IWICColorContext **ppIColorContext );
        
			
          HRESULT GetMetadataQueryWriter ( IWICMetadataQueryWriter  **ppIMetadataQueryWriter );
        
			
          HRESULT SetPalette ( IWICPalette *pIPalette);
        
			};
			

De notre discussion sur les décodeurs, vous vous rappellerez que certains formats d'image ont des miniatures, des contextes couleur et/ou des métadonnées d'ensemble, tandis que de nombreux formats d'images ne proposent ces éléments qu'en fonction de la trame. Par conséquent, les méthodes pour les définir sont facultatives sur IWICBitmapEncoder, mais nécessaires sur IWICBitmapFrameEncode. Nous évoquerons les méthodes facultatives sur IWICBitmapEncoder dans la section IWICBitmapFrameEncode, où elles sont généralement implémentées.

Si vous ne prenez pas en charge les miniatures, renvoyez WINCODEC_ERR_CODECNOTHUMBNAIL depuis la méthode SetThumbnail sur IWICBitmapEncoder. Si vous ne prenez pas en charge la palette au niveau du conteneur ou si l'image que vous encodez ne possède pas de format indexé, renvoyez WINCODEC_ERR_PALETTEUNAVAILABLE depuis la méthode SetPalette. Pour toute autre méthode non prise en charge, renvoyez WINCODEC_ERR_UNSUPPORTEDOPERATION.

Initialize est la première méthode appelée sur un IWICBitmapEncoder après avoir été instanciée. Un flux d'image est transmis au décodeur et un appelant peut spécifier une option de cache de manière facultative. Dans le cas du décodeur, le flux est en lecture seule mais le flux transmis à un codeur est un flux inscriptible, dans lequel le codeur sérialisera toutes les données et métadonnées d'image. Les options de cache sur le codeur sont également différentes.

          enum WICBitmapEncoderCacheOption
          {       WICBitmapEncoderCacheInMemory,
				  WICBitmapEncoderCacheTempFile,
				  WICBitmapEncoderNoCache        }
        

L'application a le choix de demander au codeur de mettre en cache les données d'image en mémoire, de les mettre en cache dans un dossier temporaire ou de les inscrire directement sans cache dans le fichier disque. Une fois effectuée la demande de cache des données dans un fichier temporaire, le codeur doit créer un fichier temporaire sur le disque et écrire directement sur ce fichier sans mettre en cache en mémoire. Lorsque l'appelant sélectionne l'option sans mise en cache, chaque trame doit être stockée dans l'ordre pour que la suivante puisse ensuite être créée.

GetContainerFormat est implémenté de la même façon que la méthode GetContainerFormat sur IWICBitmapDecoder.

GetEncoderInfo retourne un objet IWICBitmapEncoderInfo. Pour extraire l'objet IWICBitmapEncoderInfo, il vous suffit de transmettre le GUID de votre codeur à la méthode CreateComponentInfo sur IWICComponentFactory, puis de demander l'interface IWICEncoderInfo sur celui-ci.

Reportez-vous à l'exemple proposé sous IWICBitmapDecoder::GetDecoderInfo.

CreateNewFrame constitue pour le codeur l'homologue de GetFrame sur IWICBitmapDecoder. Cette méthode retourne un objet IWICBitmapFrameEncode, qui est celui qui sérialise effectivement les données d'image pour une trame donnée au sein du conteneur.

L'un des avantages de WIC est qu'il fournit aux applications une couche d'abstraction leur permettant de traiter tous les formats d'image de la même façon, alors qu'ils ne sont naturellement pas tous exactement identiques. Du fait que certains formats d'image possèdent des fonctionnalités absentes sur d'autres, il est nécessaire d'offrir au CODEC un moyen de les exposer, afin que des applications puissent tirer parti de ces fonctionnalités uniques. C'est précisément l'objectif des options de codeur. Si votre CODEC prend en charge certaines options de codeur, vous devez créer un objet IPropertyBag2 qui expose ces options de codeur, et le retourner dans le paramètre ppIEncoderOptions de cette méthode. L'appelant peut alors utiliser cet objet IPropertyBag2 pour déterminer les options de codeur prises en charge par votre CODEC. Si l'appelant souhaite spécifier les valeurs de certaines des options de codeur prises en charge, il affectera la valeur à la propriété pertinente dans l'objet IPropertyBag2 et la transmettra à l'objet IWICBitmapFrameEncode nouvellement créé dans sa méthode Initialize.

Pour instancier un objet IPropertyBag2, vous devez d'abord créer une structure PROPBAG2 pour spécifier chaque option de codeur prise en charge par votre codeur et son type de données pour chaque propriété. Vous devez ensuite implémenter un objet IPopertyBag2 qui applique les intervalles de valeurs de chaque propriété sur écriture, et harmonise les valeurs qui entrent en conflit et se chevauchent. Pour les ensembles simples d'options de codeur n'entrant pas en conflit, vous pouvez appeler la méthode IWICComponentFactory::CreateEncoderPropertyBag, qui créera pour vous un objet IPropertyBag2 simple en utilisant les propriétés que vous spécifiez dans votre structure PROPBAG2. Vous devrez tout de même appliquer les intervalles de valeurs. Pour des options de codeur plus avancées, ou si vous devez harmoniser des valeurs entrant en conflit, vous pourrez si vous le souhaitez écrire votre propre implémentation IPropertyBag2.

          UINT cuiPropertyCount = 0;
          IPropertyBag2* piPropertyBag = NULL;
          PROPBAG2* pPropBagOptions;
          HRESULT hr;

          // Insert code here to initialize piPoropertyBag with the
          // supported options for your encoder, and to initialize
          // cuiPropertyCount to the number of encoder option properties
          // you're exposing.
          ...

          hr = piComponentFactory->CreateEncoderPropertyBag(
                             pPropBagOptions, cuiPropertyCount, &piPropertyBag );
        

WIC propose un petit ensemble d'options de codeur canoniques utilisées par certains des formats d'image courants. Les options de codeur canoniques sont toutes facultatives et leur prise en charge ne nécessite pas de CODEC. Elles sont proposées sous forme d'options canoniques parce que de nombreuses applications exposent une UI permettant aux utilisateurs de spécifier ces options lorsqu'ils enregistrent un fichier d'image sous un format qui les prend en charge. L'apport d'une méthode canonique de spécification de ces options permet aux applications de les communiquer à des codeurs de manière aisée et cohérente. Les options de codeur canoniques sont répertoriées dans le tableau ci-dessous.

Option de codeur

VARTYPE

Intervalle de valeurs

Lossless

VT_BOOL

True/False

ImageQuality

VT_R4

0-1.0

CompressionQuality

VT_R4

0-1.0

BitmapTransform

VT_UI1

WICBitmapTransformOptions

Si votre CODEC prend en charge le codage sans perte, vous devez exposer l'option de codeur Lossless pour permettre aux applications de demander le codage sans perte d'une image. Si un appelant règle cette propriété sur True, vous devez ignorer l'option ImageQuality et coder l'image sans perte.

L'option ImageQuality permet à une application de spécifier le degré de fidélité du codage à effectuer sur l'image. Cette option permet à un utilisateur d'établir un compromis entre d'une part la qualité d'image et d'autre part la vitesse et/ou la taille du fichier. JPEG compte parmi les formats d'image capables de réaliser ce compromis. La valeur 0.0 indique que la fidélité est de faible importance et que le codeur doit utiliser son algorithme entraînant le plus de pertes. La valeur 1.0 indique que la fidélité est essentielle et que le codeur doit conserver la plus haute fidélité possible (selon votre CODEC, cela peut correspondre à l'option Lossless. Toutefois, si votre CODEC prend en charge le codage sans perte et que l'option Lossless est réglée sur True, l'option ImageQuality doit être ignorée).

L'option CompressionQuality permet à une application de spécifier l'efficacité de la compression à utiliser lors du codage de l'image. Un algorithme très efficace peut produire un fichier d'image plus petit avec la même qualité qu'un algorithme de compression moins efficace, mais le codage peut alors être plus long. Cette option permet à un utilisateur de spécifier un compromis entre la taille de fichier et la vitesse de codage, tout en conservant le même niveau de qualité. TIFF fait partie des formats d'image gérant ce compromis (notez qu'un format tel que JPEG prend en charge différents niveaux de compression, mais qu'un taux de compression plus élevé entraîne une qualité d'image moindre. En conséquence, un CODEC JPEG exposerait l'option ImageQuality et non l'option CompressionQuality). Pour cette option, la valeur 0.0 indique que vous devez compresser l'image aussi rapidement que possible et sans réduire la fidélité, en obtenant en contrepartie une taille de fichier plus élevée. La valeur 1.0 indique que vous devez obtenir une taille de fichier aussi réduite que possible (avec le même niveau de qualité), la longueur du codage étant indifférente. Un CODEC peut prendre en charge l'option ImageQuality et l'option CompressionQuality, l'option ImageQuality spécifiant le degré acceptable de tendance à la perte et l'option CompressionQuality proposant un compromis taille/vitesse pour le niveau de qualité spécifié.

L'option BitmapTransform permet à l'appelant de spécifier un angle de rotation, ou une orientation du retournement vertical ou horizontal pendant le codage. L'énumération WICBitmapTransformOptions permettant de spécifier la transformation demandée est la même que celle utilisée lors de la demande d'une transformation pendant le décodage via l'interface IWICBitmapSourceTransform.

Notez que les codeurs ne se limitent pas aux options de codeur canoniques. Les options de codeur ont pour objet de permettre aux codeurs d'exposer leurs fonctionnalités, et les types de fonctionnalités que vous pouvez exposer ne sont soumis à aucune limite. Vous devez être certain que vos options de codeur sont bien documentées car, même si une application peut utiliser le jeu de propriétés que vous retournez à partir de cette méthode pour découvrir les noms, types et intervalles de valeurs des options que vous prenez en charge, ce n'est qu'à partir de votre documentation qu'elle pourra déterminer la signification de ces éléments, ou la façon de les exposer dans l'UI.

Commit est la méthode que vous appelez une fois les données et les métadonnées d'image sérialisées dans le flux. Vous devez utiliser cette méthode pour sérialiser les données d'image d'aperçu (Preview) dans le flux et, s'il y a lieu, les miniatures globales, les métadonnées, la palette, etc.. Cette méthode ne doit pas fermer le fichier d'image, car c'est l'application qui l'a ouvert qui est censée le fermer.

La section présente sur la méthode IWICBitmapFrameEncode:Commit comporte des détails précisant en quoi IWICBitmapEncoderCacheOptions influe sur le comportement de cette méthode.

SetPreview permet de créer un aperçu de l'image. Il n'est pas strictement obligatoire d'associer un aperçu à chaque image, mais c'est fortement recommandé. Les caméras numériques et les scanners modernes créent des images à très haute résolution, qui tendent à être très volumineuses et dont le décodage s'avère donc très long. Les images issues de la nouvelle génération de caméras seront encore plus volumineuses. Pour l'agrément de l'utilisateur, il est fortement conseillé de fournir une version de l'image plus petite et de plus faible résolution, en général au format JPEG, qui puisse être rapidement décodée et affichée « instantanément » lorsqu'un utilisateur la demande. Une application peut demander un aperçu avant de demander le décodage de l'image réelle, afin d'améliorer l'agrément de l'utilisateur et de lui proposer au moins une représentation plein écran de l'image pendant qu'il attend la fin de l'opération. L'apport d'aperçus est souhaitable pour tous les CODEC, mais particulièrement pour ceux qui ne prennent pas en charge IWICBitmapSourceTransform.

Si vous fournissez un aperçu JPEG, vous n'êtes pas tenu d'écrire un codeur JPEG pour le coder. Vous devez confier le codage des aperçus et des miniatures au codeur JPEG qui accompagne la plate-forme WIC.

IWICBitmapCodecProgressNotification

L'interface IWICBitmapCodecProgressNotification est facultative, mais son implémentation est préconisée sur la classe de codeur de niveau conteneur. Cette interface est traitée en détail dans la section Décodeur du présent article. L'implémentation est identique pour le décodeur et le codeur.

IWICBitmapFrameEncode

Cette interface constitue pour le codeur l'homologue de l'interface IWICBitmapFrameDecode. Vous implémenterez cette interface sur votre classe de codage de niveau trame, qui constitue la classe réalisant le codage effectif des bits d'image de chaque trame.

interface IWICBitmapFrameEncode : public |Inconnu

			{
			// Méthodes requises
			          HRESULT Initialize ( IPropertyBag2 *pIEncoderOptions );
			
          HRESULT SetSize ( UINT width,
			    UINT height );
        
			
          HRESULT SetResolution ( double dpiX,
				  double dpiY );
        
			
          HRESULT SetPixelFormat (WICPixelFormatGUID *pPixelFormat);
        
			
          HRESULT SetColorContexts ( UINT cCount,
				     IWICColorContext **ppIColorContext );
        
			
          HRESULT GetMetadataQueryWriter ( IWICMetadataQueryWriter
					 **ppIMetadataQueryWriter );
        
			
          HRESULT SetThumbnail ( IWICBitmapSource *pIThumbnail );
        
			
          HRESULT WritePixels ( UINT lineCount,
				UINT cbStride,
				UINT cbBufferSize,
				BYTE *pbPixels );
        
			
          HRESULT WriteSource ( IWICBitmapSource *pIWICBitmapSource,
				WICRect *prc );
        
			
          HRESULT Commit ( void );
        
			// Méthode facultative
			
          HRESULT SetPalette ( IWICPalette *pIPalette );
        
			};
			

Initialize est la première méthode appelée sur un objet IWICBitmapFrameEncode après son instanciation. Cette méthode comporte un seul paramètre, qui est facultatif. Ce paramètre représente les options de codeur, et correspond à l'instance IPropertyBag2 que vous avez créée dans la méthode CreateNewFrame sur le décodeur de niveau conteneur, et renvoyée à l'appelant dans le paramètre pIEncoderOptions de cette méthode. A ce moment-là, vous avez renseigné la structure IPropertyBag2 avec les propriétés représentant les options de codage prises en charge par votre codeur de niveau trame. L'appelant a maintenant fourni des valeurs permettant à ces propriétés d'indiquer les paramètres d'option de codage souhaités, et vous renvoie le même objet pour initialiser l'objet IWICBitmapFrameEncode. Vous devez appliquer les options spécifiées en codant les bits d'image.

SetSize et SetResolution portent des noms évocateurs. L'appelant utilisera ces méthodes pour spécifier la taille et la résolution de l'image codée.

SetPixelFormat permet de demander un format de pixels sous lequel coder l'image. Si ce format de pixels n'est pas pris en charge, vous devez retourner le GUID du format de pixels qui est pris en charge dans pPixelFormat, qui constitue un paramètre d'entrée/sortie.

SetColorContexts permet de spécifier un ou plusieurs contextes de couleurs valides (également appelés profils de couleurs) pour cette image. Il est important de spécifier le(s) contexte(s) de couleurs, de manière qu'une application décodant ensuite l'image puisse effectuer une conversion du profil de couleurs source utilisé pour afficher ou imprimer l'image. Sans profil de couleurs, il est impossible de transmettre fidèlement les couleurs entre des périphériques différents, au grand dam des utilisateurs finals, dont les photos n'offrent pas le même aspect quand elles s'affichent sur des moniteurs différents et qui ne parviennent pas à obtenir des épreuves conformes aux images proposées à l'écran.

GetMetadataQueryWriter retourne un IWICMetadataQueryWriter qu'une application peut utiliser pour insérer ou modifier des propriétés de métadonnées dans un bloc de métadonnées sur la trame d'image.

Vous disposez de plusieurs façons d'instancier un IWICMetadataQueryWriter à partir du IWICComponentFactory. Vous pouvez le créer à partir de votre IWICMetadataBlockWriter, de la façon dont nous avons créé un IWICMetadataQueryReader à partir d'un IWICMetadataBlockReader dans la méthode GetMetadataQueryReader sur l'interface IWICBitmapFrameDecode.

          IWICMetadataQueryWriter* piMetadataQueryWriter = NULL;
          HRESULT hr;

          hr = m_piComponentFactory->CreateQueryWriterFromBlockWriter(
                 static_cast<IWICMetadataBlockWriter*>(this),
                 &piMetadataQueryWriter);
        

Vous pouvez également le créer à partir d'un IWICMetadataQueryReader existant, comme celui que nous avons obtenu à partir de la méthode précitée.

          hr = m_piComponentFactory->CreateQueryWriterFromReader(
                 piMetadataQueryReader, pguidVendor, &piMetadataQueryWriter);
        

Le paramètre pguidVendor vous permet de spécifier un fournisseur particulier, que le QueryWriter utilisera en instanciant un enregistreur de métadonnées. Si, par exemple, vous fournissez vos propres enregistreurs de métadonnées, vous pourrez si vous le souhaitez spécifier votre propre GUID de fournisseur. Ce paramètre est facultatif, et vous pouvez lui transmettre la valeur NULL si vous n'avez pas de préférence.

SetThumbnail permet de fournir une miniature. Toutes les images doivent fournir une miniature, de manière globale et/ou sur chaque trame. Les méthodes GetThumbnail et SetThumbnail sont facultatives au niveau du conteneur mais, si un CODEC retourne WINCODEC_ERR_CODECNOTHUMBNAIL à partir de la méthode GetThumbnail sur IWICBitmapDecoder, WIC appelle la méthode GetThumbnail sur le IWICBitmapFrameDecode pour la trame 0. Si aucune miniature ne figure à aucun des deux emplacements, WIC doit décoder l'image complète et l'adapter au format miniature, risquant ainsi de pénaliser lourdement les performances pour les grandes images.

La miniature doit être d'une taille et d'une résolution accélérant son décodage et son affichage. C'est pourquoi les miniatures sont le plus souvent des images JPEG. Notez que, si vous utilisez JPEG pour vos miniatures, vous n'êtes pas tenu d'écrire un codeur JPEG pour les coder ni un décodeur JPEG pour les décoder. Vous devez toujours confier le codage des miniatures au codeur JPEG qui accompagne la plate-forme WIC.

WritePixels est la méthode utilisée pour transmettre des lignes de numérisation à partir d'un bitmap en mémoire à coder. Cette méthode est appelée de manière répétée, jusqu'à ce que toutes les lignes de numérisation soient transmises. Le paramètre lineCount indique combien de lignes de numérisation doivent être écrites dans l'appel concerné. Le paramètre cbStride indique le nombre d'octets de chaque ligne de numérisation. cbBufferSize indique la taille du tampon transmis dans le paramètre pbPixels, qui contient les bits d'image effectifs à coder. Si la hauteur combinée des lignes de numérisation issues d'appels cumulés dépasse la hauteur spécifiée dans la méthode SetSize, retournez WINCODEC_ERR_TOOMANYSCANLINES.

Lorsque le WICBitmapEncoderCacheOption est WICBitmapEncoderCacheInMemory, les lignes de numérisation doivent être mises en cache dans la mémoire jusqu'à ce qu'elles aient toutes été transmises. Si l'option de mise en cache du codeur est WICBitmapEncoderCacheTempFile, les lignes de numérisation doivent être mises en cache dans un fichier temporaire, créé pendant l'initialisation de l'objet. Dans un cas comme dans l'autre, l'image ne doit être codée qu'une fois que l'appelant a appelé Commit. Lorsque l'option de mise en cache option est WICBitmapEncoderNoCache, le codeur code les lignes de numérisation lors de leur réception, si cela s'avère possible (dans certains formats, c'est impossible et les lignes de numérisation doivent être mises en cache jusqu'à l'appel de Commit).

Il est probable que la plupart des CODEC Raw (bruts) n'implémenteront pas WritePixels, car ils ne prennent pas en charge la modification des bits d'image dans le fichier Raw. Toutefois, les CODEC Raw doivent toujours implémenter WriteSource. En effet, lorsque des données sont ajoutées, elles peuvent accroître la taille du fichier et ce dernier doit ainsi être réécrit sur le disque. Dans ce cas, il est nécessaire de pouvoir copier les bits d'image existants, ce que fait précisément la méthode WriteSource.

WriteSource permet de code un objet IWICBitmapSource. Le premier paramètre est un pointeur vers un objet IWICBitmapSource. Le second paramètre est un WICRect spécifiant la région intéressante à coder. Cette méthode peut être appelée plusieurs fois de suite, dès lors que la largeur de chaque rectangle correspond à celle de l'image finale à coder. Si la largeur du rectangle transmis dans le paramètre prc est différente de la largeur spécifiée dans la méthode SetSize, retournez WINCODEC_ERR_SOURCERECTDOESNOTMATCHDIMENSIONS. Si la hauteur combinée des lignes de numérisation issues d'appels cumulés dépasse la hauteur spécifiée dans la méthode SetSize, retournez WINCODEC_ERR_TOOMANYSCANLINES.

Les options de mise en cache fonctionnent de la même manière avec cette méthode qu'avec la méthode WritePixels précédemment décrite.

Commit est la méthode qui sérialise les bits d'image codés vers le flux de fichier, et effectue une itération à travers tous les enregistreurs de métadonnées pour la trame leur demandant de sérialiser leurs métadonnées vers le flux. Lorsque l'option de mise en cache est WICBitmapEncoderCacheInMemory ou WICBitmapEncoderCacheTempFile, cette méthode est également chargée de coder l'image ; lorsque l'option de mise en cache est WICBitmapEncoderCacheTempFile, la méthode Commit doit également supprimer le fichier temporaire utilisé pour la mise en cache des données d'image avant le codage.

Cette méthode est toujours appelée une fois que toutes les lignes de numérisation ou les rectangles formant l'image ont été transmis à l'aide de la méthode WritePixels ou WriteSource. La taille du rectangle final qui est composé via les appels cumulés vers WritePixels ou WriteSource doit correspondre à celle qui a été spécifiée dans la méthode SetSize. Si elle s'en écarte, cette méthode doit retourner WINCODECERROR_UNEXPECTEDSIZE.

Pour effectuer une itération via les enregistreurs de métadonnées et indiquer à chacun d'entre eux de sérialiser ces métadonnées vers le flux, appelez GetWriterByIndex pour effectuer une itération via les enregistreurs de chaque bloc, et appelez IWICPersistStream.Save sur chaque enregistreur de métadonnées.

          IWICMetadataWriter* piMetadataWRiter = NULL;
          IWICPersistStream* piPersistStream = NULL;
          HRESULT hr;
          for (UINT x=0; x < m_blockCount; x++)
          {
          hr = GetWriterByIndex(x, & piMetadataWriter);
          hr = piMetadataWriter->QueryInterface(
          IID_IWICPersistStream,(void**)&piPersistStream);

          hr = piPersistStream->Save(m_piStream,
          WICPersistOptions.WicPersistOptionDefault, true);
          ...
          }
        

SetPalette : seuls les CODEC présentant des formats indexés sont tenus d'implémenter SetPalette. Si une image utilise un format indexé, recourez à cette méthode pour spécifier la palette des couleurs utilisées dans cette image. Si votre CODEC ne comporte pas de format indexé, retournez WINCODEC_ERR_PALETTEUNAVAILABLE à partir de cette méthode.

IWICMetadataBlockWriter

La classe de codage de niveau trame implémente cette interface pour exposer tous les blocs de métadonnées et demande l'enregistreur de métadonnées adéquat de chaque bloc. Si votre format d'image prend en charge des métadonnées globales, à l'extérieur de toute trame individuelle, vous devrez implémenter cette interface sur la classe de codeur de niveau conteneur. Pour une étude plus détaillée des gestionnaires de métadonnées, reportez-vous à la section sur le IWICMetadataBlockReader, dans la section relative à l'implémentation d'un décodeur doté de fonctionnalités WIC.

interface IWICMetadataBlockWriter : IWICMetadataBlockReader

			{
			// All methods required
			
          HRESULT InitializeFromBlockReader ( IWICMetadataBlockReader 
						 *pIMDBlockReader );
        
			
          HRESULT GetWriterByIndex ( UINT nIndex, 
					IWICMetadataWriter **ppIMetadataWriter );
        
			
          HRESULT AddWriter (IWICMetadataWriter *pIMetadataWriter );
        
			
          HRESULT SetWriterByIndex ( UINT nIndex,
		 IWICMetadataWriter *pIMetadataWriter );
        
			
          HRESULT RemoveWriterByIndex ( UINT nIndex );
        
			}
			

InitializeFromBlockReader utilise un IWICMetadataBlockReader pour initialiser l'enregistreur de bloc. Vous pouvez extraire le IWICMetadataBlockReader à partir du décodeur qui a décodé l'image.

          UINT blockCount = 0;
          IWICMetadataReader* piMetadataReader = NULL;
          IWICMetadataWriter** apiMetadataWriter = NULL;
          HRESULT hr;

          hr = m_piBlockReader->GetCount(&blockCount);
          apiMetadataWriter = IWICMetadataWriter*[blockCount];
          for (UINT x=0; x < blockCount; x++)
          {
          hr = m_piBlockReader-   >GetReaderByIndex(&piMetadataReader);
          hr = m_piComponentFactory->CreateMetadataWriterFromReader(
          piMetadataReader, NULL, &apiMetadataWriter[x]);
          }
        

L'initialisation de IWICMetadataBlockWriter avec un IWICMetadataBlockReader instancie un enregistreur de métadonnées pour chaque lecteur de métadonnées exposé par l'objet IWICMetadataBlockReader. Par conséquent, l'application n'est pas tenue de demander explicitement un enregistreur pour chaque bloc de métadonnées.

GetWriterByIndex retourne l'objet IWICMetadataWriter pour le bloc de métadonnées nth, où n est la valeur transmise dans le paramètre nIndex. S'il n'existe aucun enregistreur de métadonnées inscrit susceptible de gérer le type de métadonnées du bloc nth, le paramètre d'usine du composant retourne le gestionnaire de métadonnées inconnu, lequel traite alors le bloc de métadonnées comme un objet BLOB. Il le sérialise en sortie sous forme d'un flux de bits sans tenter de l'analyser.

AddWriter permet à un appelant d'ajouter un nouvel enregistreur de métadonnées. Cette opération est nécessaire si une application veut ajouter des métadonnées d'un format différent de tous ceux des blocs de métadonnées existants. Par exemple, une application peut ajouter des métadonnées XMP. S'il n'existe aucun bloc de métadonnées XMP, l'application doit alors instancier un enregistreur de métadonnées XMP et utiliser la méthode AddWriter pour l'inclure dans la collection des enregistreurs de métadonnées.

SetWriterByIndex permet d'ajouter un enregistreur de métadonnées sur un index spécifique de la collection. S'il existe actuellement un enregistreur de métadonnées au niveau de cet index, le nouvel enregistreur doit le remplacer.

RemoveWriterByIndex permet de supprimer un enregistreur de métadonnées de la collection.

Installation et inscription des CODEC

Lorsque vous installez un CODEC, vous devez l'inscrire dans le Registre. Vous devez également vous assurer que le cache de miniatures est mis à jour si des images dans votre format sont déjà présentes sur l'ordinateur.

Dans cette section, nous présenterons toutes les clés de Registre que vous devez écrire pour inscrire votre CODEC et lui permettre de participer à la découverte. Nous décrirons également les entrées indispensables pour permettre au CODEC de participer à la recherche de métadonnées et de mettre à jour les services de l'Explorateur Windows et de la Galerie de photos Vista. Nous aborderons également l'API que vous devez appeler dans le programme d'installation de votre CODEC pour mettre à jour le cache de miniatures des images dans votre format d'image qui sont déjà présentes sur l'ordinateur. En dernier lieu, nous expliquerons comment faciliter pour les utilisateurs la recherche et l'installation de votre CODEC lorsque ces derniers possèdent des images dans votre format d'image sur leur ordinateur.

Signature de votre CODEC

Comme nous l'avons signalé dans la section Découverte et arbitrage, tous les CODEC doivent être signés pour participer au processus de découverte de la plateforme Windows Imaging Component (WIC). WIC ne charge pas les CODEC qui ne sont pas signés par une autorité de certification approuvée (telle que Verisign). Pour plus d'informations sur la signature, consultez la documentation du kit de développement Windows Vista (Windows Vista SDK).

Inscription de votre CODEC

Lorsque vous inscrivez un CODEC, vous inscrivez en fait deux composants : le codeur et le décodeur. Vous devrez également créer des entrées de Registre pour inscrire votre format de conteneur avec les gestionnaires de métadonnées des formats de métadonnées que votre format d'image prend en charge.

Entrées de Registre pour les codeurs et les décodeurs

Les entrées de Registre suivantes doivent être créées séparément pour le codeur et le décodeur.

HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},Author = "Nom de l'auteur"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},Description = "Description du codeur ou du décodeur"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},DeviceManufacturer = "Fabricant de l'appareil photo"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},DeviceModels = "Périphérique,Périphérique"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},FriendlyName = "Nom du codeur ou du décodeur"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},FileExtensions = ".foo, .abc, .xyz"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},Date = "mm-jj-aaaa"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},VendorGUID = {Vendor GUID}
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},ContainerFormat = {ContainerFormat GUID}
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},Version = "Numéro.build.principal.secondaire"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},SpecVersion = "Numéro.build.principal.secondaire"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},MimeTypes = "image/foo,image/foo"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},SupportAnimation = 0 ou 1
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},SupportChromakey = 0 ou 1
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},SupportLossless = 0 ou 1
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},SupportMultiframe = 0 ou 1
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},Formats\{PixelFormat GUID}
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},InProcServer32\(Default) = "lecteur:\chemin\votredll.dll"
HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID},InProcServer32\ThreadingModel = "Apartment" | "Les deux"

Les entrées FriendlyName, VendorGUID, ContainerFormat, MimeTypes, FileExtensions et Formats sont obligatoires. Quant aux autres, elles sont facultatives.

Bien que la plupart de ces entrées soient explicites, une explication est nécessaire pour quelques-unes d'entre elles. Les entrées DeviceManufacturer et DeviceModels sont spécifiques aux CODEC bruts et font référence au fabricant de l'appareil photo et aux modèles d'appareil photo auxquels le CODEC s'applique. L'entrée SpecVersion correspond à la version de la spécification de format d'image à laquelle le CODEC se conforme. L'entrée Formats spécifie les formats de pixel pris en charge par le CODEC. Un CODEC peut prendre en charge plusieurs formats de pixel. Dans ce cas, vous devez entrer plusieurs clés sous HKEY_CLASSES_ROOT\CLSID\{Encoder/Decoder CLSID}\Formats.

Entrées de Registre spécifiques au codeur

En complément des entrées répertoriées ci-avant pour le codeur, il est également nécessaire d'inscrire votre codeur sous la catégorie des codeurs WIC afin que le moteur de découverte puisse le trouver. Pour ce faire, vous devez créer les entrées de Registre suivantes. Le premier GUID dans les entrées suivantes est le CATID de WICBitmapEncoders.

HKEY_CLASSES_ROOT\CLSID\{AC757296-3522-4E11-9862-C17BE5A1767E}\Instance\*{Encoder CLSID},*CLSID = *{Encoder CLSID}
HKEY_CLASSES_ROOT\CLSID\{AC757296-3522-4E11-9862-C17BE5A1767E}\Instance\{Encoder CLSID},*Friendly Name = "Nom du codeur"

Inscription d'un nouveau format de conteneur avec des enregistreurs de métadonnées

Si vous créez un nouveau format de conteneur pour votre CODEC, vous devrez également créer des entrées de Registre pour gérer les enregistreurs de métadonnées correspondant aux blocs de métadonnées dans vos images. Vous devez créer les entrées suivantes sous le CLSID de l'enregistreur de métadonnées pour chaque format de métadonnées pris en charge dans votre format de conteneur. Si votre CODEC utilise un conteneur TIFF, ces informations figurent déjà dans le Registre et il n'est pas nécessaire de créer ces entrées.

HKEY_CLASSES_ROOT\CLSID\{Metadata Writer CLSID}\Containers\{Container Format GUID},WritePosition = Décalage par rapport à son conteneur
HKEY_CLASSES_ROOT\CLSID\{Metadata Writer CLSID}\Containers\{Container Format GUID}
,WriteHeader = Modèle utilisé pour l'en-tête des métadonnées
HKEY_CLASSES_ROOT\CLSID\{Metadata Writer CLSID}\Containers\{Container Format GUID}
,WriteOffset = Décalage à partir du début de l'en-tête

Si vous utilisez un format de conteneur de type TIFF ou JPEG, vous devrez inscrire une association entre votre conteneur et ce format de conteneur. Reportez-vous à la section Intégration à la banque de propriétés Windows pour plus de détails.

Entrées de Registre spécifiques au décodeur

Outre les entrées de Registre obligatoires pour tous les codeurs et les décodeurs, les entrées suivantes sont requises spécifiquement pour les décodeurs.

Ces entrées inscrivent votre décodeur sous la catégorie des décodeurs WIC. Le premier GUID dans ces entrées est le CATID de WICBitmapDecoders.

HKEY_CLASSES_ROOT\CLSID\{7ED96837-96F0-4812-B211-F13C24117ED3}\Instance\{Decoder CLSID},CLSID = {Decoder CLSID}
HKEY_CLASSES_ROOT\CLSID\{7ED96837-96F0-4812-B211-F13C24117ED3}\Instance\{Decoder CLSID}
,Friendly Name = "Nom du décodeur"

Comme nous l'avons signalé précédemment dans la section Découverte et arbitrage, le mécanisme qui permet la découverte au moment de l'exécution d'un décodeur approprié à une image donnée repose sur l'établissement d'une correspondance entre un modèle d'identification incorporé dans le fichier image et un modèle spécifié dans l'entrée de Registre du décodeur. Pour permettre la découverte des décodeurs au moment de l'exécution, vous devez inscrire le modèle d'identification unique de votre format d'image comme suit. Toutes ces entrées de Registre sont requises, à l'exception de l'entrée EndOfStream, facultative, comme décrit ci-après.

HKEY_CLASSES_ROOT\CLSID\{Decoder CLSID}\Patterns\0,Position = Décalage dans le bloc
HKEY_CLASSES_ROOT\CLSID\{Decoder CLSID}
\Patterns\0,Length = Longueur du modèle
HKEY_CLASSES_ROOT\CLSID\{Decoder CLSID}
\Patterns\0,Pattern = Modèle pour lequel établir une correspondance
HKEY_CLASSES_ROOT\CLSID\{Decoder CLSID}
\Patterns\0,Mask = FF FF FF FF
HKEY_CLASSES_ROOT\CLSID\{Decoder CLSID}
\Patterns\0,EndOfStream= 0 ou 1

La valeur Position indique le décalage dans le fichier où se trouve le modèle.

La valeur Length déclare la longueur du modèle.

La valeur Pattern spécifie les bits réels qui composent le modèle. Il s'agit des bits qui sont comparés au modèle d'identification dans un fichier image durant la découverte.

La valeur Mask autorise les valeurs de caractère générique dans les modèles. Le masque est appliqué en effectuant une opération AND logique sur le modèle et le masque. Les bits du modèle qui correspondent à un bit du masque avec une valeur de 0 sont ignorés.

La valeur EndOfStream, lorsqu'elle est présente, indique si le décalage du modèle d'identification doit être calculé à partir de la fin du flux plutôt qu'à partir du début. Certains formats d'image placent le modèle d'identification à la fin ou vers la fin du fichier. Par défaut, la recherche est effectuée à partir du début ; par conséquent, vous pouvez omettre cette entrée, sauf si votre modèle est près de la fin du fichier.

Un CODEC peut prendre en charge plusieurs modèles d'identification. Dans ce cas, vous devez répéter toutes les clés sous HKEY_CLASSES_ROOT\CLSID\{Decoder CLSID}\Patterns et utiliser la clé numérique (0 dans l'exemple) pour faire la distinction entre les différents modèles. Vous devez inclure chacune des quatre valeurs sous la clé de chaque modèle.

Inscription d'un nouveau format de conteneur avec des lecteurs de métadonnées

Si vous créez un nouveau format de conteneur pour votre CODEC, vous devrez également créer des entrées de Registre afin de gérer la découverte des lecteurs de métadonnées correspondant aux blocs de métadonnées dans vos images, en procédant de la même manière que pour les enregistreurs de métadonnées. Vous devez créer les entrées suivantes sous le CLSID du lecteur de métadonnées pour chaque format de métadonnées que votre format de conteneur prend en charge. (Notez que si votre CODEC utilise un conteneur TIFF, ces informations figurent déjà dans le Registre.)

HKEY_CLASSES_ROOT\CLSID\{Metadata Reader CLSID}\Containers\{Container Format GUID}\0,Position = Décalage par rapport à son conteneur
HKEY_CLASSES_ROOT\CLSID\{Metadata Reader CLSID}\Containers\{Container Format GUID}
\0,Pattern = Modèle utilisé pour l'en-tête de métadonnées
HKEY_CLASSES_ROOT\CLSID\{Metadata Reader CLSID}\Containers\{Container Format GUID}
\0,Mask = FF FF FF FF
HKEY_CLASSES_ROOT\CLSID\{Metadata Reader CLSID}\Containers\{Container Format GUID}
\0,DataOffset = Décalage à partir du début de l'en-tête

Dans la mesure où les lecteurs de métadonnées sont également utilisés pour la découverte, ils sont très similaires aux entrées des décodeurs. Ces entrées sont utilisées par le paramètre d'usine du composant pour rechercher les lecteurs de métadonnées pris en charge par votre conteneur et pour sélectionner le lecteur approprié, lorsque votre implémentation de IWICMetadataBlockReader demande un lecteur de métadonnées.

La valeur Position indique le décalage dans le conteneur du bloc de métadonnées où se trouve l'en-tête de métadonnées. Pour les blocs de métadonnées de premier niveau, il s'agira du décalage dans le fichier de flux. Pour les blocs de métadonnées imbriqués dans d'autres, il s'agira du décalage par rapport au bloc de métadonnées qui les contient.

La valeur Pattern de l'en-tête de métadonnées est généralement définie par le gestionnaire de métadonnées, et vous devez utiliser l'en-tête de métadonnées standard pour chaque lecteur, sauf s'il est indispensable que le modèle possède un format différent dans votre conteneur.

La valeur facultative DataOffset indique le décalage à partir du début de l'en-tête de métadonnées auquel les données réelles commencent. Dans les cas de figure où les métadonnées ne sont pas situées à un décalage spécifique par rapport à l'en-tête, cette entrée peut être omise.

Intégration avec l'Explorateur Windows et la Galerie de photos Windows Vista

Pour que l'Explorateur Windows et la Galerie de photos Vista puissent afficher des miniatures et également rechercher et mettre à jour des métadonnées d'image standard, un CODEC doit posséder une implémentation de l'interface IThumbnailProvider et de l'interface IPropertyStore associée. L'interface IThumbnailProvider est utilisée pour extraire des miniatures et charger le cache de miniatures, et l'interface IPropertyStore est utilisée pour rechercher et mettre à jour les métadonnées associées à un fichier. Tous les types de fichiers dans Windows Vista possèdent des miniatures et des métadonnées, mais différents types de fichiers nécessitent différentes implémentations de ces interfaces pour extraire ou générer les miniatures et leurs métadonnées. Windows Vista fournit des implémentations par défaut de ces interfaces. L'implémentation par défaut de IThumbnailProvider peut être utilisée pour n'importe quel format d'image compatible WIC. L'implémentation par défaut de IPropertyStore peut être utilisée avec n'importe quel format d'image compatible WIC qui repose sur un conteneur TIFF ou JPEG. Pour associer votre format d'image aux implémentations par défaut de ces deux interfaces, vous devez simplement ajouter quelques entrées de Registre.

Les entrées suivantes indiquent à l'Explorateur Windows et à la Galerie de photos Vista qu'une extension de fichier (.ext) et son type Mime correspondant sont associés à un format d'image.

HKEY_CLASSES_ROOT\.ext,ContentType = "Type Mime du format d'image"HKEY_CLASSES_ROOT\.ext,PerceivedType = "image"

Intégration à la banque de propriétés Windows

Parfois, les mêmes propriétés de métadonnées sont exposées dans différents schémas de métadonnées, souvent avec des noms de propriétés différents. Lorsque l'une de ces propriétés est mise à jour (alors que les autres ne le sont pas), il est possible que les métadonnées du fichier ne soient plus synchronisées. Le gestionnaire de propriétés de photos Windows fournit l'implémentation par défaut IPropertyStore pour les images, et il est utilisé par les applications ainsi que par l'Explorateur Windows et la Galerie de photos Vista pour vérifier que toutes les métadonnées d'une image restent synchronisées et que les propriétés affichées par les applications sont cohérentes avec celles qui sont affichées par l'Explorateur Windows et la Galerie de photos Windows Vista. Lorsque le gestionnaire de propriétés de photos met à jour les métadonnées, il veille à ce que ces propriétés soient mises à jour harmonieusement pour tous les formats de métadonnées courants qui sont présents dans le fichier.

Pour ce faire, le gestionnaire de propriétés de photos doit connaître le format de conteneur et savoir comment localiser les différentes propriétés qui le composent. En général, le gestionnaire de propriétés de photos ne peut pas savoir comment les différents blocs de métadonnées sont agencés dans un format de conteneur propriétaire, mais si les métadonnées dans votre format de conteneur sont agencées de la même manière que les métadonnées dans un format de conteneur TIFF ou JPEG, le gestionnaire de propriétés de photos peut tirer parti de ces informations pour mettre également à jour les métadonnées de manière cohérente dans votre format de conteneur.

Vous pouvez inscrire cette association en créant l'entrée de Registre suivante. Cette entrée informe le gestionnaire de propriétés de photos que le format de conteneur identifié par ce GUID comprend les mêmes chemins des langages de requête de métadonnées que le format de conteneur avec le GUID 163bcc30-e2e9-4f0b-961d-a3e9fdb788a3. (163bcc30-e2e9-4f0b-961d-a3e9fdb788a3 est le GUID du format de conteneur TIFF.)

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\ PhotoPropertyHandler\ContainerAssociations,{Container Format GUID} = {163bcc30-e2e9-4f0b-961d-a3e9fdb788a3}

L'entrée suivante associe l'implémentation par défaut du gestionnaire de propriétés de photos de IPropertyStore aux fichiers qui portent l'extension ".ext". Le premier GUID est l'IID de l'interface IPropertyStore, et le second est le GUID de l'implémentation du gestionnaire de propriétés de photos de celle-ci.

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\PropertySystem\PropertyHandlers\.ext,(Default) = "{a38b883c-1682-497e-97b0-0a3a9e801682}"

Les CODEC qui utilisent un format propriétaire non compatible avec le format de conteneur TIFF ou JPEG devront écrire leur propre implémentation IPropertyStore.

Intégration à Galerie de photos Windows Vista

Windows Vista intègre une nouvelle visionneuse de photos qui repose sur la plateforme WIC et qui peut afficher n'importe quel format d'image compatible WIC pour lequel le CODEC est installé. Pour notifier Windows Vista que votre format d'image peut être ouvert dans la nouvelle visionneuse (Photo Viewer), vous devez créer une association de fichier avec la visionneuse. Pour ce faire, vous devez écrire les entrées de Registre suivantes.

HKEY_CLASSES_ROOT\.ext,(Default) = " ProgID" (par exemple fichierext)
HKEY_CLASSES_ROOT\.ext
\OpenWithProgids,ProgID
HKEY_CLASSES_ROOT\.ext\OpenWithList\PhotoViewer.dll
HKEY_CLASSES_ROOT\.ext\ShellEx\ContextMenuHandlers\ShellImagePreview, (Default) = "{FFE2A43C-56B9-4bf5-9A79-CC6D4285608A}"

HKEY_CLASSES_ROOT\SystemFileAssociations\.ext\OpenWithList\PhotoViewer.dll
HKEY_CLASSES_ROOT\SystemFileAssociations\.ext\ShellEx\ContextMenuHandlers\ ShellImagePreview,(Default) = "{FFE2A43C-56B9-4bf5-9A79-CC6D4285608A}"

HKEY_CLASSES_ROOT\Image Format ProgID,(Default) = *"Nom du format d'image"
*HKEY_CLASSES_ROOT\Image Format ProgID\DefaultIcon,(Default) = "Chemin d'accès de l'icône du type de fichier, index d'icône"

HKEY_CLASSES_ROOT\Image Format ProgID\shell\open\command,(Default) ="%SystemRoot%\System32\rundll32.exe "%ProgramFiles%\Windows Photo Gallery\PhotoViewer.dll", ImageView_Fullscreen %1"

HKEY_CLASSES_ROOT\Image Format ProgID\shell\open,MuiVerb = "@%PROGRAM_FILES%\Windows Photo Gallery\photoviewer.dll,-3043"

HKEY_CLASSES_ROOT\Image Format ProgID\shell\open\DropTarget,Clsid = "{FFE2A43C-56B9-4bf5-9A79-CC6D4285608A}"

HKEY_CLASSES_ROOT\Image Format ProgID\shell\printto\command,(Default) = "%SystemRoot%\System32\rundll32,exe "%ProgramFiles%\Windows Photo Gallery\PhotoViewer.dll", ImageView_PrintTo /pt "%1" "%2" "%3" "%4"

La valeur ProgID est généralement l'extension de fichier ajoutée avec le mot "fichier". (Par exemple, si l'extension de fichier est .foo, la valeur ProgID sera en principe "foofichier".)

Il existe d'autres entrées de Registre standard que vous devez créer pour les associations de fichiers, mais dans la mesure où elles ne sont pas spécifiques à WIC ou à Windows Vista, elles n'entrent pas dans le cadre de cet article. Pour plus d'informations sur les associations de fichiers, consultez la documentation du kit de développement Windows (Windows SDK).

Intégration au cache de miniatures de Windows Vista

Les deux entrées suivantes indiquent que l'implémentation du fournisseur de miniatures WIC standard peut être utilisée pour extraire des miniatures pour les fichiers portant cette extension. Le premier GUID est l'IID de l'interface IThumbnailProvider, et le second est le GUID de l'implémentation Windows Vista standard de cette interface. (Toutes le entrées sous HLCR\.ext\ShellEx\ sont répétées sous HKCR\SystemFileAssociations\.ext\ShellEx\.)

HKEY_CLASSES_ROOT\.ext\ShellEx\{e357fccd-a995-4576-b01f-234630154e96},(Default) = "{C7657C4A-9F68-40fa-A4DF-96BC08EB3551}"

HKEY_CLASSES_ROOT\.ext\ShellEx\{e357fccd-a995-4576-b01f-234630154e96},(Default) = "{C7657C4A-9F68-40fa-A4DF-96BC08EB3551}"

Installation et désinstallation de votre CODEC

Votre programme d'installation doit non seulement inscrire votre CODEC, mais également mettre à jour le cache de miniatures, pour l'informer qu'aucun nouveau CODEC n'est disponible et garantir que votre décodeur est utilisé pour extraire des miniatures pour les images déjà présentes sur votre ordinateur.

Mise à jour du cache de miniatures lors de l'installation de votre CODEC

Lorsqu'un CODEC est installé, le programme d'installation doit appeler l'API Windows suivante après avoir écrit ses entrées de Registre.

SHChangeNotify(SHCNE_ASSOCCHANGED, SHCNF_IDLIST, NULL, NULL)

Cet appel notifie Windows que de nouvelles informations d'association de fichier sont disponibles. Si des images dans votre format d'image sont déjà présentes sur l'ordinateur, le cache de miniatures contiendra les miniatures par défaut correspondantes, car aucun décodeur n'était disponible pour extraire les miniatures lors de l'acquisition initiale des images. Lorsque vous notifiez Windows qu'une nouvelle association de fichier est disponible, le cache de miniatures supprime toutes les miniatures vides et extrait les miniatures réelles des fichiers qui peuvent désormais être décodés.

Désinstallation de votre CODEC

En règle générale, lorsque vous désinstallez un composant, vous désinstallez également toutes les dépendances que vous aviez installées. Ce n'est pas le cas avec WIC.

Lorsque vous téléchargez le composant redistribuable WIC (Windows Imaging Component), vous devez accepter une condition de contrat de licence stipulant que vous ne désinstallerez jamais WIC. Cette restriction est liée au fait que WIC est un composant système dont dépendent de nombreuses applications installées. Étant donné qu'il s'agit d'un composant système, il ne peut exister qu'une seule instance de WIC sur un ordinateur à un moment donné. Par conséquent, si une application ou un composant doit être désinstallé, les applications qui en dépendent ne fonctionneront plus.

Le programme de désinstallation présent dans le package WIC a pour seul but de permettre aux utilisateurs finaux de désinstaller WIC par le biais de l'utilitaire Ajouter ou supprimer des programmes du Panneau de configuration.

Important :   Un CODEC ou une application ne doit en aucun cas désinstaller le composant WIC (Windows Imaging Component).

Mise à disposition du CODEC avec WIC activé pour les utilisateurs

Si vous êtes fabricant d'appareils photo, vous pouvez intégrer vos CODEC bruts dans le packaging de vos appareils photo. Vous pouvez également publier vos CODEC sur la page de téléchargement de votre site Web. Cependant, si un utilisateur se procure un fichier image dans votre format auprès d'une autre source (par exemple, un ami ou un collaborateur) ou d'un autre site Web, il ne saura pas forcément où se procurer le CODEC permettant de le décoder.

Pour réduire ce problème, Windows Vista offre aux personnes qui utilisent votre format d'image une méthode simple pour rechercher votre CODEC et le télécharger sur leur ordinateur. Si la Galerie de photos Windows Vista reconnaît une extension de fichier en tant que format d'image et que le CODEC de ce format n'est pas installé, une boîte de dialogue informe l'utilisateur que la photo ne peut pas être affichée et lui demande s'il souhaite télécharger le logiciel requis pour l'afficher. Lorsque l'utilisateur accepte, il est dirigé vers un site Web hébergé par Microsoft qui comporte un lien vers le site de téléchargement du fabricant du CODEC. (Vous pouvez éventuellement demander que les utilisateurs soient dirigés directement vers votre site de téléchargement.)

Si vous souhaitez que les extensions de fichiers de votre format d'image soient reconnues par la Galerie de photos Windows Vista afin que les utilisateurs puissent être dirigés vers votre site de téléchargement, vous devez effectuer les opérations suivantes :

  1. Indiquez un site de téléchargement pour votre CODEC. (Vous pouvez configurer une page indépendante pour chaque CODEC que vous fournissez, ou une page qui propose des téléchargements pour tous vos CODEC.)

    • Le site de téléchargement doit être localisé et les recherches en fonction du modèle de l'appareil photo doivent être simples à effectuer.
  2. Communiquez à Microsoft la liste des extensions de vos formats d'image, ainsi que l'URL de votre site de téléchargement.

Vous devrez faire connaître à Microsoft les extensions des nouveaux CODEC que vous développerez à l'avenir, ainsi que toute modification apportée à l'URL de votre site de téléchargement, afin que les nouvelles informations puissent être ajoutées à la Galerie de photos.

Conclusion

Si vous créez votre CODEC sur la plateforme WIC (Windows Imaging Component), toutes les applications reposant sur WIC bénéficient d'une prise en charge de votre format d'image identique à celle obtenue pour les formats d'image courants livrés avec la plateforme. De plus, la visionneuse de photos, l'Explorateur et la Galerie de photos Windows Vista peuvent afficher des miniatures et des aperçus d'images dans votre format à l'aide du décodeur que vous fournissez. Pour les formats bruts, la plateforme WIC permet aux applications d'acquisition d'images plus sophistiquées de tirer parti des fonctionnalités de traitement brut de votre décodeur. Selon les options de décodeur que vous prenez en charge, vous pouvez également exposer les capacités uniques de votre codeur pour permettre aux applications d'exploiter pleinement les fonctionnalités avancées de votre format d'image.

Le développement d'un CODEC avec WIC activé repose sur l'implémentation de nouvelles interfaces. Bien souvent, vous pouvez écrire un wrapper pour votre CODEC existant qui implémente ces interfaces. Lorsque vous installez votre CODEC, vous devez créer des entrées de Registre pour qu'il puisse être détecté par la plateforme WIC, puis l'associer aux gestionnaires de métadonnées appropriés. Vous devez également appeler une API pour effacer du cache de miniatures les miniatures (vides) par défaut qui ont pu être précédemment associées aux images dans votre format. Si vous le souhaitez, vous pouvez faire en sorte que la Galerie de photos Windows Vista fournisse aux utilisateurs un lien leur permettant de télécharger votre CODEC lorsque la Galerie de photos rencontre une image dotée de votre extension de fichier. Pour ce faire, vous devez transmettre à Microsoft des informations concernant l'extension de fichier de votre CODEC et l'URL de votre site de téléchargement.

Le développement de CODEC sur la plateforme WIC offre de nombreux avantages aux utilisateurs de votre format d'image et facilite la prise en charge de votre format d'image par les applications tierces.