diff --git a/src/ImageSharp/Formats/Tiff/Constants/TiffConstants.cs b/src/ImageSharp/Formats/Tiff/Constants/TiffConstants.cs index 5733bada97..8d9fb94a44 100644 --- a/src/ImageSharp/Formats/Tiff/Constants/TiffConstants.cs +++ b/src/ImageSharp/Formats/Tiff/Constants/TiffConstants.cs @@ -83,82 +83,82 @@ namespace SixLabors.ImageSharp.Formats.Tiff.Constants /// /// The bits per sample for 1 bit bicolor images. /// - public static readonly ushort[] BitsPerSample1Bit = { 1 }; + public static readonly TiffBitsPerSample BitsPerSample1Bit = new TiffBitsPerSample(1, 0, 0); /// /// The bits per sample for images with a 2 color palette. /// - public static readonly ushort[] BitsPerSample2Bit = { 2 }; + public static readonly TiffBitsPerSample BitsPerSample2Bit = new TiffBitsPerSample(2, 0, 0); /// /// The bits per sample for images with a 4 color palette. /// - public static readonly ushort[] BitsPerSample4Bit = { 4 }; + public static readonly TiffBitsPerSample BitsPerSample4Bit = new TiffBitsPerSample(4, 0, 0); /// /// The bits per sample for 6 bit gray images. /// - public static readonly ushort[] BitsPerSample6Bit = { 6 }; + public static readonly TiffBitsPerSample BitsPerSample6Bit = new TiffBitsPerSample(6, 0, 0); /// /// The bits per sample for 8 bit images. /// - public static readonly ushort[] BitsPerSample8Bit = { 8 }; + public static readonly TiffBitsPerSample BitsPerSample8Bit = new TiffBitsPerSample(8, 0, 0); /// /// The bits per sample for 10 bit gray images. /// - public static readonly ushort[] BitsPerSample10Bit = { 10 }; + public static readonly TiffBitsPerSample BitsPerSample10Bit = new TiffBitsPerSample(10, 0, 0); /// /// The bits per sample for 12 bit gray images. /// - public static readonly ushort[] BitsPerSample12Bit = { 12 }; + public static readonly TiffBitsPerSample BitsPerSample12Bit = new TiffBitsPerSample(12, 0, 0); /// /// The bits per sample for 14 bit gray images. /// - public static readonly ushort[] BitsPerSample14Bit = { 14 }; + public static readonly TiffBitsPerSample BitsPerSample14Bit = new TiffBitsPerSample(14, 0, 0); /// /// The bits per sample for 16 bit gray images. /// - public static readonly ushort[] BitsPerSample16Bit = { 16 }; + public static readonly TiffBitsPerSample BitsPerSample16Bit = new TiffBitsPerSample(16, 0, 0); /// /// The bits per sample for color images with 2 bits for each color channel. /// - public static readonly ushort[] BitsPerSampleRgb2Bit = { 2, 2, 2 }; + public static readonly TiffBitsPerSample BitsPerSampleRgb2Bit = new TiffBitsPerSample(2, 2, 2); /// /// The bits per sample for color images with 4 bits for each color channel. /// - public static readonly ushort[] BitsPerSampleRgb4Bit = { 4, 4, 4 }; + public static readonly TiffBitsPerSample BitsPerSampleRgb4Bit = new TiffBitsPerSample(4, 4, 4); /// /// The bits per sample for color images with 8 bits for each color channel. /// - public static readonly ushort[] BitsPerSampleRgb8Bit = { 8, 8, 8 }; + public static readonly TiffBitsPerSample BitsPerSampleRgb8Bit = new TiffBitsPerSample(8, 8, 8); /// /// The bits per sample for color images with 10 bits for each color channel. /// - public static readonly ushort[] BitsPerSampleRgb10Bit = { 10, 10, 10 }; + public static readonly TiffBitsPerSample BitsPerSampleRgb10Bit = new TiffBitsPerSample(10, 10, 10); /// /// The bits per sample for color images with 12 bits for each color channel. /// - public static readonly ushort[] BitsPerSampleRgb12Bit = { 12, 12, 12 }; + public static readonly TiffBitsPerSample BitsPerSampleRgb12Bit = new TiffBitsPerSample(12, 12, 12); /// /// The bits per sample for color images with 14 bits for each color channel. /// - public static readonly ushort[] BitsPerSampleRgb14Bit = { 14, 14, 14 }; + public static readonly TiffBitsPerSample BitsPerSampleRgb14Bit = new TiffBitsPerSample(14, 14, 14); /// /// The bits per sample for color images with 14 bits for each color channel. /// - public static readonly ushort[] BitsPerSampleRgb16Bit = { 16, 16, 16 }; + public static readonly TiffBitsPerSample BitsPerSampleRgb16Bit = new TiffBitsPerSample(16, 16, 16); /// /// The list of mimetypes that equate to a tiff. diff --git a/src/ImageSharp/Formats/Tiff/TiffBitsPerSample.cs b/src/ImageSharp/Formats/Tiff/TiffBitsPerSample.cs index 71f6b5bf9f..b79730a127 100644 --- a/src/ImageSharp/Formats/Tiff/TiffBitsPerSample.cs +++ b/src/ImageSharp/Formats/Tiff/TiffBitsPerSample.cs @@ -1,96 +1,242 @@ // Copyright (c) Six Labors. // Licensed under the Apache License, Version 2.0. +using System; +using SixLabors.ImageSharp.Formats.Tiff.Constants; + namespace SixLabors.ImageSharp.Formats.Tiff { /// /// The number of bits per component. /// - public enum TiffBitsPerSample + public readonly struct TiffBitsPerSample : IEquatable { /// - /// The bits per samples is not known. - /// - Unknown = 0, - - /// - /// One bit per sample for bicolor images. - /// - Bit1, - - /// - /// Two bits per sample for grayscale images with 4 different levels of gray or paletted images with a palette of 4 colors. - /// - Bit2, - - /// - /// Four bits per sample for grayscale images with 16 different levels of gray or paletted images with a palette of 16 colors. - /// - Bit4, - - /// - /// Six bits per sample for grayscale images. - /// - Bit6, - - /// - /// Eight bits per sample for grayscale images with 256 different levels of gray or paletted images with a palette of 256 colors. - /// - Bit8, - - /// - /// Ten bits per sample for grayscale images. - /// - Bit10, - - /// - /// Twelve bits per sample for grayscale images. + /// The bits for the channel 0. /// - Bit12, + public readonly ushort Channel0; /// - /// Fourteen bits per sample for grayscale images. + /// The bits for the channel 1. /// - Bit14, + public readonly ushort Channel1; /// - /// Sixteen bits per sample for grayscale images. - /// - Bit16, - - /// - /// 6 bits per sample, each channel has 2 bits. - /// - Rgb222, - - /// - /// Twelve bits per sample, each channel has 4 bits. - /// - Rgb444, - - /// - /// 24 bits per sample, each color channel has 8 Bits. - /// - Rgb888, - - /// - /// Thirty bits per sample, each channel has 10 bits. - /// - Rgb101010, - - /// - /// Thirty six bits per sample, each channel has 12 bits. - /// - Rgb121212, - - /// - /// Forty two bits per sample, each channel has 14 bits. - /// - Rgb141414, - - /// - /// Forty eight bits per sample, each channel has 16 bits. - /// - Rgb161616, + /// The bits for the channel 2. + /// + public readonly ushort Channel2; + + /// + /// Initializes a new instance of the struct. + /// + /// The bits for the channel 0. + /// The bits for the channel 1. + /// The bits for the channel 2. + public TiffBitsPerSample(ushort channel0, ushort channel1, ushort channel2) + { + this.Channel0 = (ushort)Numerics.Clamp(channel0, 1, 32); + this.Channel1 = (ushort)Numerics.Clamp(channel1, 0, 32); + this.Channel2 = (ushort)Numerics.Clamp(channel2, 0, 32); + } + + /// + /// Tries to parse a ushort array and convert it into a TiffBitsPerSample struct. + /// + /// The value to parse. + /// The tiff bits per sample. + /// True, if the value could be parsed. + public static bool TryParse(ushort[] value, out TiffBitsPerSample sample) + { + if (value is null || value.Length == 0) + { + sample = default; + return false; + } + + ushort c2; + ushort c1; + ushort c0; + switch (value.Length) + { + case 3: + c2 = value[2]; + c1 = value[1]; + c0 = value[0]; + break; + case 2: + c2 = 0; + c1 = value[1]; + c0 = value[0]; + break; + default: + c2 = 0; + c1 = 0; + c0 = value[0]; + break; + } + + sample = new TiffBitsPerSample(c0, c1, c2); + return true; + } + + /// + public override bool Equals(object obj) + => obj is TiffBitsPerSample sample && this.Equals(sample); + + /// + public bool Equals(TiffBitsPerSample other) + => this.Channel0 == other.Channel0 + && this.Channel1 == other.Channel1 + && this.Channel2 == other.Channel2; + + /// + public override int GetHashCode() + => HashCode.Combine(this.Channel0, this.Channel1, this.Channel2); + + /// + /// Converts the bits per sample struct to an ushort array. + /// + /// Bits per sample as ushort array. + public ushort[] ToArray() + { + if (this.Channel1 == 0) + { + return new[] { this.Channel0 }; + } + + if (this.Channel2 == 0) + { + return new[] { this.Channel0, this.Channel1 }; + } + + return new[] { this.Channel0, this.Channel1, this.Channel2 }; + } + + /// + /// Maps an array of bits per sample to a concrete struct value. + /// + /// The bits per sample array. + /// TiffBitsPerSample enum value. + public static TiffBitsPerSample? GetBitsPerSample(ushort[] bitsPerSample) + { + switch (bitsPerSample.Length) + { + case 3: + if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb16Bit.Channel2 && + bitsPerSample[1] == TiffConstants.BitsPerSampleRgb16Bit.Channel1 && + bitsPerSample[0] == TiffConstants.BitsPerSampleRgb16Bit.Channel0) + { + return TiffConstants.BitsPerSampleRgb16Bit; + } + + if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb14Bit.Channel2 && + bitsPerSample[1] == TiffConstants.BitsPerSampleRgb14Bit.Channel1 && + bitsPerSample[0] == TiffConstants.BitsPerSampleRgb14Bit.Channel0) + { + return TiffConstants.BitsPerSampleRgb14Bit; + } + + if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb12Bit.Channel2 && + bitsPerSample[1] == TiffConstants.BitsPerSampleRgb12Bit.Channel1 && + bitsPerSample[0] == TiffConstants.BitsPerSampleRgb12Bit.Channel0) + { + return TiffConstants.BitsPerSampleRgb12Bit; + } + + if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb10Bit.Channel2 && + bitsPerSample[1] == TiffConstants.BitsPerSampleRgb10Bit.Channel1 && + bitsPerSample[0] == TiffConstants.BitsPerSampleRgb10Bit.Channel0) + { + return TiffConstants.BitsPerSampleRgb10Bit; + } + + if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb8Bit.Channel2 && + bitsPerSample[1] == TiffConstants.BitsPerSampleRgb8Bit.Channel1 && + bitsPerSample[0] == TiffConstants.BitsPerSampleRgb8Bit.Channel0) + { + return TiffConstants.BitsPerSampleRgb8Bit; + } + + if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb4Bit.Channel2 && + bitsPerSample[1] == TiffConstants.BitsPerSampleRgb4Bit.Channel1 && + bitsPerSample[0] == TiffConstants.BitsPerSampleRgb4Bit.Channel0) + { + return TiffConstants.BitsPerSampleRgb4Bit; + } + + if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb2Bit.Channel2 && + bitsPerSample[1] == TiffConstants.BitsPerSampleRgb2Bit.Channel1 && + bitsPerSample[0] == TiffConstants.BitsPerSampleRgb2Bit.Channel0) + { + return TiffConstants.BitsPerSampleRgb2Bit; + } + + break; + + case 1: + if (bitsPerSample[0] == TiffConstants.BitsPerSample1Bit.Channel0) + { + return TiffConstants.BitsPerSample1Bit; + } + + if (bitsPerSample[0] == TiffConstants.BitsPerSample2Bit.Channel0) + { + return TiffConstants.BitsPerSample2Bit; + } + + if (bitsPerSample[0] == TiffConstants.BitsPerSample4Bit.Channel0) + { + return TiffConstants.BitsPerSample4Bit; + } + + if (bitsPerSample[0] == TiffConstants.BitsPerSample6Bit.Channel0) + { + return TiffConstants.BitsPerSample6Bit; + } + + if (bitsPerSample[0] == TiffConstants.BitsPerSample8Bit.Channel0) + { + return TiffConstants.BitsPerSample8Bit; + } + + if (bitsPerSample[0] == TiffConstants.BitsPerSample10Bit.Channel0) + { + return TiffConstants.BitsPerSample10Bit; + } + + if (bitsPerSample[0] == TiffConstants.BitsPerSample12Bit.Channel0) + { + return TiffConstants.BitsPerSample12Bit; + } + + if (bitsPerSample[0] == TiffConstants.BitsPerSample14Bit.Channel0) + { + return TiffConstants.BitsPerSample14Bit; + } + + if (bitsPerSample[0] == TiffConstants.BitsPerSample16Bit.Channel0) + { + return TiffConstants.BitsPerSample16Bit; + } + + break; + } + + return null; + } + + /// + /// Gets the bits per pixel for the given bits per sample. + /// + /// Bits per pixel. + public TiffBitsPerPixel BitsPerPixel() + { + int bitsPerPixel = this.Channel0 + this.Channel1 + this.Channel2; + return (TiffBitsPerPixel)bitsPerPixel; + } + + /// + public override string ToString() + => $"TiffBitsPerSample({this.Channel0}, {this.Channel1}, {this.Channel2})"; } } diff --git a/src/ImageSharp/Formats/Tiff/TiffBitsPerSampleExtensions.cs b/src/ImageSharp/Formats/Tiff/TiffBitsPerSampleExtensions.cs deleted file mode 100644 index 5ec1331b31..0000000000 --- a/src/ImageSharp/Formats/Tiff/TiffBitsPerSampleExtensions.cs +++ /dev/null @@ -1,170 +0,0 @@ -// Copyright (c) Six Labors. -// Licensed under the Apache License, Version 2.0. - -using System; -using SixLabors.ImageSharp.Formats.Tiff.Constants; - -namespace SixLabors.ImageSharp.Formats.Tiff -{ - internal static class TiffBitsPerSampleExtensions - { - /// - /// Gets the bits per channel array for a given BitsPerSample value, e,g, for RGB888: [8, 8, 8] - /// - /// The tiff bits per sample. - /// Bits per sample array. - public static ushort[] BitsPerChannel(this TiffBitsPerSample tiffBitsPerSample) - { - switch (tiffBitsPerSample) - { - case TiffBitsPerSample.Bit1: - return TiffConstants.BitsPerSample1Bit; - case TiffBitsPerSample.Bit2: - return TiffConstants.BitsPerSample2Bit; - case TiffBitsPerSample.Bit4: - return TiffConstants.BitsPerSample4Bit; - case TiffBitsPerSample.Bit6: - return TiffConstants.BitsPerSample6Bit; - case TiffBitsPerSample.Bit8: - return TiffConstants.BitsPerSample8Bit; - case TiffBitsPerSample.Bit10: - return TiffConstants.BitsPerSample10Bit; - case TiffBitsPerSample.Bit12: - return TiffConstants.BitsPerSample12Bit; - case TiffBitsPerSample.Bit14: - return TiffConstants.BitsPerSample14Bit; - case TiffBitsPerSample.Bit16: - return TiffConstants.BitsPerSample16Bit; - case TiffBitsPerSample.Rgb222: - return TiffConstants.BitsPerSampleRgb2Bit; - case TiffBitsPerSample.Rgb444: - return TiffConstants.BitsPerSampleRgb4Bit; - case TiffBitsPerSample.Rgb888: - return TiffConstants.BitsPerSampleRgb8Bit; - case TiffBitsPerSample.Rgb101010: - return TiffConstants.BitsPerSampleRgb10Bit; - case TiffBitsPerSample.Rgb121212: - return TiffConstants.BitsPerSampleRgb12Bit; - case TiffBitsPerSample.Rgb141414: - return TiffConstants.BitsPerSampleRgb14Bit; - case TiffBitsPerSample.Rgb161616: - return TiffConstants.BitsPerSampleRgb16Bit; - default: - return Array.Empty(); - } - } - - /// - /// Maps an array of bits per sample to a concrete enum value. - /// - /// The bits per sample array. - /// TiffBitsPerSample enum value. - public static TiffBitsPerSample GetBitsPerSample(this ushort[] bitsPerSample) - { - switch (bitsPerSample.Length) - { - case 3: - if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb16Bit[2] && - bitsPerSample[1] == TiffConstants.BitsPerSampleRgb16Bit[1] && - bitsPerSample[0] == TiffConstants.BitsPerSampleRgb16Bit[0]) - { - return TiffBitsPerSample.Rgb161616; - } - - if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb14Bit[2] && - bitsPerSample[1] == TiffConstants.BitsPerSampleRgb14Bit[1] && - bitsPerSample[0] == TiffConstants.BitsPerSampleRgb14Bit[0]) - { - return TiffBitsPerSample.Rgb141414; - } - - if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb12Bit[2] && - bitsPerSample[1] == TiffConstants.BitsPerSampleRgb12Bit[1] && - bitsPerSample[0] == TiffConstants.BitsPerSampleRgb12Bit[0]) - { - return TiffBitsPerSample.Rgb121212; - } - - if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb10Bit[2] && - bitsPerSample[1] == TiffConstants.BitsPerSampleRgb10Bit[1] && - bitsPerSample[0] == TiffConstants.BitsPerSampleRgb10Bit[0]) - { - return TiffBitsPerSample.Rgb101010; - } - - if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb8Bit[2] && - bitsPerSample[1] == TiffConstants.BitsPerSampleRgb8Bit[1] && - bitsPerSample[0] == TiffConstants.BitsPerSampleRgb8Bit[0]) - { - return TiffBitsPerSample.Rgb888; - } - - if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb4Bit[2] && - bitsPerSample[1] == TiffConstants.BitsPerSampleRgb4Bit[1] && - bitsPerSample[0] == TiffConstants.BitsPerSampleRgb4Bit[0]) - { - return TiffBitsPerSample.Rgb444; - } - - if (bitsPerSample[2] == TiffConstants.BitsPerSampleRgb2Bit[2] && - bitsPerSample[1] == TiffConstants.BitsPerSampleRgb2Bit[1] && - bitsPerSample[0] == TiffConstants.BitsPerSampleRgb2Bit[0]) - { - return TiffBitsPerSample.Rgb222; - } - - break; - - case 1: - if (bitsPerSample[0] == TiffConstants.BitsPerSample1Bit[0]) - { - return TiffBitsPerSample.Bit1; - } - - if (bitsPerSample[0] == TiffConstants.BitsPerSample2Bit[0]) - { - return TiffBitsPerSample.Bit2; - } - - if (bitsPerSample[0] == TiffConstants.BitsPerSample4Bit[0]) - { - return TiffBitsPerSample.Bit4; - } - - if (bitsPerSample[0] == TiffConstants.BitsPerSample6Bit[0]) - { - return TiffBitsPerSample.Bit6; - } - - if (bitsPerSample[0] == TiffConstants.BitsPerSample8Bit[0]) - { - return TiffBitsPerSample.Bit8; - } - - if (bitsPerSample[0] == TiffConstants.BitsPerSample10Bit[0]) - { - return TiffBitsPerSample.Bit10; - } - - if (bitsPerSample[0] == TiffConstants.BitsPerSample12Bit[0]) - { - return TiffBitsPerSample.Bit12; - } - - if (bitsPerSample[0] == TiffConstants.BitsPerSample14Bit[0]) - { - return TiffBitsPerSample.Bit14; - } - - if (bitsPerSample[0] == TiffConstants.BitsPerSample16Bit[0]) - { - return TiffBitsPerSample.Bit16; - } - - break; - } - - return TiffBitsPerSample.Unknown; - } - } -} diff --git a/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs b/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs index 1efc826027..0699359c07 100644 --- a/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs +++ b/src/ImageSharp/Formats/Tiff/TiffDecoderOptionsParser.cs @@ -69,7 +69,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff options.Predictor = frameMetadata.Predictor ?? TiffPredictor.None; options.PhotometricInterpretation = frameMetadata.PhotometricInterpretation ?? TiffPhotometricInterpretation.Rgb; options.BitsPerPixel = frameMetadata.BitsPerPixel != null ? (int)frameMetadata.BitsPerPixel.Value : (int)TiffBitsPerPixel.Bit24; - options.BitsPerSample = frameMetadata.BitsPerSample != null ? frameMetadata.BitsPerSample?.BitsPerChannel() : Array.Empty(); + options.BitsPerSample = frameMetadata.BitsPerSample != null ? frameMetadata.BitsPerSample?.ToArray() : Array.Empty(); options.ParseColorType(exifProfile); options.ParseCompression(frameMetadata.Compression, exifProfile); diff --git a/src/ImageSharp/Formats/Tiff/TiffEncoderEntriesCollector.cs b/src/ImageSharp/Formats/Tiff/TiffEncoderEntriesCollector.cs index 9bc0792c40..43a0868496 100644 --- a/src/ImageSharp/Formats/Tiff/TiffEncoderEntriesCollector.cs +++ b/src/ImageSharp/Formats/Tiff/TiffEncoderEntriesCollector.cs @@ -318,34 +318,34 @@ namespace SixLabors.ImageSharp.Formats.Tiff case TiffPhotometricInterpretation.PaletteColor: if (encoder.BitsPerPixel == TiffBitsPerPixel.Bit4) { - return TiffConstants.BitsPerSample4Bit; + return TiffConstants.BitsPerSample4Bit.ToArray(); } else { - return TiffConstants.BitsPerSample8Bit; + return TiffConstants.BitsPerSample8Bit.ToArray(); } case TiffPhotometricInterpretation.Rgb: - return TiffConstants.BitsPerSampleRgb8Bit; + return TiffConstants.BitsPerSampleRgb8Bit.ToArray(); case TiffPhotometricInterpretation.WhiteIsZero: if (encoder.BitsPerPixel == TiffBitsPerPixel.Bit1) { - return TiffConstants.BitsPerSample1Bit; + return TiffConstants.BitsPerSample1Bit.ToArray(); } - return TiffConstants.BitsPerSample8Bit; + return TiffConstants.BitsPerSample8Bit.ToArray(); case TiffPhotometricInterpretation.BlackIsZero: if (encoder.BitsPerPixel == TiffBitsPerPixel.Bit1) { - return TiffConstants.BitsPerSample1Bit; + return TiffConstants.BitsPerSample1Bit.ToArray(); } - return TiffConstants.BitsPerSample8Bit; + return TiffConstants.BitsPerSample8Bit.ToArray(); default: - return TiffConstants.BitsPerSampleRgb8Bit; + return TiffConstants.BitsPerSampleRgb8Bit.ToArray(); } } diff --git a/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs b/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs index 62e9fb4e21..76db6e75f7 100644 --- a/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs +++ b/src/ImageSharp/Formats/Tiff/TiffFrameMetadata.cs @@ -69,7 +69,7 @@ namespace SixLabors.ImageSharp.Formats.Tiff } /// - /// Parses the given Exif profile to populate the properties of the tiff frame meta data.. + /// Parses the given Exif profile to populate the properties of the tiff frame meta data. /// /// The tiff frame meta data. /// The Exif profile containing tiff frame directory tags. @@ -77,8 +77,8 @@ namespace SixLabors.ImageSharp.Formats.Tiff { if (profile != null) { - meta.BitsPerSample = profile.GetValue(ExifTag.BitsPerSample) != null ? profile.GetValue(ExifTag.BitsPerSample)?.Value.GetBitsPerSample() : null; - meta.BitsPerPixel = BitsPerPixelFromBitsPerSample(meta.BitsPerSample?.BitsPerChannel()); + meta.BitsPerSample = profile.GetValue(ExifTag.BitsPerSample) != null ? TiffBitsPerSample.GetBitsPerSample(profile.GetValue(ExifTag.BitsPerSample)?.Value) : null; + meta.BitsPerPixel = meta.BitsPerSample?.BitsPerPixel(); meta.Compression = (TiffCompression?)profile.GetValue(ExifTag.Compression)?.Value; meta.PhotometricInterpretation = (TiffPhotometricInterpretation?)profile.GetValue(ExifTag.PhotometricInterpretation)?.Value; meta.Predictor = (TiffPredictor?)profile.GetValue(ExifTag.Predictor)?.Value; @@ -90,27 +90,6 @@ namespace SixLabors.ImageSharp.Formats.Tiff } } - /// - /// Gets the bits per pixel for the given bits per sample. - /// - /// The tiff bits per sample. - /// Bits per pixel. - private static TiffBitsPerPixel? BitsPerPixelFromBitsPerSample(ushort[] bitsPerSample) - { - if (bitsPerSample == null) - { - return null; - } - - int bitsPerPixel = 0; - foreach (ushort bits in bitsPerSample) - { - bitsPerPixel += bits; - } - - return (TiffBitsPerPixel)bitsPerPixel; - } - /// public IDeepCloneable DeepClone() => new TiffFrameMetadata(this); }