correct reading UCS-2 encoded string tags

Author: IldarKhayrutdinov

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

@@ -27,34 +27,6 @@ internal static class ExifEncodedStringHelpers
 
         private static Encoding JIS0208Encoding => Encoding.GetEncoding(932);
 
-        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;
-        }
-
         public static ReadOnlySpan<byte> GetCodeBytes(CharacterCode code) => code switch
         {
             CharacterCode.ASCII => AsciiCodeBytes,
@@ -88,5 +60,46 @@ public static bool TryCreate(ReadOnlySpan<byte> buffer, out EncodedString encode
 
         public static uint GetDataLength(EncodedString encodedString) =>
             (uint)GetEncoding(encodedString.Code).GetByteCount(encodedString.Text) + CharacterCodeBytesLength;
+
+        public static bool IsEncodedString(ExifTagValue tag)
+        {
+            switch (tag)
+            {
+                case ExifTagValue.UserComment:
+                case ExifTagValue.GPSProcessingMethod:
+                case ExifTagValue.GPSAreaInformation:
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        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

@@ -219,7 +219,7 @@ protected void ReadBigValue(IList<IExifValue> values, (ulong Offset, ExifDataTyp
             this.Seek(tag.Offset);
             if (this.TryReadSpan(buffer))
             {
-                object value = this.ConvertValue(tag.DataType, buffer, tag.NumberOfComponents > 1 || tag.Exif.IsArray);
+                object value = this.ConvertValue(tag.Exif, tag.DataType, buffer, tag.NumberOfComponents > 1 || tag.Exif.IsArray);
                 if (value is EncodedString)
                 {
                     // Console.WriteLine("EncodedString tag: " + (ushort)tag.Exif.Tag);
@@ -260,20 +260,34 @@ private string ConvertToString(ReadOnlySpan<byte> buffer)
             return ExifConstants.DefaultEncoding.GetString(buffer);
         }
 
-        private object ConvertValue(ExifDataType dataType, ReadOnlySpan<byte> buffer, bool isArray)
+        private object ConvertValue(ExifValue exifValue, ExifDataType dataType, ReadOnlySpan<byte> buffer, bool isArray)
         {
             if (buffer.Length == 0)
             {
                 return null;
             }
 
+            var tagValue = (ExifTagValue)(ushort)exifValue.Tag;
+            if (ExifUcs2StringHelpers.IsUcs2Tag(tagValue))
+            {
+                return ExifUcs2StringHelpers.ConvertToString(buffer);
+            }
+            else if (ExifEncodedStringHelpers.IsEncodedString(tagValue))
+            {
+                if (ExifEncodedStringHelpers.TryCreate(buffer, out EncodedString encodedString))
+                {
+                    return encodedString;
+                }
+            }
+
             switch (dataType)
             {
                 case ExifDataType.Unknown:
                     return null;
                 case ExifDataType.Ascii:
                     return this.ConvertToString(buffer);
                 case ExifDataType.Byte:
+                case ExifDataType.Undefined:
                 {
                     if (!isArray)
                     {
@@ -362,15 +376,6 @@ 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 ExifEncodedStringHelpers.TryCreate(buffer, out EncodedString encodedString) ? encodedString : buffer.ToArray();
-                }
 
                 default:
                     throw new NotSupportedException($"Data type {dataType} is not supported.");
@@ -430,7 +435,7 @@ private void ReadValue(List<IExifValue> values, Span<byte> offsetBuffer)
             }
             else
             {
-                object value = this.ConvertValue(dataType, offsetBuffer.Slice(0, (int)size), numberOfComponents > 1 || exifValue.IsArray);
+                object value = this.ConvertValue(exifValue, dataType, offsetBuffer.Slice(0, (int)size), numberOfComponents > 1 || exifValue.IsArray);
                 this.Add(values, exifValue, value);
             }
         }
@@ -504,7 +509,7 @@ private void ReadValue64(List<IExifValue> values, Span<byte> offsetBuffer)
             }
             else
             {
-                object value = this.ConvertValue(dataType, offsetBuffer.Slice(0, (int)size), numberOfComponents > 1 || exifValue.IsArray);
+                object value = this.ConvertValue(exifValue, dataType, offsetBuffer.Slice(0, (int)size), numberOfComponents > 1 || exifValue.IsArray);
                 this.Add(values, exifValue, value);
             }
         }

tests/ImageSharp.Tests/Metadata/Profiles/Exif/Values/ExifValuesTests.cs

@@ -23,11 +23,6 @@ public class ExifValuesTests
             { ExifTag.XMP },
             { ExifTag.CFAPattern2 },
             { ExifTag.TIFFEPStandardID },
-            { ExifTag.XPTitle },
-            { ExifTag.XPComment },
-            { ExifTag.XPAuthor },
-            { ExifTag.XPKeywords },
-            { ExifTag.XPSubject },
             { ExifTag.GPSVersionID },
         };
 
@@ -295,7 +290,12 @@ public class ExifValuesTests
             { ExifTag.GPSDestLongitudeRef },
             { ExifTag.GPSDestBearingRef },
             { ExifTag.GPSDestDistanceRef },
-            { ExifTag.GPSDateStamp }
+            { ExifTag.GPSDateStamp },
+            { ExifTag.XPTitle },
+            { ExifTag.XPComment },
+            { ExifTag.XPAuthor },
+            { ExifTag.XPKeywords },
+            { ExifTag.XPSubject },
         };
 
         public static TheoryData<ExifTag> UndefinedTags => new TheoryData<ExifTag>