[EXIF] Support UCS2 and 8-byte encoded string tags

src/ImageSharp/ImageSharp.csproj

@@ -49,6 +49,7 @@
 
   <ItemGroup>
     <PackageReference Include="System.Runtime.CompilerServices.Unsafe" Version="5.0.0" />
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup Condition=" $(TargetFramework.StartsWith('netstandard')) OR '$(TargetFramework)' == 'net472'">

src/ImageSharp/Metadata/Profiles/Exif/ExifConstants.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0.
 
 using System;
+using System.Text;
 
 namespace SixLabors.ImageSharp.Metadata.Profiles.Exif
 {
@@ -22,5 +23,8 @@ internal static class ExifConstants
             0x00,
             0x2A
         };
+
+        // UTF-8 is better than ASCII, UTF-8 encodes the ASCII codes the same way
+        public static Encoding DefaultEncoding => Encoding.UTF8;
     }
 }

src/ImageSharp/Metadata/Profiles/Exif/ExifEncodedStringHelpers.cs

@@ -0,0 +1,121 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Buffers.Binary;
+using System.Text;
+using static SixLabors.ImageSharp.Metadata.Profiles.Exif.EncodedString;
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Exif
+{
+    internal static class ExifEncodedStringHelpers
+    {
+        public const int CharacterCodeBytesLength = 8;
+
+        private const ulong AsciiCode = 0x_00_00_00_49_49_43_53_41;
+        private const ulong JISCode = 0x_00_00_00_00_00_53_49_4A;
+        private const ulong UnicodeCode = 0x_45_44_4F_43_49_4E_55;
+        private const ulong UndefinedCode = 0x_00_00_00_00_00_00_00_00;
+
+        private static ReadOnlySpan<byte> AsciiCodeBytes => new byte[] { 0x41, 0x53, 0x43, 0x49, 0x49, 0, 0, 0 };
+
+        private static ReadOnlySpan<byte> JISCodeBytes => new byte[] { 0x4A, 0x49, 0x53, 0, 0, 0, 0, 0 };
+
+        private static ReadOnlySpan<byte> UnicodeCodeBytes => new byte[] { 0x55, 0x4E, 0x49, 0x43, 0x4F, 0x44, 0x45, 0 };
+
+        private static ReadOnlySpan<byte> UndefinedCodeBytes => new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+        // 20932 EUC-JP Japanese (JIS 0208-1990 and 0212-1990)
+        // https://docs.microsoft.com/en-us/dotnet/api/system.text.encoding?view=net-6.0
+        private static Encoding JIS0208Encoding => CodePagesEncodingProvider.Instance.GetEncoding(20932);
+
+        public static bool IsEncodedString(ExifTagValue tag) => tag switch
+        {
+            ExifTagValue.UserComment or ExifTagValue.GPSProcessingMethod or ExifTagValue.GPSAreaInformation => true,
+            _ => false
+        };
+
+        public static ReadOnlySpan<byte> GetCodeBytes(CharacterCode code) => code switch
+        {
+            CharacterCode.ASCII => AsciiCodeBytes,
+            CharacterCode.JIS => JISCodeBytes,
+            CharacterCode.Unicode => UnicodeCodeBytes,
+            CharacterCode.Undefined => UndefinedCodeBytes,
+            _ => UndefinedCodeBytes
+        };
+
+        public static Encoding GetEncoding(CharacterCode code) => code switch
+        {
+            CharacterCode.ASCII => Encoding.ASCII,
+            CharacterCode.JIS => JIS0208Encoding,
+            CharacterCode.Unicode => Encoding.Unicode,
+            CharacterCode.Undefined => Encoding.UTF8,
+            _ => Encoding.UTF8
+        };
+
+        public static bool TryParse(ReadOnlySpan<byte> buffer, out EncodedString encodedString)
+        {
+            if (TryDetect(buffer, out CharacterCode code))
+            {
+                string text = GetEncoding(code).GetString(buffer.Slice(CharacterCodeBytesLength));
+                encodedString = new EncodedString(code, text);
+                return true;
+            }
+
+            encodedString = default;
+            return false;
+        }
+
+        public static uint GetDataLength(EncodedString encodedString) =>
+            (uint)GetEncoding(encodedString.Code).GetByteCount(encodedString.Text) + CharacterCodeBytesLength;
+
+        public static int Write(EncodedString encodedString, Span<byte> destination)
+        {
+            GetCodeBytes(encodedString.Code).CopyTo(destination);
+
+            string text = encodedString.Text;
+            int count = Write(GetEncoding(encodedString.Code), text, destination.Slice(CharacterCodeBytesLength));
+
+            return CharacterCodeBytesLength + count;
+        }
+
+        public static unsafe int Write(Encoding encoding, string value, Span<byte> destination)
+        {
+            fixed (char* c = value)
+            {
+                fixed (byte* b = destination)
+                {
+                    return encoding.GetBytes(c, value.Length, b, destination.Length);
+                }
+            }
+        }
+
+        private static bool TryDetect(ReadOnlySpan<byte> buffer, out CharacterCode code)
+        {
+            if (buffer.Length >= CharacterCodeBytesLength)
+            {
+                ulong test = BinaryPrimitives.ReadUInt64LittleEndian(buffer);
+                switch (test)
+                {
+                    case AsciiCode:
+                        code = CharacterCode.ASCII;
+                        return true;
+                    case JISCode:
+                        code = CharacterCode.JIS;
+                        return true;
+                    case UnicodeCode:
+                        code = CharacterCode.Unicode;
+                        return true;
+                    case UndefinedCode:
+                        code = CharacterCode.Undefined;
+                        return true;
+                    default:
+                        break;
+                }
+            }
+
+            code = default;
+            return false;
+        }
+    }
+}

src/ImageSharp/Metadata/Profiles/Exif/ExifReader.cs

@@ -241,9 +241,7 @@ private static TDataType[] ToArray<TDataType>(ExifDataType dataType, ReadOnlySpa
             return result;
         }
 
-        private byte ConvertToByte(ReadOnlySpan<byte> buffer) => buffer[0];
-
-        private string ConvertToString(ReadOnlySpan<byte> buffer)
+        private static string ConvertToString(Encoding encoding, ReadOnlySpan<byte> buffer)
         {
             int nullCharIndex = buffer.IndexOf((byte)0);
 
@@ -252,9 +250,11 @@ private string ConvertToString(ReadOnlySpan<byte> buffer)
                 buffer = buffer.Slice(0, nullCharIndex);
             }
 
-            return Encoding.UTF8.GetString(buffer);
+            return encoding.GetString(buffer);
         }
 
+        private byte ConvertToByte(ReadOnlySpan<byte> buffer) => buffer[0];
+
         private object ConvertValue(ExifDataType dataType, ReadOnlySpan<byte> buffer, bool isArray)
         {
             if (buffer.Length == 0)
@@ -267,8 +267,9 @@ private object ConvertValue(ExifDataType dataType, ReadOnlySpan<byte> buffer, bo
                 case ExifDataType.Unknown:
                     return null;
                 case ExifDataType.Ascii:
-                    return this.ConvertToString(buffer);
+                    return ConvertToString(ExifConstants.DefaultEncoding, buffer);
                 case ExifDataType.Byte:
+                case ExifDataType.Undefined:
                     if (!isArray)
                     {
                         return this.ConvertToByte(buffer);
@@ -354,13 +355,7 @@ private object ConvertValue(ExifDataType dataType, ReadOnlySpan<byte> buffer, bo
                     }
 
                     return ToArray(dataType, buffer, this.ConvertToUInt64);
-                case ExifDataType.Undefined:
-                    if (!isArray)
-                    {
-                        return this.ConvertToByte(buffer);
-                    }
 
-                    return buffer.ToArray();
                 default:
                     throw new NotSupportedException($"Data type {dataType} is not supported.");
             }
@@ -453,7 +448,7 @@ private void ReadValue64(List<IExifValue> values, Span<byte> offsetBuffer)
             // Likewise, tags that point to other IFDs, like e.g. the SubIFDs tag, are now allowed to have the datatype TIFF_IFD8 in BigTIFF.
             // Again, the old datatypes TIFF_IFD, and the hardly recommendable TIFF_LONG, are still valid, too.
             // https://www.awaresystems.be/imaging/tiff/bigtiff.html
-            ExifValue exifValue = null;
+            ExifValue exifValue;
             switch (tag)
             {
                 case ExifTagValue.StripOffsets:

src/ImageSharp/Metadata/Profiles/Exif/ExifUcs2StringHelpers.cs

@@ -0,0 +1,21 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+using System;
+using System.Text;
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Exif
+{
+    internal static class ExifUcs2StringHelpers
+    {
+        public static Encoding Ucs2Encoding => Encoding.GetEncoding("UCS-2");
+
+        public static bool IsUcs2Tag(ExifTagValue tag) => tag switch
+        {
+            ExifTagValue.XPAuthor or ExifTagValue.XPComment or ExifTagValue.XPKeywords or ExifTagValue.XPSubject or ExifTagValue.XPTitle => true,
+            _ => false,
+        };
+
+        public static int Write(string value, Span<byte> destination) => ExifEncodedStringHelpers.Write(Ucs2Encoding, value, destination);
+    }
+}

src/ImageSharp/Metadata/Profiles/Exif/ExifWriter.cs

@@ -4,7 +4,6 @@
 using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
-using System.Text;
 
 namespace SixLabors.ImageSharp.Metadata.Profiles.Exif
 {
@@ -274,9 +273,19 @@ internal static uint GetNumberOfComponents(IExifValue exifValue)
         {
             object value = exifValue.GetValue();
 
+            if (ExifUcs2StringHelpers.IsUcs2Tag((ExifTagValue)(ushort)exifValue.Tag))
+            {
+                return (uint)ExifUcs2StringHelpers.Ucs2Encoding.GetByteCount((string)value);
+            }
+
+            if (value is EncodedString encodedString)
+            {
+                return ExifEncodedStringHelpers.GetDataLength(encodedString);
+            }
+
             if (exifValue.DataType == ExifDataType.Ascii)
             {
-                return (uint)Encoding.UTF8.GetBytes((string)value).Length + 1;
+                return (uint)ExifConstants.DefaultEncoding.GetByteCount((string)value) + 1;
             }
 
             if (value is Array arrayValue)
@@ -289,11 +298,6 @@ internal static uint GetNumberOfComponents(IExifValue exifValue)
 
         private static int WriteArray(IExifValue value, Span<byte> destination, int offset)
         {
-            if (value.DataType == ExifDataType.Ascii)
-            {
-                return WriteValue(ExifDataType.Ascii, value.GetValue(), destination, offset);
-            }
-
             int newOffset = offset;
             foreach (object obj in (Array)value.GetValue())
             {
@@ -378,7 +382,7 @@ private static int WriteValue(ExifDataType dataType, object value, Span<byte> de
             switch (dataType)
             {
                 case ExifDataType.Ascii:
-                    offset = Write(Encoding.UTF8.GetBytes((string)value), destination, offset);
+                    offset = Write(ExifConstants.DefaultEncoding.GetBytes((string)value), destination, offset);
                     destination[offset] = 0;
                     return offset + 1;
                 case ExifDataType.Byte:
@@ -425,14 +429,25 @@ private static int WriteValue(ExifDataType dataType, object value, Span<byte> de
             }
         }
 
-        internal static int WriteValue(IExifValue value, Span<byte> destination, int offset)
+        internal static int WriteValue(IExifValue exifValue, Span<byte> destination, int offset)
         {
-            if (value.IsArray && value.DataType != ExifDataType.Ascii)
+            object value = exifValue.GetValue();
+
+            if (ExifUcs2StringHelpers.IsUcs2Tag((ExifTagValue)(ushort)exifValue.Tag))
+            {
+                return offset + ExifUcs2StringHelpers.Write((string)value, destination.Slice(offset));
+            }
+            else if (value is EncodedString encodedString)
+            {
+                return offset + ExifEncodedStringHelpers.Write(encodedString, destination.Slice(offset));
+            }
+
+            if (exifValue.IsArray)
             {
-                return WriteArray(value, destination, offset);
+                return WriteArray(exifValue, destination, offset);
             }
 
-            return WriteValue(value.DataType, value.GetValue(), destination, offset);
+            return WriteValue(exifValue.DataType, value, destination, offset);
         }
     }
 }

src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.ByteArray.cs

@@ -41,31 +41,6 @@ public abstract partial class ExifTag
         /// </summary>
         public static ExifTag<byte[]> TIFFEPStandardID => new ExifTag<byte[]>(ExifTagValue.TIFFEPStandardID);
 
-        /// <summary>
-        /// Gets the XPTitle exif tag.
-        /// </summary>
-        public static ExifTag<byte[]> XPTitle => new ExifTag<byte[]>(ExifTagValue.XPTitle);
-
-        /// <summary>
-        /// Gets the XPComment exif tag.
-        /// </summary>
-        public static ExifTag<byte[]> XPComment => new ExifTag<byte[]>(ExifTagValue.XPComment);
-
-        /// <summary>
-        /// Gets the XPAuthor exif tag.
-        /// </summary>
-        public static ExifTag<byte[]> XPAuthor => new ExifTag<byte[]>(ExifTagValue.XPAuthor);
-
-        /// <summary>
-        /// Gets the XPKeywords exif tag.
-        /// </summary>
-        public static ExifTag<byte[]> XPKeywords => new ExifTag<byte[]>(ExifTagValue.XPKeywords);
-
-        /// <summary>
-        /// Gets the XPSubject exif tag.
-        /// </summary>
-        public static ExifTag<byte[]> XPSubject => new ExifTag<byte[]>(ExifTagValue.XPSubject);
-
         /// <summary>
         /// Gets the GPSVersionID exif tag.
         /// </summary>

src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.EncodedString.cs

@@ -0,0 +1,24 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Exif
+{
+    /// <content/>
+    public abstract partial class ExifTag
+    {
+        /// <summary>
+        /// Gets the UserComment exif tag.
+        /// </summary>
+        public static ExifTag<EncodedString> UserComment { get; } = new ExifTag<EncodedString>(ExifTagValue.UserComment);
+
+        /// <summary>
+        /// Gets the GPSProcessingMethod exif tag.
+        /// </summary>
+        public static ExifTag<EncodedString> GPSProcessingMethod { get; } = new ExifTag<EncodedString>(ExifTagValue.GPSProcessingMethod);
+
+        /// <summary>
+        /// Gets the GPSAreaInformation exif tag.
+        /// </summary>
+        public static ExifTag<EncodedString> GPSAreaInformation { get; } = new ExifTag<EncodedString>(ExifTagValue.GPSAreaInformation);
+    }
+}

src/ImageSharp/Metadata/Profiles/Exif/Tags/ExifTag.Ucs2String.cs

@@ -0,0 +1,34 @@
+// Copyright (c) Six Labors.
+// Licensed under the Apache License, Version 2.0.
+
+namespace SixLabors.ImageSharp.Metadata.Profiles.Exif
+{
+    /// <content/>
+    public abstract partial class ExifTag
+    {
+        /// <summary>
+        /// Gets the title tag used by Windows (encoded in UCS2).
+        /// </summary>
+        public static ExifTag<string> XPTitle => new ExifTag<string>(ExifTagValue.XPTitle);
+
+        /// <summary>
+        /// Gets the comment tag used by Windows (encoded in UCS2).
+        /// </summary>
+        public static ExifTag<string> XPComment => new ExifTag<string>(ExifTagValue.XPComment);
+
+        /// <summary>
+        /// Gets the author tag used by Windows (encoded in UCS2).
+        /// </summary>
+        public static ExifTag<string> XPAuthor => new ExifTag<string>(ExifTagValue.XPAuthor);
+
+        /// <summary>
+        /// Gets the keywords tag used by Windows (encoded in UCS2).
+        /// </summary>
+        public static ExifTag<string> XPKeywords => new ExifTag<string>(ExifTagValue.XPKeywords);
+
+        /// <summary>
+        /// Gets the subject tag used by Windows (encoded in UCS2).
+        /// </summary>
+        public static ExifTag<string> XPSubject => new ExifTag<string>(ExifTagValue.XPSubject);
+    }
+}