C# 编辑png元数据，添加itxt值

我正在尝试创建一个函数，将一个PNG从URL加载到内存中，然后添加一个带有关键字“openbadges”和一些json数据的iTXt块。除了执行任务外，我的每一部分都在工作

metadata.SetQuery("/iTXt/openbadges", "");

我得到一个例外：

Value does not fall within the expected range.

以下是函数：

private static byte[] CreateOpenBadge(BadgeAssertionEntity assertion)
{
    using (var image = LoadImage(new Uri(assertion.Badge.ImageUrl)))
    using (var imageStream = new MemoryStream())
    {
        image.Save(imageStream, ImageFormat.Png);

        var pngDecoder = new PngBitmapDecoder(imageStream, BitmapCreateOptions.PreservePixelFormat, BitmapCacheOption.Default);

        using (var badgeStream = new MemoryStream())
        {
            var pngEncoder = new PngBitmapEncoder();

            pngEncoder.Frames.Add(BitmapFrame.Create(pngDecoder.Frames[0]));

            var metadata = pngEncoder.Frames[0].Metadata as BitmapMetadata;

            if (metadata == null)
                throw new ApplicationException();

            metadata.SetQuery("/iTXt/openbadges", "");

            pngEncoder.Save(badgeStream);

            return badgeStream.ToArray();
        }
    }
}

---

知道我做错了什么吗？

我放弃了使用PngBitmapEncoder。相反，我将直接修改png字节。我已经附加了一个我为这个目的制作的类，以防其他人发现它有用

本课程深受AShelly在

我还使用crc哈希

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Text;

using Badger.Libraries.Hashing;

namespace Badger.Libraries.Images
{
    public class Png
    {
        private readonly byte[] _header;
        private readonly IList<Chunk> _chunks;

        public Png(Uri imageUri)
        {
            _header = new byte[8];
            _chunks = new List<Chunk>();

            var webResponse = WebRequest.Create(imageUri).GetResponse();

            using (var webResponseStream = webResponse.GetResponseStream())
            using (var memoryStream = new MemoryStream())
            {
                if (webResponseStream == null)
                    throw new ArgumentException("invalid uri");

                webResponseStream.CopyTo(memoryStream);

                memoryStream.Seek(0, SeekOrigin.Begin);

                memoryStream.Read(_header, 0, _header.Length);

                while (memoryStream.Position < memoryStream.Length)
                    _chunks.Add(ChunkFromStream(memoryStream));

                memoryStream.Close();
            }
        }

        public void AddInternationalText(string keyword, string text)
        {
            // 1-79     (keyword)
            // 1        (null character)
            // 1        (compression flag)
            // 1        (compression method)
            // 0+       (language)
            // 1        (null character)
            // 0+       (translated keyword)
            // 1        (null character)
            // 0+       (text)

            var typeBytes = Encoding.UTF8.GetBytes("iTXt");
            var keywordBytes = Encoding.UTF8.GetBytes(keyword);
            var textBytes = Encoding.UTF8.GetBytes(text);
            var nullByte = BitConverter.GetBytes('\0')[0];
            var zeroByte = BitConverter.GetBytes(0)[0];

            var data = new List<byte>();

            data.AddRange(keywordBytes);
            data.Add(nullByte);
            data.Add(zeroByte);
            data.Add(zeroByte);
            data.Add(nullByte);
            data.Add(nullByte);
            data.AddRange(textBytes);

            var chunk = new Chunk(typeBytes, data.ToArray());

            _chunks.Insert(1, chunk);
        }

        public byte[] ToBytes()
        {
            using (var stream = new MemoryStream())
            {
                stream.Write(_header, 0, _header.Length);

                foreach (var chunk in _chunks)
                    chunk.WriteToStream(stream);

                var bytes = stream.ToArray();

                stream.Close();

                return bytes;
            }
        }

        private static Chunk ChunkFromStream(Stream stream)
        {
            var length = ReadBytes(stream, 4);
            var type = ReadBytes(stream, 4);
            var data = ReadBytes(stream, Convert.ToInt32(BitConverter.ToUInt32(length.Reverse().ToArray(), 0)));

            stream.Seek(4, SeekOrigin.Current);

            return new Chunk(type, data);
        }

        private static byte[] ReadBytes(Stream stream, int n)
        {
            var buffer = new byte[n];
            stream.Read(buffer, 0, n);
            return buffer;
        }

        private static void WriteBytes(Stream stream, byte[] bytes)
        {
            stream.Write(bytes, 0, bytes.Length);
        }

        private class Chunk
        {
            public Chunk(byte[] type, byte[] data)
            {
                _type = type;
                _data = data;
            }

            public void WriteToStream(Stream stream)
            {
                WriteBytes(stream, BitConverter.GetBytes(Convert.ToUInt32(_data.Length)).Reverse().ToArray());
                WriteBytes(stream, _type);
                WriteBytes(stream, _data);
                WriteBytes(stream, CalculateCrc(_type, _data));
            }

            private static byte[] CalculateCrc(IEnumerable<byte> type, IEnumerable<byte> data)
            {
                var bytes = new List<byte>();

                bytes.AddRange(type);
                bytes.AddRange(data);

                var hasher = new Crc32();

                using (var stream = new MemoryStream(bytes.ToArray()))
                    return hasher.ComputeHash(stream);
            }

            private readonly byte[] _type;
            private readonly byte[] _data;
        }
    }
}

使用系统；
使用System.Collections.Generic；
使用System.IO；
使用System.Linq；
Net系统；
使用系统文本；
使用Badger.Libraries.Hashing；
名称空间Badger.Libraries.Images
{
公共类Png
{
专用只读字节[]_头；
私有只读IList_块；
公共Png（Uri imageUri）
{
_头=新字节[8]；
_chunks=新列表（）；
var webResponse=WebRequest.Create（imageUri.GetResponse（）；
使用（var webResponseStream=webResponse.GetResponseStream（））
使用（var memoryStream=new memoryStream（））
{
如果（webResponseStream==null）
抛出新ArgumentException（“无效uri”）；
webResponseStream.CopyTo（memoryStream）；
memoryStream.Seek（0，SeekOrigin.Begin）；
memoryStream.Read（_header，0，_header.Length）；
while（memoryStream.Position

诀窍是设置query（）“/iTXt/Keyword”和“/iTXt/TextEntry”，但必须使用字符[]作为关键字的值

这是因为内部“/iTXt/Keyword”需要一个VT_LPSTR作为值类型，只有char[]才能正确转换为该值类型

下面是一个使用WIC编写棋盘png的示例，其中包括一些iTXt元数据

using System.IO;
using System.Windows;
using System.Windows.Media;
using System.Windows.Media.Imaging;

namespace PNGEncoder
{
    class Program
    {
        static void Main(string[] args)
        {
            var width = 256;
            var height = 256;

            var pngMetadata = new BitmapMetadata("png");

            pngMetadata.SetQuery("/iTXt/Keyword", "keyword0".ToCharArray());
            pngMetadata.SetQuery("/iTXt/TextEntry", "textentry0");

            pngMetadata.SetQuery("/[1]iTXt/Keyword", "keyword1".ToCharArray());
            pngMetadata.SetQuery("/[1]iTXt/TextEntry", "textentry1");

            var bitmap = new WriteableBitmap(width, height, 96, 96, PixelFormats.Gray8, null);

            var pixels = new byte[width * height];
            for (var y = 0; y < height; y++)
            {
                for (var x = 0; x < width; x++)
                {
                    pixels[y * width + x] = (byte)(255 * (((x >> 4) ^ (y >> 4)) & 1));
                }
            }

            bitmap.WritePixels(new Int32Rect(0, 0, width, height), pixels, width, 0);

            var encoder = new PngBitmapEncoder();
            encoder.Frames.Add(BitmapFrame.Create(bitmap, null, pngMetadata, null));

            using (var stream = File.Create("checkerBoard.png"))
            {
                encoder.Save(stream);
            }
        }
    }
}

使用System.IO；
使用System.Windows；
使用System.Windows.Media；
使用System.Windows.Media.Imaging；
命名空间PNGEncoder
{
班级计划
{
静态void Main（字符串[]参数）
{
变量宽度=256；
变量高度=256；
var pngMetadata=新的位图元数据（“png”）；
pngMetadata.SetQuery（“/iTXt/Keyword”，“keyword0.tocharray（））；
pngMetadata.SetQuery（“/iTXt/TextEntry”，“textentry0”）；
pngMetadata.SetQuery（“/[1]iTXt/Keyword”，“keyword1.tocharray（））；
pngMetadata.Set