Översikt över utökningsbarhet för metadata

Det här avsnittet beskriver kraven för att skapa anpassade metadatahanterare för Windows Imaging Component (WIC), inklusive både metadataläsare och skrivare. Den beskriver också kraven för att utöka identifieringen av WIC-körningskomponenten till att omfatta dina anpassade metadatahanterare.

Det här avsnittet innehåller följande avsnitt.

• Förutsättningar
• Introduktion
• Skapa en metadataläsare
  • IWICMetadataReader-gränssnitt
  • IWICPersistStream-gränssnittet
  • IWICStreamProvider-gränssnittet
• Skapa en metadataskrivare
  • IWICMetadataWriter Interface
  • IWICPersistStream-gränssnittet
  • IWICStreamProvider Interface
• Installera och registrera en metadatahanterare
  • Registernycklar för Metadatahanterare
  • metadataläsare
  • metadataförfattare
  • Signera en metadatahanterare
• särskilda överväganden
  • PROPVARIANTS
  • 8BIM-hanterare
• Relaterade ämnen

Förutsättningar

För att förstå det här avsnittet bör du ha en djupgående förståelse för WIC, dess komponenter och metadata för bilder. Mer information om WIC-metadata finns i översikt över WIC-metadata. För mer information om WIC-komponenterna, se Översikt över Windows Imaging-komponenten.

Introduktion

Som beskrivs i översikt över WIC-metadatafinns det ofta flera metadatablock i en bild som var och en exponerar olika typer av information i olika metadataformat. Om du vill interagera med ett metadataformat som är inbäddat i en bild måste ett program använda en lämplig metadatahanterare. WIC tillhandahåller flera metadatahanterare (både metadataläsare och skribenter) som gör att du kan läsa och skriva specifika typer av metadata, till exempel Exif eller XMP.

Förutom de interna hanterare som tillhandahålls tillhandahåller WIC API:er som gör att du kan skapa nya metadatahanterare som deltar i WIC:s identifiering av körningskomponenter. På så sätt kan program som använder WIC läsa och skriva anpassade metadataformat.

Följande steg gör det möjligt för dina metadatahanterare att delta i WIC:s metadataupptäckt vid körning.

• Implementera en metadataläsarhanterarklass (IWICMetadataReader) som exponerar de nödvändiga WIC-gränssnitten för att läsa ditt anpassade metadataformat. Detta gör det möjligt för WIC-baserade program att läsa metadataformatet på samma sätt som de läser interna metadataformat.
• Implementera en metadata-skrivarhanterarklass (IWICMetadataWriter) som exponerar de nödvändiga WIC-gränssnitten för kodning av ditt anpassade metadataformat. Detta gör det möjligt för WIC-baserade program att serialisera metadataformatet till bildformat som stöds.
• Signera och registrera metadatahanterare digitalt. Detta gör att dina metadatarutiner kan upptäckas under körning genom att matcha mönstret i registret med det mönster som är inbäddat i avbildningsfilen.

Skapa en metadataläsare

Den huvudsakliga åtkomsten till metadatablock i en codec är via IWICMetadataBlockReader gränssnitt som varje WIC-codec implementerar. Det här gränssnittet räknar upp vart och ett av de metadatablock som är inbäddade i ett bildformat så att lämplig metadatahanterare kan identifieras och instansieras för varje block. De metadatablock som inte identifieras av WIC anses vara okända och definieras som GUID-CLSID_WICUnknownMetadataReader. Om du vill att metadataformatet ska kännas igen av WIC måste du skapa en klass som implementerar tre gränssnitt: IWICMetadataReader, IWICPersistStreamoch IWICStreamProvider.

IWICMetadataReader-gränssnitt

Gränssnittet IWICMetadataReader måste implementeras när du skapar en metadataläsare. Det här gränssnittet ger åtkomst till underliggande metadataobjekt i dataströmmen i ett metadataformat.

Följande kod visar definitionen av metadataläsargränssnittet enligt definitionen i filen wincodecsdk.idl.

interface IWICMetadataReader : IUnknown
{
    HRESULT GetMetadataFormat(
        [out] GUID *pguidMetadataFormat
        );

    HRESULT GetMetadataHandlerInfo(
        [out] IWICMetadataHandlerInfo **ppIHandler
        );

    HRESULT GetCount(
        [out] UINT *pcCount
        );

    HRESULT GetValueByIndex(
        [in] UINT nIndex,
        [in, out, unique] PROPVARIANT *pvarSchema,
        [in, out, unique] PROPVARIANT *pvarId,
        [in, out, unique] PROPVARIANT *pvarValue
        );

    HRESULT GetValue(
        [in, unique] const PROPVARIANT *pvarSchema,
        [in] const PROPVARIANT *pvarId,
        [in, out, unique] PROPVARIANT *pvarValue
        );

    HRESULT GetEnumerator(
        [out] IWICEnumMetadataItem **ppIEnumMetadata
        );
};

Metoden GetMetadataFormat returnerar GUID för ditt metadataformat.

Metoden GetMetadataHandlerInfo returnerar ett IWICMetadataHandlerInfo--gränssnitt som innehåller information om metadatahanteraren. Detta inkluderar information som vilka bildformat som stöder metadataformatet och om metadataläsaren kräver åtkomst till den fullständiga metadataströmmen.

Metoden GetCount returnerar antalet enskilda metadataobjekt (inklusive inbäddade metadatablock) som finns i metadataströmmen.

Metoden GetValueByIndex returnerar ett metadataobjekt med ett indexvärde. Med den här metoden kan program loopa igenom varje metadataobjekt i ett metadatablock. Följande kod visar hur ett program kan använda den här metoden för att hämta varje metadataobjekt i ett metadatablock.

PROPVARIANT readerValue;
IWICMetadataBlockReader *blockReader = NULL;
IWICMetadataReader *reader = NULL;

PropVariantInit(&readerValue);

hr = pFrameDecode->QueryInterface(IID_IWICMetadataBlockReader, (void**)&blockReader);

if (SUCCEEDED(hr))
{
    // Retrieve the third block in the image. This is image specific and
    // ideally you should call this by retrieving the reader count
    // first.
    hr = blockReader->GetReaderByIndex(2, &reader);
}

if (SUCCEEDED(hr))
{
    UINT numValues = 0;

    hr = reader->GetCount(&numValues);

    // Loop through each item and retrieve by index
    for (UINT i = 0; SUCCEEDED(hr) && i < numValues; i++)
    {
        PROPVARIANT id, value;

        PropVariantInit(&id);
        PropVariantInit(&value);

        hr = reader->GetValueByIndex(i, NULL, &id, &value);

        if (SUCCEEDED(hr))
        {
            // Do something with the metadata item.
            //...
        }
        PropVariantClear(&id);
        PropVariantClear(&value);
    }               
}

Metoden GetValue hämtar ett specifikt metadataobjekt efter schema och/eller ID. Den här metoden liknar metoden GetValueByIndex förutom att den hämtar ett metadataobjekt som har ett specifikt schema eller ID.

Metoden GetEnumerator returnerar en uppräknare för varje metadataobjekt i metadatablocket. Detta gör det möjligt för program att använda en uppräknare för att navigera i metadataformatet.

Om metadataformatet inte har en uppfattning om scheman för metadataobjekt, kommer GetValue... metoder bör ignorera den här egenskapen. Men om formatet stöder schemanamngivning bör du förvänta dig ett NULL- värde.

Om ett metadataobjekt är ett inbäddat metadatablock skapar du en metadatahanterare från underströmmen av det inbäddade innehållet och returnerar den nya metadatahanteraren. Om det inte finns någon tillgänglig metadataläsare för det kapslade blocket instansierar och returnerar du en okänd metadataläsare. Om du vill skapa en ny metadataläsare för det inbäddade blocket anropar du komponentfabrikens CreateMetadataReaderFromContainer eller CreateMetadataReader metoder eller anropar funktionen WICMatchMetadataContent.

Om metadataströmmen innehåller stort endianskt innehåll ansvarar metadataläsaren för att växla alla datavärden som den bearbetar. Det är också ansvarigt för att informera alla kapslade metadataläsare om att de arbetar med en big-endian-dataström. Alla värden bör dock returneras i little-endian-format.

Implementera stöd för namnområdesnavigering genom att stödja frågor där metadataobjektets ID är en VT_CLSID (ett GUID) som motsvarar ett metadataformat. Om en kapslad metadataläsare för det formatet identifieras under parsningen måste den returneras. På så sätt kan program använda en metadatafrågasläsare för att söka i metadataformatet.

När du hämtar ett metadataobjekt efter ID bör du använda PropVariantChangeType-funktion för att tvinga ID:t till den förväntade typen. Till exempel tvingar IFD-läsaren ett ID att skriva VT_UI2 för att sammanfalla med datatypen för ett IFD-tagg-ID USHORT. Indatatypen och den förväntade typen måste båda vara PROPVARIANT- för att göra detta. Detta krävs inte, men om du gör det här tvånget förenklas kod som anropar läsaren för att fråga efter metadataobjekt.

IWICPersistStream-gränssnitt

Gränssnittet IWICPersistStream ärver från IPersistStream och innehåller ytterligare metoder för att spara och läsa in objekt med hjälp av WICPersistOptions uppräkning.

Följande kod visar definitionen av gränssnittet IWICPersistStream enligt definitionen i filen wincodecsdk.idl.

interface IWICPersistStream : IPersistStream
{
    HRESULT LoadEx(
        [in, unique] IStream *pIStream,
        [in, unique] const GUID *pguidPreferredVendor,
        [in] DWORD dwPersistOptions
        );

    HRESULT SaveEx(
        [in] IStream *pIStream,
        [in] DWORD dwPersistOptions,
        [in] BOOL fClearDirty
        );
};

Metoden LoadEx ger metadataläsaren en dataström som innehåller metadatablocket. Läsaren parsar den här strömmen för att få åtkomst till underliggande metadataobjekt. Metadataläsaren initieras med en underström som är placerad i början av råmetadatainnehållet. Om läsaren inte kräver den fullständiga dataströmmen är underströmmen begränsad till endast innehållet i metadatablocket. Annars tillhandahålls den fullständiga metadataströmmen med den position som angetts i början av metadatablocket.

Metoden SaveEx används av metadataskrivare för att serialisera ditt metadatablock. När SaveEx används i en metadataläsare bör den returnera WINCODEC_ERR_UNSUPPORTEDOPERATION.

IWICStreamProvider-gränssnitt

Med IWICStreamProvider--gränssnittet kan metadataläsaren ange referenser till innehållsströmmen, ange information om strömmen och uppdatera cachelagrade versioner av strömmen.

Följande kod visar definitionen av IWICStreamProvider-gränssnittet enligt definitionen i filen wincodecsdk.idl.

interface IWICStreamProvider : IUnknown
{
    HRESULT GetStream(
        [out] IStream **ppIStream
        );

    HRESULT GetPersistOptions(
        [out] DWORD *pdwPersistOptions
        );

    HRESULT GetPreferredVendorGUID(
        [out] GUID *pguidPreferredVendor
        );

    HRESULT RefreshStream(
        );
};

Metoden GetStream hämtar en referens till din metadataström. Strömmen som du returnerar bör få strömpekaren återställd till startpositionen. Om metadataformatet kräver fullständig dataströmsåtkomst bör startpositionen vara början på metadatablocket.

Metoden GetPersistOptions returnerar strömmens aktuella alternativ från WICPersistOptions uppräkning.

Metoden GetPreferredVendorGUID returnerar GUID för leverantören av metadataläsaren.

Metoden RefreshStream uppdaterar metadataströmmen. Den här metoden måste anropa LoadEx- med en NULL- ström för alla kapslade metadatablock. Detta är nödvändigt eftersom kapslade metadatablock och deras element kanske inte längre finns, på grund av direktredigering.

Skapa en metadataskrivare

En metadataskrivare är en typ av metadatahanterare som ger ett sätt att serialisera ett metadatablock till en bildram eller utanför en enskild ram om bildformatet stöder det. Den huvudsakliga åtkomsten till metadataskrivarna i en codec är via IWICMetadataBlockWriter gränssnitt som varje WIC-kodare implementerar. Det här gränssnittet gör det möjligt för program att räkna upp vart och ett av metadatablocken som är inbäddade i en bild så att lämplig metadataskrivare kan identifieras och instansieras för varje metadatablock. Metadatablock som inte har någon motsvarande metadataskrivare anses vara okända och definieras som GUID-CLSID_WICUnknownMetadataReader. Om du vill aktivera WIC-aktiverade program för att serialisera och skriva metadataformatet måste du skapa en klass som implementerar följande gränssnitt: IWICMetadataWriter, IWICMetadataReader, IWICPersistStreamoch IWICStreamProvider.

IWICMetadataWriter-gränssnitt

Gränssnittet IWICMetadataWriter måste implementeras av metadataskrivaren. Eftersom IWICMetadataWriter ärver från IWICMetadataReadermåste du också implementera alla metoder för IWICMetadataReader. Eftersom båda hanteringstyperna kräver samma gränssnittsarv kanske du vill skapa en enda klass som innehåller både läs- och skrivfunktioner.

Följande kod visar definitionen av metadataskrivarens gränssnitt enligt definitionen i filen wincodecsdk.idl.

interface IWICMetadataWriter : IWICMetadataReader
{
    HRESULT SetValue(
        [in, unique] const PROPVARIANT *pvarSchema,
        [in] const PROPVARIANT *pvarId,
        [in] const PROPVARIANT *pvarValue
        );

    HRESULT SetValueByIndex(
        [in] UINT nIndex,
        [in, unique] const PROPVARIANT *pvarSchema,
        [in] const PROPVARIANT *pvarId,
        [in] const PROPVARIANT *pvarValue
        );

    HRESULT RemoveValue(
        [in, unique] const PROPVARIANT *pvarSchema,
        [in] const PROPVARIANT *pvarId
        );

    HRESULT RemoveValueByIndex(
        [in] UINT nIndex
        );
};

Metoden SetValue skriver det angivna metadataobjektet till metadataströmmen.

Metoden SetValueByIndex skriver det angivna metadataobjektet till det angivna indexet i metadataströmmen. Indexet refererar inte till ID:t utan till objektets position i metadatablocket.

Metoden RemoveValue tar bort det angivna metadataobjektet från metadataströmmen.

Metoden RemoveValueByIndex tar bort metadataobjektet i det angivna indexet från metadataströmmen. När du har tagit bort ett objekt förväntas de återstående metadataobjekten uppta det tömda indexet om indexet inte är det sista indexet. Det förväntas också att antalet ändras när objektet har tagits bort.

Det är metadataförfattarens ansvar att konvertera PROPVARIANT objekt till den underliggande struktur som krävs av ditt format. Men till skillnad från metadataläsaren bör VARIANT-typer normalt inte tvingas till olika typer eftersom anroparen specifikt anger vilken datatyp som ska användas.

Metadataskrivaren måste spara alla metadataobjekt i bildströmmen, inklusive dolda eller okända värden. Detta inkluderar okända kapslade metadatablock. Det är dock kodarens ansvar att ange viktiga metadataobjekt innan du påbörjar spara-åtgärden.

Om metadataströmmen innehåller big-endian-innehåll ansvarar metadataskrivaren för att byta alla datavärden som den bearbetar. Det är också ansvarigt för att informera alla kapslade metadataförfattare om att de arbetar med en storslutsdataström när de sparar.

Implementera stöd för skapande och borttagning av namnområden genom att stödja uppsättnings- och borttagningsåtgärder för metadataobjekt med en typ av VT_CLSID (ett GUID) som motsvarar ett metadataformat. Metadataskrivaren anropar funktionen WICSerializeMetadataContent för att korrekt bädda in innehållet i den kapslade metadataskrivaren i den överordnade metadataskrivaren.

Om metadataformatet stöder kodning på plats ansvarar du för att hantera nödvändig utfyllnad. Mer information om kodning på plats finns i översikten över WIC-metadata och översikten över läsning och skrivning av bildmetadata.

IWICPersistStream-gränssnitt

Gränssnittet IWICPersistStream ärver från IPersistStream och innehåller ytterligare metoder för att spara och läsa in objekt med hjälp av WICPersistOptions uppräkning.

Följande kod visar definitionen av gränssnittet IWICPersistStream enligt definitionen i filen wincodecsdk.idl.

interface IWICPersistStream : IPersistStream
{
    HRESULT LoadEx(
        [in, unique] IStream *pIStream,
        [in, unique] const GUID *pguidPreferredVendor,
        [in] DWORD dwPersistOptions
        );

    HRESULT SaveEx(
        [in] IStream *pIStream,
        [in] DWORD dwPersistOptions,
        [in] BOOL fClearDirty
        );
};

Metoden LoadEx ger metadatahanteraren en dataström som innehåller metadatablocket.

Metoden SaveEx serialiserar metadata till en ström. Om den angivna strömmen är samma som initieringsströmmen bör du utföra kodning på plats. Om kodning på plats stöds bör den här metoden returnera WINCODEC_ERR_TOOMUCHMETADATA när det inte finns tillräckligt med utfyllnad för att utföra kodning på plats. Om kodning direkt på plats inte stöds bör den här metoden returnera WINCODEC_ERR_UNSUPPORTEDOPERATION.

Metoden IPersistStream::GetSizeMax måste implementeras och måste returnera den exakta storleken på metadatainnehållet som skulle skrivas i efterföljande sparande.

Metoden IPersistStream::IsDirty ska implementeras om metadataskrivaren initieras via en dataström, så att en bild på ett tillförlitligt sätt kan avgöra om innehållet har ändrats.

Om metadataformatet stöder kapslade metadatablock bör metadataskrivaren delegera serialiseringen av innehållet till kapslade metadataskrivare när det sparas i en ström.

IWICStreamProvider-gränssnitt

Implementeringen av IWICStreamProvider--gränssnittet för en metadataskrivare är detsamma som för en metadataläsare. Mer information finns i Avsnittet Skapa en metadataläsare i det här dokumentet.

Installera och registrera en metadatahanterare

Om du vill installera en metadatahanterare måste du ange hanterarens sammansättning och registrera den i systemregistret. Du kan bestämma hur och när registernycklarna ska fyllas i.

Registernycklar för metadatahanterare

Varje metadatahanterare identifieras av ett unikt CLSID och varje hanterare måste registrera sitt CLSID under metadatahanterarens kategori-ID GUID. Varje hanterartyps kategori-ID definieras i wincodec.idl. kategori-ID-namnet för läsare är CATID_WICMetadataReader och kategori-ID-namnet för författare är CATID_WICMetadataWriter.

Varje metadatahanterare identifieras av ett unikt CLSID och varje hanterare måste registrera sitt CLSID under metadatahanterarens kategori-ID GUID. Varje hanterartyps kategori-ID definieras i wincodec.idl. kategori-ID-namnet för läsare är CATID_WICMetadataReader och kategori-ID-namnet för författare är CATID_WICMetadataWriter.

Följande registernycklar registrerar din metadatahanterare hos de andra tillgängliga metadatahanterarna.

[HKEY_CLASSES_ROOT\CLSID\{CATID_WICMetadataReaders}\Instance\{Reader CLSID}]
CLSID={Reader CLSID}
Friendly Name="Reader Name"

[HKEY_CLASSES_ROOT\CLSID\{CATID_ WICMetadataWriters}\Instance\{Writer CLSID}]
CLSID={Writer CLSID}
Friendly Name="Writer Name"

Förutom att registrera dina hanterare i respektive kategori måste du också registrera ytterligare nycklar som ger information som är specifik för hanteraren. Läsare och författare delar liknande registernyckelkrav. Följande syntax visar hur du registrerar en hanterare. Både läsarhanterare och skriverhanterare måste registreras på det här sättet, med hjälp av deras respektive CLSID.

[HKEY_CLASSES_ROOT\CLSID\{CLSID}]
"Vendor"={VendorGUID}
"Date"="yyyy-mm-dd"
"Version"="Major.Minor.Build.Number"
"SpecVersion"="Major.Minor.Build.Number"
"MetadataFormat"={MetadataFormatGUID}
"RequiresFullStream"=dword:1|0
"SupportsPadding"= dword:1|0
"FixedSize"=0

[HKEY_CLASSES_ROOT\CLSID\{CLSID}\InProcServer32]
@="drive:\path\yourdll.dll"
"ThreadingModel"="Apartment"

[HKEY_CLASSES_ROOT\CLSID\{CLSID}\{LCID}]
Author="Author's Name"
Description = " Metadata Description"
DeviceManufacturer ="Manufacturer Name"
DeviceModels="Device,Device"
FriendlyName="Friendly Name"

Metadataläsare

Registreringen av metadataläsare innehåller även nycklar som beskriver hur läsaren kan bäddas in i ett containerformat. Ett containerformat kan vara ett bildformat som TIFF eller JPEG. Det kan också vara ett annat metadataformat, till exempel ett IFD-metadatablock. Avbildningscontainerformat som stöds internt visas i wincodec.idl; varje bildcontainerformat definieras som ett GUID med ett namn som börjar med GUID_ContainerFormat. Metadatacontainerformat som stöds internt visas i wincodecsdk.idl; varje metadatacontainerformat definieras som ett GUID med ett namn som börjar med GUID_MetadataFormat.

Följande nycklar registrerar en container som metadataläsaren stöder och de data som behövs för att läsa från containern. Varje container som stöds av läsaren måste registreras på det här sättet.

[HKEY_CLASSES_ROOT\CLSID\{Reader CLSID}\Containers\{Container GUID}\0]
"Position"=dword:00000000
"Pattern"=hex:ff,ff,ff,...
"Mask"=hex:ff,ff,ff,...
"DataOffset"=dword:00000006

Mönsternyckeln beskriver det binära mönster som används för att matcha metadatablocket med läsaren. När du definierar ett mönster för metadataläsaren bör det vara tillräckligt tillförlitligt att en positiv matchning innebär att metadataläsaren kan förstå metadata i metadatablocket som bearbetas.

Nyckeln DataOffset beskriver den fasta förskjutningen av metadata från blockrubriken. Den här nyckeln är valfri, och om den inte anges innebär det att de faktiska metadata inte kan hittas med en fast förskjutning från blockrubriken.

Metadataförfattare

Registreringen av metadataskrivare innehåller även nycklar som beskriver hur du skriver ut rubriken före metadatainnehållet som är inbäddat i ett containerformat. Precis som med läsaren kan ett containerformat vara ett bildformat eller ett annat metadatablock.

Följande nycklar registrerar en container som stöds av metadataskrivaren, samt specificerar den data som behövs för att skriva både huvudet och metadata. Varje container som stöds av författaren måste registreras på det här sättet.

[HKEY_CLASSES_ROOT\CLSID\{Writer CLSID}\Containers\{Container GUID}]
"WritePosition"=dword:00000000
"WriteHeader"=hex:ff,ff,ff,...
"WriteOffset"=dword:00000000

WriteHeader-nyckeln beskriver det binära mönstret för metadatablockrubriken som ska skrivas. Det här binära mönstret sammanfaller med metadataformatets läsmönsternyckel.

Nyckeln WriteOffset beskriver den fasta förskjutningen från blockrubriken där metadata ska skrivas. Den här nyckeln är valfri och innebär, om den inte anges, att de faktiska metadata inte ska skrivas ut med rubriken.

Signera en metadatahanterare

Alla metadatahanterare måste vara digitalt signerade för att kunna delta i WIC-identifieringsprocessen. WIC läser inte in någon hanterare som inte är signerad av en betrodd certifikatutfärdare. Mer information om digital signering finns i Introduktion till kodsignering.

Särskilda överväganden

Följande avsnitt innehåller ytterligare information som du måste tänka på när du skapar dina egna metadatahanterare.

PROPVARIANTS

WIC använder en PROPVARIANT- för att representera ett metadataobjekt för både läsning och skrivning. En PROPVARIANT tillhandahåller en datatyp och ett datavärde för ett metadataobjekt som används i ett metadataformat. Som skrivare för en metadatahanterare har du stor flexibilitet när det gäller hur data lagras i metadataformatet och hur data representeras i ett metadatablock. Följande tabell innehåller riktlinjer som hjälper dig att bestämma vilken PROPVARIANT-typ som ska användas i olika situationer.

Använd inte säkra matriser för att undvika redundans i att representera matrisobjekt. använd endast enkla matriser. Detta minskar det arbete som ett program behöver utföra vid tolkning av PROPVARIANT- typer.

Undvik att använda VT_BYREF och lagra värden direkt i koden när det är möjligt. VT_BYREF är ineffektivt för små typer (vanligt för metadataobjekt) och ger inte storleksinformation.

Innan du använder en PROPVARIANT-anropar du alltid PropVariantInit för att initiera värdet. När du är klar med PROPVARIANT anropar du alltid PropVariantClear för att frigöra allt minne som allokerats för variabeln.

8BIM-hanterare

När du skriver en metadatahanterare för ett 8BIM-metadatablock måste du använda en signatur som kapslar in både 8BIM-signaturen och ID:t. Till exempel innehåller den inbyggda 8BIMIPTC-metadataläsaren följande registerinformation för identifiering av läsare:

[HKEY_CLASSES_ROOT\CLSID\{0010668C-0801-4DA6-A4A4-826522B6D28F}\Containers\{16100D66-8570-4BB9-B92D-FDA4B23ECE67}\0]
"Position"=dword:00000000
"Pattern"=hex:38,42,49,4d,04,04
"Mask"=hex:ff,ff,ff,ff,ff,ff
"DataOffset"=dword:00000006

8BIMIPTC-läsaren har ett registrerat mönster med 0x38, 0x42, 0x49, 0x4D, 0x04, 0x04. De första fyra byteen (0x38, 0x42, 0x49, 0x4D) är 8BIM-signaturen och de två sista byteen (0x04 0x04) är ID:t för IPTC-posten.

För att kunna skriva en 8BIM-metadataläsare för matchningsinformation behöver du därför ett registrerat mönster med 0x38, 0x42, 0x49, 0x4D, 0x03 0xED. Återigen är de första fyra byteen (0x38, 0x42, 0x49, 0x4D) 8BIM-signaturen. De två sista byteen (0x03, 0xED) är dock matchningsinformations-ID:t enligt PSD-formatet.

Relaterade ämnen

konceptuell

Översikt över Windows Imaging-komponenten

Översikt över WIC-metadata

Översikt över frågespråk för metadata

Översikt över läsande och skrivande av bildmetadata

Instruktioner: Koda om en JPEG-bild med metadata

andra resurser

Så här skriver du en WIC-Enabled CODEC-