Replies: 5 comments 26 replies
-
|
In combination with #2090 it would be closer to 65 'removed' APIs |
Beta Was this translation helpful? Give feedback.
-
|
Maybe we should use struct/record class to ensure passed options are immutable from outside? IMO |
Beta Was this translation helpful? Give feedback.
-
I would disagree... my use case here is the case where I don't know what image format that i'm decoding but If it is a gif/animated png/animated webp etc I want to always discard down to the first frame (maybe I am wanting to generate it for print etc) |
Beta Was this translation helpful? Give feedback.
-
|
Oh yeah, 100% agree, didn't think about use-case with uknown format before writing this ;) |
Beta Was this translation helpful? Give feedback.
-
|
with regards struct/immutability none of the API promises its thread safe etc so I wouldn't worry about it... I would actually expect the XXDecoder clases to read the values on invoke and set the required configs on the XXDecodeCore where they are required. |
Beta Was this translation helpful? Give feedback.
-
|
Sounds reasonable. |
Beta Was this translation helpful? Give feedback.
-
|
Shouldn't we just implement the old methods on top of Edit: + class DecoderOptions {
+ // common options
+ }
+
+ class GifDecoderOptions : DecoderOptions {
+ public FrameDecodingMode DecodingMode { get; set; }
+ }
- interface IGifDecoderOptions { FrameDecodingMode DecodingMode { get; set; } }
+ interface IImageDecoder {
+ Image Decode(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
+ }
class GifDecoder :
- IGifDecoderOptions,
IImageDecoder
{
- Image Decode(Configuration configuration, Stream stream, CancellationToken cancellationToken);
+ Image Decode(DecoderOptions options, Stream stream, CancellationToken cancellationToken);
} |
Beta Was this translation helpful? Give feedback.
-
|
@antonfirsov I've been thinking about this again. What about if public sealed class BmpDecoderOptions
{
public DecoderOptions GeneralOptions { get; set; }
public RleSkippedPixelHandling RleSkippedPixelHandling { get; set; }
}Not sure about the name That way I'd really like to to draw a line for V3 between general |
Beta Was this translation helpful? Give feedback.
-
The same trick would work with inheritance (
I see now that your main concern is to have stronger typing on the API, meaning that user should not be let to feed using var image = Image.DecodeBmp("x.bmp", new BmpDecoderOptions() { /* decoder config */ });far better than: using var image = new BmpDecoder().Decode("x.bmp", new BmpDecoderOptions() { /* decoder config */ });or even: using var image = new BmpDecoder(){ /* decoder config */ }).Decode("x.bmp");// And even with the latter two options I'm already assuming helper overloads that take a |
Beta Was this translation helpful? Give feedback.
-
I believe it's more convenient to have a 'master class' options as it would allow users to create a 'global config' for every available decoder so Using it with format-specific API will look strange: class DecoderOptions
{
// this set to null means use 'default' options
public JpegDecoderOptions Jpeg { get; set; }
public static implicit operator JpegDecoderOptions (DecoderOptions options) => options.Jpeg;
} |
Beta Was this translation helpful? Give feedback.
-
Composition would be best means I see of providing the type safety and ensuring the code remains AOT friendly also. That's forefront on my mind now.
Yes but more than that. One thing I've seen too often is people assuming a format (incorrectly) and then raising issues because we throw (correctly). By splitting the decode API clearly into general and specialized camps we encourage our users to make more informed choices and avoid these types of issues. I actually do not want us to be passing an using var image = Image.DecodeBmp("x.bmp", new BmpDecoderOptions() { /* decoder config */ });I wouldn't like this example as it's too easy to point this at the wrong format and misfire. It also creates yet another overload for Here's how I would like to see the decoders play out. // T here must be ISpecializedDecoderOptions
public class BmpDecoder : ImageDecoder<BmpDecoderOptions>
{
public Image<TPixel> Decode<TPixel>(DecoderOptions options, Stream stream, CancellationToken cancellationToken);
public Image<TPixel> Decode<TPixel>(DecoderOptions options, Stream stream, CancellationToken cancellationToken);
public Image<TPixel> DecodeSpecialized(BmpDecoderOptions options, Stream stream, CancellationToken cancellationToken);
public Image DecodeSpecialized(BmpDecoderOptions options, Stream stream, CancellationToken cancellationToken);
// Identify, Implicit implementations etc...
}The base class (something like linked but with updates for generic options type) would be responsible for automatically resizing the decoded image when So our general path is maintained. Image.Load(DecoderOptions ...)But for specialized options a more explicit and advanced API is available. new JpegDecoder().DecodeSpecialized(JpegDecoderOptions ...)I think I could rattle this all out in a pretty short while once #2076 is merged. |
Beta Was this translation helpful? Give feedback.
-
|
For clarity. Here's the base decoder class. The /// <summary>
/// The base class for all image decoders.
/// </summary>
/// <typeparam name="T">The type of specialized decoder options.</typeparam>
public abstract class ImageDecoder<T> : IImageInfoDetector, IImageDecoder
where T : ISpecializedDecoderOptions, new()
{
/// <inheritdoc/>
public IImageInfo Identify(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
{
T specializedOptions = new() { GeneralOptions = options };
return this.IdentifySpecialized(specializedOptions, stream, cancellationToken);
}
/// <inheritdoc/>
public Image<TPixel> Decode<TPixel>(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
where TPixel : unmanaged, IPixel<TPixel>
{
T specializedOptions = new() { GeneralOptions = options };
Image<TPixel> image = this.DecodeSpecialized<TPixel>(specializedOptions, stream, cancellationToken);
Resize(options, image);
return image;
}
/// <inheritdoc/>
public Image Decode(DecoderOptions options, Stream stream, CancellationToken cancellationToken)
{
T specializedOptions = new() { GeneralOptions = options };
Image image = this.DecodeSpecialized(specializedOptions, stream, cancellationToken);
Resize(options, image);
return image;
}
/// <summary>
/// Reads the raw image information from the specified stream.
/// </summary>
/// <param name="options">The specialized decoder options.</param>
/// <param name="stream">The <see cref="Stream"/> containing image data.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>The <see cref="IImageInfo"/> object.</returns>
/// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
public abstract IImageInfo IdentifySpecialized(T options, Stream stream, CancellationToken cancellationToken);
/// <summary>
/// Decodes the image from the specified stream to an <see cref="Image{TPixel}"/> of a specific pixel type.
/// </summary>
/// <typeparam name="TPixel">The pixel format.</typeparam>
/// <param name="options">The specialized decoder options.</param>
/// <param name="stream">The <see cref="Stream"/> containing image data.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
/// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
public abstract Image<TPixel> DecodeSpecialized<TPixel>(T options, Stream stream, CancellationToken cancellationToken)
where TPixel : unmanaged, IPixel<TPixel>;
/// <summary>
/// Decodes the image from the specified stream to an <see cref="Image"/> of a specific pixel type.
/// </summary>
/// <param name="options">The specialized decoder options.</param>
/// <param name="stream">The <see cref="Stream"/> containing image data.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>The <see cref="Image{TPixel}"/>.</returns>
/// <exception cref="ImageFormatException">Thrown if the encoded image contains errors.</exception>
public abstract Image DecodeSpecialized(T options, Stream stream, CancellationToken cancellationToken);
/// <summary>
/// Performs a resize operation against the decoded image. If the target size is not set, or the image size
/// already matches the target size, the image is untouched.
/// </summary>
/// <param name="options">The decoder options.</param>
/// <param name="image">The decoded image.</param>
protected static void Resize(DecoderOptions options, Image image)
{
if (ShouldResize(options, image))
{
ResizeOptions resizeOptions = new()
{
Size = options.TargetSize.Value,
Sampler = KnownResamplers.Box,
Mode = ResizeMode.Max
};
image.Mutate(x => x.Resize(resizeOptions));
}
}
/// <summary>
/// Determines whether the decoded image should be resized.
/// </summary>
/// <param name="options">The decoder options.</param>
/// <param name="image">The decoded image.</param>
/// <returns><see langword="true"/> if the image should be resized, otherwise; <see langword="false"/>.</returns>
private static bool ShouldResize(DecoderOptions options, Image image)
{
if (options.TargetSize is null)
{
return false;
}
Size targetSize = options.TargetSize.Value;
Size currentSize = image.Size();
return currentSize.Width != targetSize.Width && currentSize.Height != targetSize.Height;
}
} |
Beta Was this translation helpful? Give feedback.
-
|
|
Beta Was this translation helpful? Give feedback.
-
|
I'm still not sure about that since if the jpeg decoder does manage to IDCT scale the image upon decode then you end up with vastly different resampling qualities for different decoders. |
Beta Was this translation helpful? Give feedback.
-
That's why I've proposed size + resampler |
Beta Was this translation helpful? Give feedback.
-
|
you could possibly only apply the IDCT scalling if a user actually uses an equivalent set of setting to |
Beta Was this translation helpful? Give feedback.
-
|
Completed in v3 |
Beta Was this translation helpful? Give feedback.
Uh oh!
There was an error while loading. Please reload this page.
Uh oh!
There was an error while loading. Please reload this page.
-
The proposal is to add a new
DecoderOptionstype that can be passed along to compatible decoders.The idea is that decoder options will provider generic high level options that can be utilised by all decoders and can have a reasonable fallback to support decoders that do not have native support for the target feature.
First 2 options should be fairly obvious they provide a way for explicitly defining the decoder and explicitly defining the
Configurationwithout having overload explosion on the loading apis.The
TargetSizesize property allow for supporting decoders to use that to decode into the target size with us providing a check and applying a final mutate if the decoder returns an image on the wrong size (upscaled size provided or just not supported etc).. decoders will be able to use this more of a hint than a target requirement but Image.Load will force the size before returning to the user.SkipMetadata: allow for supporting decoders to totally skip metadata blocks but if the decoder does not support metadata skipping then we will null out all relevant parts of the metadata object before returning the image to the user.MaxFrames: hints to the decoder that it can stop decoding frames after this point... additonal returns frames will auto be removed in anycase.namespace SixLabors.ImageSharp { public sealed partial class Image { public static Image<TPixel> Load<TPixel>(byte[] data) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, byte[] data) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(byte[] data, IImageDecoder decoder) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, byte[] data, IImageDecoder decoder) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> Load<TPixel>(byte[] data, DecoderOptions options) where TPixel : managed, IPixel<TPixel> public static Image<TPixel> Load<TPixel>(byte[] data, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, byte[] data, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> Load<TPixel>(byte[] data, DecoderOptions options, out IImageFormat format) where TPixel : managed, IPixel<TPixel> public static Image<TPixel> Load<TPixel>(ReadOnlySpan<byte> data) where TPixel : managed, IPixel<TPixel> public static Image<TPixel> Load<TPixel>(ReadOnlySpan<byte> data, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, ReadOnlySpan<byte> data, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> Load<TPixel>(ReadOnlySpan<byte> data, DecoderOptions options, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(ReadOnlySpan<byte> data, IImageDecoder decoder) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, ReadOnlySpan<byte> data) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, ReadOnlySpan<byte> data, IImageDecoder decoder) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> Load<TPixel>(ReadOnlySpan<byte> data, DecoderOptions options) where TPixel : managed, IPixel<TPixel> public static Image Load(byte[] data) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(byte[] data, IImageDecoder decoder) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, byte[] data) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, byte[] data, IImageDecoder decoder) + public static Image Load(byte[] data, DecoderOptions options) public static Image Load(byte[] data, out IImageFormat format) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, byte[] data, out IImageFormat format) + public static Image Load(byte[] data, DecoderOptions options, out IImageFormat format) public static Image Load(ReadOnlySpan<byte> data) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(ReadOnlySpan<byte> data, IImageDecoder decoder) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, ReadOnlySpan<byte> data) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, ReadOnlySpan<byte> data, IImageDecoder decoder) + public static Image Load(ReadOnlySpan<byte> data, DecoderOptions options) public static Image Load(ReadOnlySpan<byte> data, out IImageFormat format) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, ReadOnlySpan<byte> data, out IImageFormat format) + public static Image Load(ReadOnlySpan<byte> data, DecoderOptions options, out IImageFormat format) public static Image Load(string path) public static Image Load(string path, out IImageFormat format) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, string path, out IImageFormat format) + public static Image Load(string path, DecoderOptions options, out IImageFormat format) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, string path) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, string path, IImageDecoder decoder) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(string path, IImageDecoder decoder) + public static Image Load(string path, DecoderOptions options) public static Image<TPixel> Load<TPixel>(string path) where TPixel : managed, IPixel<TPixel> public static Image<TPixel> Load<TPixel>(string path, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, string path, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> Load<TPixel>(string path, DecoderOptions optionsh, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, string path) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(string path, IImageDecoder decoder) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, string path, IImageDecoder decoder) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> Load<TPixel>(string path, DecoderOptions options) where TPixel : managed, IPixel<TPixel> public static Image Load(Stream stream, out IImageFormat format) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, Stream stream, out IImageFormat format) + public static Image Load(Stream stream, DecoderOptions options out IImageFormat format) public static Image Load(Stream stream) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Stream stream, IImageDecoder decoder) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, Stream stream, IImageDecoder decoder) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image Load(Configuration configuration, Stream stream) + public static Image Load(Stream stream, DecoderOptions options) public static Image<TPixel> Load<TPixel>(Stream stream) where TPixel : managed, IPixel<TPixel> public static Image<TPixel> Load<TPixel>(Stream stream, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Stream stream, IImageDecoder decoder) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, Stream stream, IImageDecoder decoder) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, Stream stream) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> Load<TPixel>(Stream stream, DecoderOptions options) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> Load<TPixel>(Configuration configuration, Stream stream, out IImageFormat format) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> Load<TPixel>(Stream stream, DecoderOptions options, out IImageFormat format) where TPixel : managed, IPixel<TPixel> public static Task<Image> LoadAsync(string path, CancellationToken cancellationToken = default) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image> LoadAsync(Configuration configuration, string path, CancellationToken cancellationToken = default) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image> LoadAsync(string path, IImageDecoder decoder, CancellationToken cancellationToken = default) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image> LoadAsync(Configuration configuration, string path, IImageDecoder decoder, CancellationToken cancellationToken = default) + public static Task<Image> LoadAsync(string path, DecoderOptions options, CancellationToken cancellationToken = default) public static Task<Image> LoadAsync(Stream stream, CancellationToken cancellationToken = default) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image> LoadAsync(Stream stream, IImageDecoder decoder, CancellationToken cancellationToken = default) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image> LoadAsync(Configuration configuration, Stream stream, IImageDecoder decoder, CancellationToken cancellationToken = default) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image> LoadAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken = default) + public static Task<Image> LoadAsync(Stream stream, DecoderOptions options, CancellationToken cancellationToken = default) public static Task<Image<TPixel>> LoadAsync<TPixel>(string path, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image<TPixel>> LoadAsync<TPixel>(string path, IImageDecoder decoder, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image<TPixel>> LoadAsync<TPixel>(Configuration configuration, string path, IImageDecoder decoder, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image<TPixel>> LoadAsync<TPixel>(Configuration configuration, string path, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + public static Task<Image<TPixel>> LoadAsync<TPixel>(string path, DecoderOptions options, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> public static Task<Image<TPixel>> LoadAsync<TPixel>(Stream stream, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image<TPixel>> LoadAsync<TPixel>(Stream stream, IImageDecoder decoder, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image<TPixel>> LoadAsync<TPixel>(Configuration configuration, Stream stream, IImageDecoder decoder, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<Image<TPixel>> LoadAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + public static Task<Image<TPixel>> LoadAsync<TPixel>(Stream stream, DecoderOptions options, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> public static Image<TPixel> LoadPixelData<TPixel>(TPixel[] data, int width, int height) where TPixel : managed, IPixel<TPixel> public static Image<TPixel> LoadPixelData<TPixel>(ReadOnlySpan<TPixel> data, int width, int height) where TPixel : managed, IPixel<TPixel> public static Image<TPixel> LoadPixelData<TPixel>(byte[] data, int width, int height) where TPixel : managed, IPixel<TPixel> public static Image<TPixel> LoadPixelData<TPixel>(ReadOnlySpan<byte> data, int width, int height) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> LoadPixelData<TPixel>(Configuration configuration, byte[] data, int width, int height) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> LoadPixelData<TPixel>(Configuration configuration, ReadOnlySpan<byte> data, int width, int height) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> LoadPixelData<TPixel>(Configuration configuration, TPixel[] data, int width, int height) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Image<TPixel> LoadPixelData<TPixel>(Configuration configuration, ReadOnlySpan<TPixel> data, int width, int height) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> LoadPixelData<TPixel>(byte[] data, int width, int height, DecoderOptions options) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> LoadPixelData<TPixel>(ReadOnlySpan<byte> data, int width, int height, DecoderOptions options) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> LoadPixelData<TPixel>(TPixel[] data, int width, int height, DecoderOptions options) where TPixel : managed, IPixel<TPixel> + public static Image<TPixel> LoadPixelData<TPixel>(ReadOnlySpan<TPixel> data, int width, int height, DecoderOptions options) where TPixel : managed, IPixel<TPixel> public static Task<(Image, IImageFormat)> LoadWithFormatAsync(Stream stream, CancellationToken cancellationToken = default) public static Task<(Image<TPixel>, IImageFormat)> LoadWithFormatAsync<TPixel>(Stream stream, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<(Image, IImageFormat)> LoadWithFormatAsync(Configuration configuration, Stream stream, CancellationToken cancellationToken = default) + public static Task<(Image, IImageFormat)> LoadWithFormatAsync( Stream stream, DecoderOptions options, CancellationToken cancellationToken = default) + [Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)] public static Task<(Image<TPixel>, IImageFormat)> LoadWithFormatAsync<TPixel>(Configuration configuration, Stream stream, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> + public static Task<(Image<TPixel>, IImageFormat)> LoadWithFormatAsync<TPixel>( Stream stream, DecoderOptions options, CancellationToken cancellationToken = default) where TPixel : managed, IPixel<TPixel> } }This will drastically reduce our api surface area (this removed 50 apis and add 26 new ones), and provides a class that can be used to add addition loading functionality without adding new API surface just a new field to
DecoderOptionsIt might be worth trying to get this added for / before #2076 so it doesn't add lots of new Size APIs.
We can retain backwards compat by not actually deleting these APIs yet and instead appling
[Obsolete("Format accessible from Metadata.OriginalImageFormat"),EditorBrowsable(EditorBrowsableState.Never)]and moving them to a new file for obsolete apis. WE can then remove them in a major or 2.Beta Was this translation helpful? Give feedback.
All reactions