Empty XMP error when saving modified XMP metadata

[markolbert]

I'm writing a library to edit keyword metadata information in various image file types. It currently fails when adding new keywords to PNG files.

The general outline of my editing process is:

• load the PNG image file
• get an XDocument from the XmpProfile in the image
• add new rdf:li elements to the dc:subject element with the new keywords
• save the modified XDocument to a MemoryStream
• convert the MemoryStream to a byte array
• create a new XmpProfile from the byte array and assign it to the image's Metadata.XmpProfile property

Here is the part of my code which "appends" the new keywords and then creates a new XmProfile from the revised XDocument (which was obtained from the image after I loaded it):

// remove the existing rdf:li elements
bagElement.Descendants(XmpSupport.LineElementName).Remove();

// create new elements, one for each keyword
var keywordElements = toAdd.Select(k => new XElement(XmpSupport.LineElementName) { Value = k })
                           .Cast<object>()
                           .ToArray();

// add the newly-created keyword elements to the keyword container
bagElement.Add(keywordElements);

// save the modified XDocument to a MemoryStream
using var ms = new MemoryStream();
xDoc.Save( ms, SaveOptions.DisableFormatting );

// get a byte array from the MemoryStream
var byteArray = ms.ToArray();

// create a new XmpProfile and assign it to the image
image.Metadata.XmpProfile = new XmpProfile(byteArray);

Unfortunately, when I use exiftool to check that the additions were made, it reports that the Xmp metadata is empty/invalid. Interestingly, Adobe Bridge successfully reads the "empty/invalid" keyword data.

I compared the XDocument from the original file to one I derived from the revised one by reloading the image file after first saving it to disk with the revised Xmp data. In comparing the two XDocuments, the only obvious difference (other than the addition of some new rdf:li elements) is that the one derived from the revised image file has the following first line:

<?xml version="1.0" encoding="utf-8"?>

I'm not sure, but this looks like a byte order mark followed by a "default" xml version/encoding element. It's not something that I added to the XDocument before I generated a new XmpProfile from it.

Is this something that gets added to the XDocument when a new profile is assigned to Metadata.XmpProfile? If so, is there a way to prevent the addition? Or is there a better way to save a revised Xmp XDocument to the image?

[JimBobSquarePants]

How are you saving the doc to disk? Using StreamWriter?

[markolbert]

No, I'm using the image SaveAsync() method:

await image.SaveAsync(filePath, ctx);

which succeeds with no problem (it's wrapped inside a try/catch block).

[markolbert]

I hesitated to include all the code in my initial post because it's fairly long. But in case it's useful...

Outermost method, calls AddSetKeywordsAsync():

public async Task<bool> AddKeywordsAsync(
    string filePath,
    HashSet<string> keywords,
    CancellationToken ctx = default
)
{
    if (keywords.All(string.IsNullOrEmpty))
        return true;

    var exInfo = GetSupportInfo(filePath);
    if( exInfo != null )
        return await AddSetKeywordsAsync( filePath, keywords, exInfo.SupportedVaults, true, ctx );

    Logger?.UnsupportedImageFile(filePath);
    return false;
}

General add/set method, calls methods to set IPTC and XMP keywords separately.

private async Task<bool> AddSetKeywordsAsync(
    string filePath,
    HashSet<string> keywords,
    HashSet<KeywordVault> keywordVaults,
    bool appendKeywords,
    CancellationToken ctx = default
)
{
    var extInfo = GetSupportInfo( filePath );

    try
    {
        using var image = await Image.LoadAsync( filePath, ctx );

        var allOkay = true;

        foreach (var keywordVault in keywordVaults)
        {
            var result = keywordVault switch
            {
                KeywordVault.Iptc => AddSetIptcKeywords(image, keywords, appendKeywords, filePath),
                KeywordVault.Xmp => await AddSetXmpKeywordsAsync(image, keywords, appendKeywords, filePath, ctx),
                _ => false
            };

            if (!result)
                Logger?.UnsupportedKeywordVault(keywordVault, filePath);

            allOkay &= result;
        }

        if (!allOkay)
            return false;

        await image.SaveAsync(filePath, ctx);
    }
    catch ( Exception ex )
    {
        Logger?.WriteMetadataFailed( filePath, ex.Message );
        return false;
    }

    return true;
}

Sets the XMP keywords

private async Task<bool> AddSetXmpKeywordsAsync(
    Image image,
    HashSet<string> keywords,
    bool appendKeywords,
    string filePath,
    CancellationToken ctx
)
{
    var xmpProfile = image.Metadata.XmpProfile;
    // not including source to CreateXmpDocument() since it doesn't get called
    // in the situation where the problem occurs (the image file already contains
    // an XMP XML document)
    var xDoc = xmpProfile?.GetDocument() ?? await CreateXmpDocument(ctx);

    if (xDoc == null)
    {
        Logger?.NullXmpXDocument(filePath);
        return false;
    }

    var bagElement = GetBagElement(xDoc);

    // ensure we're case-insensitive
    var toAdd = new HashSet<string>(keywords, StringComparer.OrdinalIgnoreCase);

    try
    {
        // add the existing keywords to what we're going to add if we're
        // appending, and then remove all the existing keywords from the
        // profile so we don't create duplicates
        if (appendKeywords)
        {
            toAdd.UnionWith(bagElement.Descendants()
                                       .Where(e => e.Name == XmpSupport.LineElementName)
                                       .Select(e => e.Value));
        }

        bagElement.Descendants(XmpSupport.LineElementName).Remove();

        var keywordElements = toAdd.Select(k => new XElement(XmpSupport.LineElementName) { Value = k })
                                   .Cast<object>()
                                   .ToArray();

        bagElement.Add(keywordElements);

        using var ms = new MemoryStream();
        xDoc.Save( ms );

        image.Metadata.XmpProfile = new XmpProfile( ms.ToArray() );
    }
    catch (Exception ex)
    {
        Logger?.AddXmpKeywordsFailed(filePath, ex.Message);
        return false;
    }

    return true;
}

Gets or creates the Bag element in the XML document which contains the keyword elements

private static XElement GetBagElement(XDocument xDoc)
{
    var subjectElement = xDoc.Descendants(XmpSupport.SubjectElementName).FirstOrDefault();

    if (subjectElement == null)
    {
        subjectElement = new XElement(XmpSupport.SubjectElementName);
        xDoc.Add(subjectElement);
    }

    var retVal = subjectElement.Descendants(XmpSupport.BagElementName).FirstOrDefault();

    if (retVal != null)
        return retVal;

    retVal = new XElement(XmpSupport.BagElementName);
    subjectElement.Add(retVal);

    return retVal;
}

[JimBobSquarePants]

Sorry, I meant how are you saving the updated document. I think you would need to use something like this.

using System.Text;
using System.Xml;
using System.Xml.Linq;

// xDoc is the modified XDocument
byte[] bytes;
using (var ms = new MemoryStream())
{
    var settings = new XmlWriterSettings
    {
        Encoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false), // no BOM
        OmitXmlDeclaration = true, // optional but usually helps with XMP consumers
        Indent = false,
        NewLineHandling = NewLineHandling.None
    };

    using (var xw = XmlWriter.Create(ms, settings))
    {
        xDoc.Save(xw);
    }

    bytes = ms.ToArray();
}

[markolbert]

That was it! Thanx!

[JimBobSquarePants]

Ace. I’ll update the profile type in V4 to add a constructor taking the document. This will make it a lot easier as I can normalize for you and others.