Rename TiffByteOrder To ByteOrder, moved it to Common folder

src/ImageSharp/Formats/Tiff/Constants/TiffByteOrder.cs → src/ImageSharp/Common/ByteOrder.cs

@@ -1,20 +1,22 @@
 // Copyright (c) Six Labors.
 // Licensed under the Apache License, Version 2.0.
 
-namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Constants
+namespace SixLabors.ImageSharp
 {
     /// <summary>
     /// The tiff data stream byte order enum.
     /// </summary>
-    public enum TiffByteOrder
+    public enum ByteOrder
     {
         /// <summary>
         /// The big-endian byte order (Motorola).
+        /// Most-significant byte comes first, and ends with the least-significant byte.
         /// </summary>
         BigEndian,
 
         /// <summary>
         /// The little-endian byte order (Intel).
+        /// Least-significant byte comes first and ends with the most-significant byte.
         /// </summary>
         LittleEndian
     }

src/ImageSharp/Formats/Tiff/Streams/TiffBigEndianStream.cs

@@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Streams
         {
         }
 
-        public override TiffByteOrder ByteOrder => TiffByteOrder.BigEndian;
+        public override ByteOrder ByteOrder => ByteOrder.BigEndian;
 
         /// <summary>
         /// Converts buffer data into an <see cref="short"/> using the correct endianness.

src/ImageSharp/Formats/Tiff/Streams/TiffLittleEndianStream.cs

@@ -15,7 +15,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Streams
         {
         }
 
-        public override TiffByteOrder ByteOrder => TiffByteOrder.LittleEndian;
+        public override ByteOrder ByteOrder => ByteOrder.LittleEndian;
 
         /// <summary>
         /// Converts buffer data into an <see cref="short"/> using the correct endianness.

src/ImageSharp/Formats/Tiff/Streams/TiffStream.cs

@@ -28,7 +28,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff.Streams
         /// <summary>
         /// Gets a value indicating whether the file is encoded in little-endian or big-endian format.
         /// </summary>
-        public abstract TiffByteOrder ByteOrder { get; }
+        public abstract ByteOrder ByteOrder { get; }
 
         /// <summary>
         /// Gets the input stream.

src/ImageSharp/Formats/Tiff/TiffDecoderCore.cs

@@ -169,7 +169,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff
             return new ImageInfo(new PixelTypeInfo(bitsPerPixel), (int)root.Width, (int)root.Height, this.metadata);
         }
 
-        private void SetTiffFormatMetaData(List<TiffFrameMetadata> framesMetadata, TiffByteOrder byteOrder)
+        private void SetTiffFormatMetaData(List<TiffFrameMetadata> framesMetadata, ByteOrder byteOrder)
         {
             this.metadata = framesMetadata.CreateMetadata(this.ignoreMetadata, byteOrder);
             this.tiffMetaData = this.metadata.GetTiffMetadata();
@@ -203,12 +203,12 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff
 
         private static TiffStream CreateStream(Stream stream)
         {
-            TiffByteOrder byteOrder = ReadByteOrder(stream);
+            ByteOrder byteOrder = ReadByteOrder(stream);
-            if (byteOrder == TiffByteOrder.BigEndian)
+            if (byteOrder == ByteOrder.BigEndian)
             {
                 return new TiffBigEndianStream(stream);
             }
-            else if (byteOrder == TiffByteOrder.LittleEndian)
+            else if (byteOrder == ByteOrder.LittleEndian)
             {
                 return new TiffLittleEndianStream(stream);
             }
@@ -216,17 +216,17 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff
             throw TiffThrowHelper.InvalidHeader();
         }
 
-        private static TiffByteOrder ReadByteOrder(Stream stream)
+        private static ByteOrder ReadByteOrder(Stream stream)
         {
             var headerBytes = new byte[2];
             stream.Read(headerBytes, 0, 2);
             if (headerBytes[0] == TiffConstants.ByteOrderLittleEndian && headerBytes[1] == TiffConstants.ByteOrderLittleEndian)
             {
-                return TiffByteOrder.LittleEndian;
+                return ByteOrder.LittleEndian;
             }
             else if (headerBytes[0] == TiffConstants.ByteOrderBigEndian && headerBytes[1] == TiffConstants.ByteOrderBigEndian)
             {
-                return TiffByteOrder.BigEndian;
+                return ByteOrder.BigEndian;
             }
 
             throw TiffThrowHelper.InvalidHeader();

src/ImageSharp/Formats/Tiff/TiffDecoderHelpers.cs

@@ -18,7 +18,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff
     /// </summary>
     internal static class TiffDecoderHelpers
     {
-        public static ImageMetadata CreateMetadata(this IList<TiffFrameMetadata> frames, bool ignoreMetadata, TiffByteOrder byteOrder)
+        public static ImageMetadata CreateMetadata(this IList<TiffFrameMetadata> frames, bool ignoreMetadata, ByteOrder byteOrder)
         {
             var coreMetadata = new ImageMetadata();
             TiffMetadata tiffMetadata = coreMetadata.GetTiffMetadata();

src/ImageSharp/Formats/Tiff/TiffMetadata.cs

@@ -31,7 +31,7 @@ namespace SixLabors.ImageSharp.Formats.Experimental.Tiff
         /// <summary>
         /// Gets or sets the byte order.
         /// </summary>
-        public TiffByteOrder ByteOrder { get; set; }
+        public ByteOrder ByteOrder { get; set; }
 
         /// <summary>
         /// Gets or sets the number of bits per pixel.

tests/ImageSharp.Tests/Formats/Tiff/TiffDecoderTests.cs

@@ -59,9 +59,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         }
 
         [Theory]
-        [InlineData(RgbLzwNoPredictorMultistrip, TiffByteOrder.LittleEndian)]
+        [InlineData(RgbLzwNoPredictorMultistrip, ImageSharp.ByteOrder.LittleEndian)]
-        [InlineData(RgbLzwNoPredictorMultistripMotorola, TiffByteOrder.BigEndian)]
+        [InlineData(RgbLzwNoPredictorMultistripMotorola, ImageSharp.ByteOrder.BigEndian)]
-        public void ByteOrder(string imagePath, TiffByteOrder expectedByteOrder)
+        public void ByteOrder(string imagePath, ByteOrder expectedByteOrder)
         {
             var testFile = TestFile.Create(imagePath);
             using (var stream = new MemoryStream(testFile.Bytes, false))

tests/ImageSharp.Tests/Formats/Tiff/TiffMetadataTests.cs

@@ -24,7 +24,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
             {
                 Compression = TiffCompression.Deflate,
                 BitsPerPixel = TiffBitsPerPixel.Pixel8,
-                ByteOrder = TiffByteOrder.BigEndian,
+                ByteOrder = ByteOrder.BigEndian,
                 XmpProfile = new byte[3]
             };
 
@@ -32,7 +32,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
 
             clone.Compression = TiffCompression.None;
             clone.BitsPerPixel = TiffBitsPerPixel.Pixel24;
-            clone.ByteOrder = TiffByteOrder.LittleEndian;
+            clone.ByteOrder = ByteOrder.LittleEndian;
             clone.XmpProfile = new byte[1];
 
             Assert.False(meta.Compression == clone.Compression);
@@ -80,9 +80,9 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
         }
 
         [Theory]
-        [InlineData(GrayscaleUncompressed, TiffByteOrder.BigEndian)]
+        [InlineData(GrayscaleUncompressed, ByteOrder.BigEndian)]
-        [InlineData(LsbToMsbByteOrder, TiffByteOrder.LittleEndian)]
+        [InlineData(LsbToMsbByteOrder, ByteOrder.LittleEndian)]
-        public void Identify_DetectsCorrectByteOrder(string imagePath, TiffByteOrder expectedByteOrder)
+        public void Identify_DetectsCorrectByteOrder(string imagePath, ByteOrder expectedByteOrder)
         {
             var testFile = TestFile.Create(imagePath);
             using var stream = new MemoryStream(testFile.Bytes, false);
@@ -127,7 +127,7 @@ namespace SixLabors.ImageSharp.Tests.Formats.Tiff
                 TiffMetadata meta = image.Metadata.GetTiffMetadata();
 
                 Assert.NotNull(meta);
-                Assert.Equal(TiffByteOrder.LittleEndian, meta.ByteOrder);
+                Assert.Equal(ByteOrder.LittleEndian, meta.ByteOrder);
                 Assert.Equal(PixelResolutionUnit.PixelsPerInch, image.Metadata.ResolutionUnits);
                 Assert.Equal(10, image.Metadata.HorizontalResolution);
                 Assert.Equal(10, image.Metadata.VerticalResolution);