StbImageSharp

https://github.com/stbsharp/stbimagesharp
Admin
StbImageSharp is a C# port of the stb_image.h C library, designed to load images in JPG, PNG, BMP,...
Tokens:22,948
Snippets:309
Trust Score:6.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Example: Load HDR image from memory

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResultFloat.md

Usage example for loading an HDR image from a byte array.

```csharp
byte[] hdrData = File.ReadAllBytes("environment.hdr");
var image = ImageResultFloat.FromMemory(hdrData, ColorComponents.RedGreenBlue);
```

--------------------------------

### Instantiate stbi__context example

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImageContext.md

Basic usage of the constructor to wrap a file stream.

```csharp
using (var stream = File.OpenRead("image.png"))
{
    var context = new StbImage.stbi__context(stream);
    // Context is used internally by image loading functions
}
```

--------------------------------

### Low-level usage example

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImageContext.md

Advanced usage demonstrating manual stream manipulation and info retrieval.

```csharp
// Advanced usage for custom image loading
using (var stream = File.OpenRead("image.png"))
{
    var context = new StbImage.stbi__context(stream);
    
    // Rewind stream to start
    StbImage.stbi__rewind(context);
    
    // Read image info
    int x, y, comp;
    var infoResult = StbImage.stbi__info_main(context, &x, &y, &comp);
    
    if (infoResult != 0)
    {
        Console.WriteLine($"Image dimensions: {x}x{y}, components: {comp}");
    }
}
```

--------------------------------

### Example: Load HDR image from stream

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResultFloat.md

Usage example for loading an HDR image from a file stream and accessing pixel data.

```csharp
using (var stream = File.OpenRead("landscape.hdr"))
{
    var hdrImage = ImageResultFloat.FromStream(stream, ColorComponents.RedGreenBlue);
    Console.WriteLine($"HDR image: {hdrImage.Width}x{hdrImage.Height}");
    
    // Access first pixel RGB values
    float r = hdrImage.Data[0];
    float g = hdrImage.Data[1];
    float b = hdrImage.Data[2];
}
```

--------------------------------

### Usage example for ImageInfo

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageInfo.md

Demonstrates reading metadata from a file stream and accessing the resulting properties.

```csharp
using (var stream = File.OpenRead("image.png"))
{
    var info = ImageInfo.FromStream(stream);
    
    if (info.HasValue)
    {
        Console.WriteLine($"Image: {info.Value.Width}x{info.Value.Height}");
        Console.WriteLine($"Format: {info.Value.ColorComponents}");
        Console.WriteLine($"Depth: {info.Value.BitsPerChannel} bits per channel");
    }
    else
    {
        Console.WriteLine("Unknown image format");
    }
}
```

--------------------------------

### Access StbImageSharp public types

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/module-guide.md

Examples of declaring primary classes, enums, and internal context types used for image processing.

```csharp
// Classes
ImageResult result;
ImageResultFloat hdrResult;
ImageInfo info;

// Enums
ColorComponents format;

// Nested class
var context = new StbImage.stbi__context(stream);
```

--------------------------------

### Pixel Data Layout Example

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResult.md

Representation of the interleaved byte array layout for a 2x2 RGBA image.

```text
[R0, G0, B0, A0, R1, G1, B1, A1, R2, G2, B2, A2, R3, G3, B3, A3]
```

--------------------------------

### Load Image from Memory

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResult.md

Method signature and usage example for loading an image from a byte array.

```csharp
public static ImageResult FromMemory(byte[] data, 
    ColorComponents requiredComponents = ColorComponents.Default)
```

```csharp
byte[] buffer = File.ReadAllBytes("image.jpg");
var image = ImageResult.FromMemory(buffer, ColorComponents.RedGreenBlueAlpha);
```

--------------------------------

### Load Image from Stream

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResult.md

Method signature and usage example for loading an image from a file stream.

```csharp
public static ImageResult FromStream(Stream stream, 
    ColorComponents requiredComponents = ColorComponents.Default)
```

```csharp
using (var stream = File.OpenRead("image.png"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    Console.WriteLine($"Loaded {image.Width}x{image.Height} image");
}
```

--------------------------------

### Load Animated GIF Frames

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResult.md

Method signature and usage example for iterating through frames of an animated GIF.

```csharp
public static IEnumerable<AnimatedFrameResult> AnimatedGifFramesFromStream(Stream stream,
    ColorComponents requiredComponents = ColorComponents.Default)
```

```csharp
using (var stream = File.OpenRead("animation.gif"))
{
    foreach (var frame in ImageResult.AnimatedGifFramesFromStream(stream, 
        ColorComponents.RedGreenBlueAlpha))
    {
        Console.WriteLine($"Frame delay: {frame.DelayInMs}ms");
    }
}
```

--------------------------------

### Configure StbImageSharp for image loading

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/configuration.md

Demonstrates setting global configuration flags for image processing and resetting them after use.

```csharp
// Configure for graphics engine with specific requirements
StbImage.stbi_set_flip_vertically_on_load(1);  // DirectX origin
StbImage.stbi_set_unpremultiply_on_load(1);    // Straight alpha
StbImage.stbi_convert_iphone_png_to_rgb(1);    // Handle iOS PNGs

// Load image with configured settings
using (var stream = File.OpenRead("image.png"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    ProcessImage(image);
}

// Reset to defaults for other processing
StbImage.stbi_set_flip_vertically_on_load(0);
StbImage.stbi_set_unpremultiply_on_load(0);
StbImage.stbi_convert_iphone_png_to_rgb(0);
```

--------------------------------

### Configuration Methods

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/00_START_HERE.md

Static methods for configuring global image loading behavior.

```APIDOC
## Configuration

### StbImage.stbi_set_flip_vertically_on_load(int)
Configures whether images should be flipped vertically upon loading.

### StbImage.stbi_set_unpremultiply_on_load(int)
Configures whether to unpremultiply alpha on load.

### StbImage.stbi_convert_iphone_png_to_rgb(int)
Configures conversion of iPhone PNGs to RGB.

### StbImage.stbi_hdr_to_ldr_gamma(float)
Sets the gamma value for HDR to LDR conversion.
```

--------------------------------

### Initialize stbi__context

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImageContext.md

Constructor signature for creating a new context from a stream.

```csharp
public stbi__context(Stream stream)
```

--------------------------------

### Performance Benchmark Results

Source: https://github.com/stbsharp/stbimagesharp/blob/master/README.md

Total loading times for various image formats comparing StbImageSharp, Stb.Native, and ImageSharp.

```text
3 -- StbImageSharp - bmp: 34 ms, tga: 499 ms, png: 12028 ms, jpg: 2005 ms, psd: 0 ms, Total: 14566 ms
3 -- Stb.Native - bmp: 23 ms, tga: 401 ms, png: 10271 ms, jpg: 1419 ms, psd: 0 ms, Total: 12114 ms
3 -- ImageSharp - bmp: 24 ms, png: 10253 ms, jpg: 1782 ms, Total: 12059 ms
3 -- Total files processed - bmp: 7, tga: 41, png: 568, jpg: 170, psd: 1, Total: 787
3 -- StbImageSharp/Stb.Native matches/processed - 787/787
```

--------------------------------

### Image Configuration Methods

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/00_START_HERE.md

Static methods for configuring global image loading behavior, such as flipping or gamma correction.

```csharp
StbImage.stbi_set_flip_vertically_on_load(int)
StbImage.stbi_set_unpremultiply_on_load(int)
StbImage.stbi_convert_iphone_png_to_rgb(int)
StbImage.stbi_hdr_to_ldr_gamma(float)
// + thread-local variants
```

--------------------------------

### Configure Build Symbols for StbImageSharp

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/module-guide.md

Use these configurations in your project file or source to control the visibility of library types.

```xml
<!-- StbImageSharp.csproj not defining STBSHARP_INTERNAL -->
<!-- All public types are: public -->
```

```csharp
// Define STBSHARP_INTERNAL in your project
// This changes all public types to internal
// Allows embedding without namespace collisions
```

--------------------------------

### Loading Images from Sources

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Demonstrates loading images from file streams or byte arrays.

```csharp
// From file
using (var stream = File.OpenRead("image.png"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
}

// From memory
byte[] data = File.ReadAllBytes("image.png");
var image = ImageResult.FromMemory(data, ColorComponents.RedGreenBlueAlpha);
```

--------------------------------

### Configure HDR and LDR Conversion Parameters

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImage.md

Methods to set gamma and scale factors for HDR to LDR and LDR to HDR conversions.

```csharp
public static void stbi_hdr_to_ldr_gamma(float gamma)
```

```csharp
public static void stbi_hdr_to_ldr_scale(float scale)
```

```csharp
public static void stbi_ldr_to_hdr_gamma(float gamma)
```

```csharp
public static void stbi_ldr_to_hdr_scale(float scale)
```

--------------------------------

### Define StbImage Configuration Methods

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImage.md

Method signatures for configuring image processing flags in StbImageSharp.

```csharp
public static void stbi_set_flip_vertically_on_load(int flag_true_if_should_flip)
```

```csharp
public static void stbi_set_flip_vertically_on_load_thread(int flag_true_if_should_flip)
```

```csharp
public static void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply)
```

```csharp
public static void stbi_set_unpremultiply_on_load_thread(int flag_true_if_should_unpremultiply)
```

```csharp
public static void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)
```

```csharp
public static void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)
```

--------------------------------

### Configure Image Loading

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/README.md

Sets global configuration flags such as vertical flipping for specific coordinate systems.

```csharp
// Flip images vertically (for DirectX coordinate system)
StbImage.stbi_set_flip_vertically_on_load(1);

var image = ImageResult.FromStream(stream);

// Reset
StbImage.stbi_set_flip_vertically_on_load(0);
```

--------------------------------

### Global Configuration

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Methods to set global image loading behaviors such as flipping, unpremultiplying, and iPhone PNG conversion.

```APIDOC
## Global Configuration

### Methods
- **StbImage.stbi_set_flip_vertically_on_load(int)** - Sets whether to flip images vertically on load.
- **StbImage.stbi_set_unpremultiply_on_load(int)** - Sets whether to unpremultiply alpha on load.
- **StbImage.stbi_convert_iphone_png_to_rgb(int)** - Sets whether to convert iPhone PNGs to RGB.
```

--------------------------------

### Define StbImageSharp imports

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/module-guide.md

Include these namespaces to access the core functionality of the library.

```csharp
using System;
using System.IO;
using StbImageSharp;
```

--------------------------------

### Optimize Memory Usage for Image Loading

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Demonstrates choosing between stream-based loading for large files and memory-based loading for small buffers to manage managed memory overhead.

```csharp
// For large files: use streams (less memory at load time)
using (var stream = new FileStream("large.png", FileMode.Open, FileAccess.Read))
{
    var image = ImageResult.FromStream(stream);
    ProcessImage(image);
    // image data is copied to managed array
}

// For small buffers: load to memory first
if (fileSize < 1024 * 1024)  // < 1 MB
{
    byte[] data = File.ReadAllBytes("small.png");
    var image = ImageResult.FromMemory(data);
}
```

--------------------------------

### Thread-Local Configuration Methods

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/configuration.md

Methods for configuring image loading settings on a per-thread basis.

```APIDOC
## Thread-Local Settings

### Methods
- **stbi_set_flip_vertically_on_load_thread(int flag)**: Sets vertical flip behavior for the current thread.
- **stbi_set_unpremultiply_on_load_thread(int flag)**: Sets unpremultiply behavior for the current thread.
- **stbi_convert_iphone_png_to_rgb_thread(int flag)**: Sets iPhone PNG to RGB conversion behavior for the current thread.

### Parameters
- **flag** (int) - Required - 1 to enable the setting, 0 to disable.
```

--------------------------------

### Query PNG Metadata and Load Image

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/supported-formats.md

Demonstrates checking for 16-bit depth in a PNG file before loading it into an RGBA format.

```csharp
// Metadata query
var info = ImageInfo.FromStream(stream);
if (info?.BitsPerChannel == 16)
{
    Console.WriteLine("16-bit PNG detected");
}

// Load as RGBA
using (var stream = File.OpenRead("image.png"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
}
```

--------------------------------

### Load Images with ColorComponents

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/types.md

Demonstrates loading images using specific color components and accessing format properties.

```csharp
// Load PNG as RGBA
var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
Console.WriteLine($"Loaded as: {image.Comp}");  // Outputs: RedGreenBlueAlpha

// Load with source format unchanged
var image2 = ImageResult.FromStream(stream, ColorComponents.Default);
Console.WriteLine($"Source format: {image2.SourceComp}");
Console.WriteLine($"Actual format: {image2.Comp}");  // Same as SourceComp
```

--------------------------------

### Configure Thread-Local Settings

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Set thread-specific image loading behaviors to avoid global state conflicts.

```csharp
StbImage.stbi_set_flip_vertically_on_load_thread(1 or 0);
StbImage.stbi_set_unpremultiply_on_load_thread(1 or 0);
StbImage.stbi_convert_iphone_png_to_rgb_thread(1 or 0);
```

--------------------------------

### Configure Thread-Local Loading Flags

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/configuration.md

Demonstrates setting thread-specific configuration for flipping images vertically during load operations.

```csharp
// Thread 1 - with flipping
Task.Run(() =>
{
    StbImage.stbi_set_flip_vertically_on_load_thread(1);
    var image1 = ImageResult.FromStream(stream1);
});

// Thread 2 - without flipping
Task.Run(() =>
{
    StbImage.stbi_set_flip_vertically_on_load_thread(0);
    var image2 = ImageResult.FromStream(stream2);
});
```

--------------------------------

### Load images from file or memory in C#

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/00_START_HERE.md

Demonstrates loading an image from a file stream or a byte array. Requires the StbImageSharp namespace.

```csharp
using StbImageSharp;

// Load image from file
using (var stream = File.OpenRead("image.png"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    
    // image.Width, image.Height, image.Data (byte[])
}

// Or from memory
byte[] data = File.ReadAllBytes("image.png");
var image = ImageResult.FromMemory(data, ColorComponents.RedGreenBlueAlpha);
```

--------------------------------

### Load image as grayscale with alpha

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Use ColorComponents.GreyAlpha to load images with both luminance and transparency channels.

```csharp
var image = ImageResult.FromStream(stream, ColorComponents.GreyAlpha);
Console.WriteLine($"Data size: {image.Data.Length}");  // Width * Height * 2

// Access first pixel
byte gray = image.Data[0];
byte alpha = image.Data[1];

// Access second pixel
byte gray2 = image.Data[2];
byte alpha2 = image.Data[3];
```

--------------------------------

### Configure Unpremultiply Alpha on Load

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/configuration.md

Enable this to convert pre-multiplied alpha channels to straight alpha during the image loading process.

```csharp
StbImage.stbi_set_unpremultiply_on_load(1);
var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
```

--------------------------------

### Load image with default format

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Use ColorComponents.Default to load an image in its native format without conversion overhead.

```csharp
var image = ImageResult.FromStream(stream, ColorComponents.Default);
// image.Comp == image.SourceComp (no conversion)
```

--------------------------------

### Configure Global Image Loading Settings

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Sets global flags for coordinate systems, alpha premultiplication, and iPhone PNG compatibility. Ensure these are reset during shutdown to avoid side effects in other parts of the application.

```csharp
public class ImageLoader
{
    public static void Initialize()
    {
        // DirectX-style coordinate system (flip Y)
        StbImage.stbi_set_flip_vertically_on_load(1);
        
        // Straight alpha (not premultiplied)
        StbImage.stbi_set_unpremultiply_on_load(1);
        
        // Handle iPhone PNGs
        StbImage.stbi_convert_iphone_png_to_rgb(1);
    }
    
    public static ImageResult LoadTexture(string path)
    {
        using (var stream = File.OpenRead(path))
        {
            return ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
        }
    }
    
    public static void Shutdown()
    {
        // Reset to defaults
        StbImage.stbi_set_flip_vertically_on_load(0);
        StbImage.stbi_set_unpremultiply_on_load(0);
        StbImage.stbi_convert_iphone_png_to_rgb(0);
    }
}

// Usage:
ImageLoader.Initialize();
var texture = ImageLoader.LoadTexture("texture.png");
ImageLoader.Shutdown();
```

--------------------------------

### Batch load images from directory

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Iterates through files in a directory, loading each into a stream and processing it with error handling.

```csharp
foreach (var path in Directory.GetFiles("images/", "*.png"))
{
    try
    {
        using (var stream = File.OpenRead(path))
        {
            var image = ImageResult.FromStream(stream);
            Process(image);
        }
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine($"Failed: {path}");
    }
}
```

--------------------------------

### Implement Robust Image Loading

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Wraps image loading in a try-catch block to handle exceptions and retrieve specific failure reasons from the underlying library.

```csharp
public static bool TryLoadImage(string path, out ImageResult image)
{
    image = null;
    
    try
    {
        using (var stream = File.OpenRead(path))
        {
            image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
            return true;
        }
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine($"Failed to load {path}: {ex.Message}");
        string failureReason = StbImage.stbi__g_failure_reason;
        Console.WriteLine($"Failure reason: {failureReason}");
        return false;
    }
}
```

--------------------------------

### Load Multiple Images in C#

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Iterates through a directory to load PNG files into a dictionary, handling potential loading exceptions per file.

```csharp
var images = new Dictionary<string, ImageResult>();

foreach (var imagePath in Directory.GetFiles("images/", "*.png"))
{
    try
    {
        using (var stream = File.OpenRead(imagePath))
        {
            var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
            images[imagePath] = image;
        }
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine($"Failed to load {imagePath}: {ex.Message}");
    }
}

Console.WriteLine($"Loaded {images.Count} images");
```

--------------------------------

### Configure iPhone PNG Conversion

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/configuration.md

Enable this to handle the proprietary CgBI PNG format used by Apple devices by converting it to standard RGB.

```csharp
StbImage.stbi_convert_iphone_png_to_rgb(1);
var image = ImageResult.FromStream(stream);
```

--------------------------------

### Image Loading Methods

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/00_START_HERE.md

Methods for loading image data from streams or memory buffers, including support for animated GIFs and HDR formats.

```csharp
ImageResult.FromStream(stream, colorFormat)
ImageResult.FromMemory(data, colorFormat)
ImageResult.AnimatedGifFramesFromStream(stream, colorFormat)

ImageResultFloat.FromStream(stream, colorFormat)
ImageResultFloat.FromMemory(data, colorFormat)

ImageInfo.FromStream(stream) → ImageInfo?
```

--------------------------------

### Load with Original Format

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/00_START_HERE.md

Loads an image from a stream using its original color components.

```csharp
var image = ImageResult.FromStream(stream, ColorComponents.Default);
```

--------------------------------

### Load Animated GIF Frames in C#

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Iterates through GIF frames and clones the data to persist it, as the original frame data is reused during iteration.

```csharp
var frames = new List<AnimatedFrameResult>();
using (var stream = File.OpenRead("animation.gif"))
{
    foreach (var frame in ImageResult.AnimatedGifFramesFromStream(stream))
    {
        // Copy frame data (important: frame.Data is reused)
        frames.Add(new AnimatedFrameResult
        {
            Width = frame.Width,
            Height = frame.Height,
            Data = (byte[])frame.Data.Clone(),
            DelayInMs = frame.DelayInMs
        });
    }
}

Console.WriteLine($"Loaded {frames.Count} frames");
```

--------------------------------

### Core Classes in StbImageSharp

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/00_START_HERE.md

Primary classes used for image loading, metadata retrieval, and configuration.

```csharp
ImageResult              // Load standard images to byte[]
ImageResultFloat        // Load HDR images to float[]
ImageInfo              // Query image metadata
AnimatedFrameResult    // Single GIF frame with timing
ColorComponents        // Enum: Grey, GreyAlpha, RGB, RGBA
StbImage              // Static configuration class
```

--------------------------------

### Load image with RGBA guarantee

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Forces the output to always contain 4 bytes per pixel regardless of the source format.

```csharp
var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
// Always 4 bytes per pixel
byte[] rgba = image.Data;
```

--------------------------------

### Configure HDR Tone Mapping

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Adjust gamma and scale parameters for HDR to LDR and LDR to HDR conversions.

```csharp
StbImage.stbi_hdr_to_ldr_gamma(2.2f);
StbImage.stbi_hdr_to_ldr_scale(1.0f);
StbImage.stbi_ldr_to_hdr_gamma(2.2f);
StbImage.stbi_ldr_to_hdr_scale(1.0f);
```

--------------------------------

### stbi_convert_iphone_png_to_rgb_thread

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImage.md

Configures whether to convert iPhone-optimized PNGs to standard RGB format for the current thread only.

```APIDOC
## public static void stbi_convert_iphone_png_to_rgb_thread(int flag_true_if_should_convert)

### Description
Convert iPhone-optimized PNGs for the current thread only.

### Parameters
- **flag_true_if_should_convert** (int) - Required - Non-zero to enable, zero to disable (thread-local).
```

--------------------------------

### Allocate Buffer Based on Dimensions

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Uses image metadata to pre-calculate buffer size requirements before loading the image.

```csharp
using (var stream = File.OpenRead("image.png"))
{
    var info = ImageInfo.FromStream(stream);
    
    if (info.HasValue)
    {
        int expectedBytes = info.Value.Width * info.Value.Height * 4;  // RGBA
        byte[] buffer = new byte[expectedBytes];
        
        // Now safe to load image
        var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    }
}
```

--------------------------------

### Load image preserving source format

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Uses the default color components to maintain the original image format, requiring a switch statement to handle different pixel byte counts.

```csharp
var image = ImageResult.FromStream(stream, ColorComponents.Default);
// Format preserved from source
switch (image.Comp)
{
    case ColorComponents.Grey:
        // 1 byte per pixel
        break;
    case ColorComponents.RedGreenBlueAlpha:
        // 4 bytes per pixel
        break;
}
```

--------------------------------

### Load image as grayscale

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Use ColorComponents.Grey to load images as single-channel luminance data.

```csharp
var image = ImageResult.FromStream(stream, ColorComponents.Grey);
Console.WriteLine($"Data size: {image.Data.Length}");  // Width * Height * 1

// Access first pixel (grayscale value)
byte gray = image.Data[0];
```

--------------------------------

### Configure HDR to LDR Tone Mapping

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/configuration.md

Sets the gamma and scale parameters before loading an HDR image into an ImageResultFloat object.

```csharp
// Adjust tone mapping parameters
StbImage.stbi_hdr_to_ldr_gamma(2.2f);
StbImage.stbi_hdr_to_ldr_scale(1.0f);

var image = ImageResultFloat.FromStream(stream);
```

--------------------------------

### Load and Analyze HDR Images in C#

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Loads an HDR image into a float array and iterates through the pixel data to find the maximum brightness value.

```csharp
using (var stream = File.OpenRead("environment.hdr"))
{
    var hdrImage = ImageResultFloat.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    
    float maxBrightness = 0;
    for (int i = 0; i < hdrImage.Data.Length; i += 4)
    {
        float r = hdrImage.Data[i];
        float g = hdrImage.Data[i + 1];
        float b = hdrImage.Data[i + 2];
        float brightness = (r + g + b) / 3f;
        
        if (brightness > maxBrightness)
            maxBrightness = brightness;
    }
    
    Console.WriteLine($"Max brightness: {maxBrightness}");
}
```

--------------------------------

### Load a Standard Image

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/README.md

Loads an image from a file stream specifying the desired color components.

```csharp
using (var stream = File.OpenRead("image.png"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    Console.WriteLine($"Image: {image.Width}x{image.Height}");
}
```

--------------------------------

### Load HDR image from stream

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResultFloat.md

Method signature for loading HDR data from a stream.

```csharp
public static ImageResultFloat FromStream(Stream stream,
    ColorComponents requiredComponents = ColorComponents.Default)
```

--------------------------------

### Stream reading methods

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImageContext.md

Static methods provided by StbImage for performing low-level operations on a context.

```csharp
public static byte stbi__get8(stbi__context s)       // Read single byte
public static void stbi__skip(stbi__context s, int skip)  // Skip bytes
public static void stbi__rewind(stbi__context s)     // Reset to start
public static int stbi__at_eof(stbi__context s)      // Check end-of-stream
public static int stbi__getn(stbi__context s, byte* buf, int size)  // Read bytes
```

--------------------------------

### Configure Vertical Flipping for Image Loading

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImage.md

Enable vertical flipping globally before loading an image, then disable it afterwards to restore default behavior.

```csharp
StbImage.stbi_set_flip_vertically_on_load(1);
var image = ImageResult.FromStream(stream);
StbImage.stbi_set_flip_vertically_on_load(0);
```

--------------------------------

### Image Loading Methods

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/00_START_HERE.md

Methods for loading image data from streams or memory buffers into standard or floating-point result objects.

```APIDOC
## Image Loading

### ImageResult.FromStream(stream, colorFormat)
Loads an image from a stream into a byte array.

### ImageResult.FromMemory(data, colorFormat)
Loads an image from a byte array into a byte array.

### ImageResult.AnimatedGifFramesFromStream(stream, colorFormat)
Loads animated GIF frames from a stream.

### ImageResultFloat.FromStream(stream, colorFormat)
Loads an HDR image from a stream into a float array.

### ImageResultFloat.FromMemory(data, colorFormat)
Loads an HDR image from a byte array into a float array.

### ImageInfo.FromStream(stream)
Queries image metadata without loading pixel data.
```

--------------------------------

### Load TGA Image and Query Bits per Channel

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/supported-formats.md

Loads a TGA file and retrieves the bits per channel metadata.

```csharp
using (var stream = File.OpenRead("texture.tga"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    Console.WriteLine($"Bits per channel: {ImageInfo.FromStream(stream)?.BitsPerChannel}");
}
```

--------------------------------

### stbi_convert_iphone_png_to_rgb

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImage.md

Configures whether to convert iPhone-optimized PNGs to standard RGB format globally.

```APIDOC
## public static void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert)

### Description
Convert iPhone-optimized PNGs to standard RGB format.

### Parameters
- **flag_true_if_should_convert** (int) - Required - Non-zero to enable, zero to disable.
```

--------------------------------

### Handle Loading Errors

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Implement error handling for image loading and format detection.

```csharp
try
{
    var image = ImageResult.FromStream(stream);
}
catch (InvalidOperationException ex)
{
    string reason = StbImage.stbi__g_failure_reason;
    Console.WriteLine($"Load failed: {reason}");
}

// For format detection
var info = ImageInfo.FromStream(stream);
if (info == null)
{
    Console.WriteLine("Unknown format");
}
```

--------------------------------

### Load Animated GIF

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/README.md

Iterates through frames of an animated GIF file.

```csharp
using (var stream = File.OpenRead("animation.gif"))
{
    foreach (var frame in ImageResult.AnimatedGifFramesFromStream(stream))
    {
        Console.WriteLine($"Delay: {frame.DelayInMs}ms");
        ProcessFrame(frame.Data, frame.Width, frame.Height);
    }
}
```

--------------------------------

### StbImage.stbi_convert_iphone_png_to_rgb(int flag)

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/configuration.md

Configures conversion of iPhone-optimized PNG CgBI format to standard RGB.

```APIDOC
## StbImage.stbi_convert_iphone_png_to_rgb(int flag)

### Description
Controls conversion of iPhone-optimized PNG CgBI format to standard RGB. This handles the proprietary iPhone PNG format used by Apple.

### Parameters
- **flag_true_if_should_convert** (int) - Required - 0 (disabled), non-zero (enabled). Default is 0.

### Example
```csharp
StbImage.stbi_convert_iphone_png_to_rgb(1);
var image = ImageResult.FromStream(stream);
```
```

--------------------------------

### Handle Errors

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/00_START_HERE.md

Catches loading exceptions and retrieves the specific failure reason from the library state.

```csharp
try
{
    var image = ImageResult.FromStream(stream);
}
catch (InvalidOperationException ex)
{
    string reason = StbImage.stbi__g_failure_reason;
    Console.WriteLine($"Load failed: {reason}");
}
```

--------------------------------

### Load image as RGBA

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Use ColorComponents.RedGreenBlueAlpha to load images with four channels including transparency.

```csharp
var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
Console.WriteLine($"Data size: {image.Data.Length}");  // Width * Height * 4

// Access first pixel RGBA
byte r = image.Data[0];
byte g = image.Data[1];
byte b = image.Data[2];
byte a = image.Data[3];

// Access second pixel RGBA
byte r2 = image.Data[4];
byte g2 = image.Data[5];
byte b2 = image.Data[6];
byte a2 = image.Data[7];
```

--------------------------------

### Access pixel data by component

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Calculate the byte index for a specific pixel channel using the image width and the component count derived from the image format.

```csharp
public static byte GetPixelByte(ImageResult image, int x, int y, int component)
{
    int pixelsPerRow = image.Width;
    int bytesPerPixel = (int)image.Comp;
    int pixelIndex = y * pixelsPerRow + x;
    int byteIndex = pixelIndex * bytesPerPixel + component;
    return image.Data[byteIndex];
}

// Usage
byte r = GetPixelByte(image, 10, 5, 0);  // Red channel at (10, 5)
byte g = GetPixelByte(image, 10, 5, 1);  // Green channel at (10, 5)
```

--------------------------------

### Load image as RGB

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Use ColorComponents.RedGreenBlue to load images as three-channel color data without alpha.

```csharp
var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlue);
Console.WriteLine($"Data size: {image.Data.Length}");  // Width * Height * 3

// Access first pixel RGB
byte r = image.Data[0];
byte g = image.Data[1];
byte b = image.Data[2];

// Access second pixel RGB
byte r2 = image.Data[3];
byte g2 = image.Data[4];
byte b2 = image.Data[5];
```

--------------------------------

### Load HDR image from memory

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResultFloat.md

Method signature for loading HDR data from a byte array.

```csharp
public static ImageResultFloat FromMemory(byte[] data,
    ColorComponents requiredComponents = ColorComponents.Default)
```

--------------------------------

### Load HDR Image

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/README.md

Loads high dynamic range images using floating point data representation.

```csharp
using (var stream = File.OpenRead("environment.hdr"))
{
    var hdr = ImageResultFloat.FromStream(stream, ColorComponents.RedGreenBlue);
    
    float r = hdr.Data[0];  // First pixel red channel
    float g = hdr.Data[1];  // First pixel green channel
    float b = hdr.Data[2];  // First pixel blue channel
}
```

--------------------------------

### Load HDR Image

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/00_START_HERE.md

Loads high dynamic range images using floating-point data representation.

```csharp
var hdr = ImageResultFloat.FromStream(stream, ColorComponents.RedGreenBlue);
float r = hdr.Data[0];  // First pixel red channel
```

--------------------------------

### Load HDR image from stream

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/module-guide.md

Use ImageResultFloat.FromStream to load High Dynamic Range images into a float array.

```csharp
var hdr = ImageResultFloat.FromStream(stream, ColorComponents.RedGreenBlue);
```

--------------------------------

### Iterating Animated GIF Frames

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/AnimatedFrameResult.md

Demonstrates how to iterate through frames of an animated GIF using ImageResult.AnimatedGifFramesFromStream. Note that the Data array is reused, so copy it if persistence is required.

```csharp
using (var stream = File.OpenRead("animation.gif"))
{
    int totalDuration = 0;
    int frameCount = 0;
    
    foreach (var frame in ImageResult.AnimatedGifFramesFromStream(stream, 
        ColorComponents.RedGreenBlueAlpha))
    {
        Console.WriteLine($"Frame {frameCount}: {frame.Width}x{frame.Height}, " +
                         $"delay {frame.DelayInMs}ms");
        
        totalDuration += frame.DelayInMs;
        frameCount++;
    }
    
    Console.WriteLine($"Total animation duration: {totalDuration}ms");
}
```

--------------------------------

### ImageResultFloat API

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/module-guide.md

The entry point for loading High Dynamic Range (HDR) images into floating-point arrays.

```APIDOC
## ImageResultFloat.FromStream(Stream, ColorComponents)

### Description
Loads an HDR image from a stream into an ImageResultFloat object.

### Parameters
- **stream** (Stream) - Required - The input stream containing HDR image data.
- **requiredComponents** (ColorComponents) - Required - The desired color format.

## ImageResultFloat.FromMemory(byte[], ColorComponents)

### Description
Loads an HDR image from a byte array into an ImageResultFloat object.

### Parameters
- **data** (byte[]) - Required - The byte array containing HDR image data.
- **requiredComponents** (ColorComponents) - Required - The desired color format.
```

--------------------------------

### Check Image Format Without Loading

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Retrieves image metadata such as dimensions and color components without decoding the full image data.

```csharp
using (var stream = File.OpenRead("image.png"))
{
    var info = ImageInfo.FromStream(stream);
    
    if (info == null)
    {
        Console.WriteLine("Unknown image format");
    }
    else
    {
        Console.WriteLine($"Dimensions: {info.Value.Width}x{info.Value.Height}");
        Console.WriteLine($"Format: {info.Value.ColorComponents}");
        Console.WriteLine($"Bits per channel: {info.Value.BitsPerChannel}");
    }
}
```

--------------------------------

### Configure Vertical Flip on Load

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/configuration.md

Use this to toggle vertical flipping of images during loading, useful for matching coordinate systems like OpenGL or DirectX.

```csharp
// Enable vertical flip globally
StbImage.stbi_set_flip_vertically_on_load(1);

var image = ImageResult.FromStream(stream);

// Disable vertical flip
StbImage.stbi_set_flip_vertically_on_load(0);
```

--------------------------------

### Load JPEG Image with StbImageSharp

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/supported-formats.md

Loads a JPEG file from a stream, requesting RGBA output. Note that JPEG source data does not contain an alpha channel.

```csharp
using (var stream = File.OpenRead("photo.jpg"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    // image.SourceComp = RedGreenBlue (JPEG has no alpha)
    // image.Comp = RedGreenBlueAlpha (requested RGBA)
}
```

--------------------------------

### Load standard image from stream

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/module-guide.md

Use ImageResult.FromStream to load standard image formats like JPG, PNG, or GIF into a byte array.

```csharp
var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
```

--------------------------------

### ColorComponents Properties

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Properties representing the original source format and the final format after conversion.

```csharp
// Source format (as stored in file)
public ColorComponents SourceComp { get; set; }

// Actual format (after requested conversion)
public ColorComponents Comp { get; set; }
```

--------------------------------

### ImageResultFloat API Signatures

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Methods for loading floating-point image data from streams or memory.

```csharp
public static ImageResultFloat FromStream(Stream stream,
    ColorComponents requiredComponents = ColorComponents.Default)

public static ImageResultFloat FromMemory(byte[] data,
    ColorComponents requiredComponents = ColorComponents.Default)
```

--------------------------------

### Integrate with MonoGame Texture2D

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/README.md

Loads an image from a stream and applies the pixel data to a MonoGame Texture2D object.

```csharp
using (var stream = File.OpenRead("texture.png"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    
    var texture = new Texture2D(graphicsDevice, image.Width, image.Height);
    texture.SetData(image.Data);
}
```

--------------------------------

### Auto-detect image format in C#

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/supported-formats.md

Use ImageResult.FromStream to automatically identify and load an image format from a stream.

```csharp
var image = ImageResult.FromStream(stream);  // Auto-detects format
```

--------------------------------

### Load Animated GIF Frames Safely

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Iterates through animated GIF frames and clones the data to ensure it remains valid after the stream is closed or the iterator advances.

```csharp
public static List<AnimatedFrameResult> LoadAnimatedGif(string path)
{
    var frames = new List<AnimatedFrameResult>();
    
    try
    {
        using (var stream = File.OpenRead(path))
        {
            foreach (var frame in ImageResult.AnimatedGifFramesFromStream(stream))
            {
                // Copy data to preserve across iterations
                frames.Add(new AnimatedFrameResult
                {
                    Width = frame.Width,
                    Height = frame.Height,
                    Data = (byte[])frame.Data.Clone(),
                    DelayInMs = frame.DelayInMs,
                    SourceComp = frame.SourceComp,
                    Comp = frame.Comp
                });
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Failed to load GIF: {ex.Message}");
    }
    
    return frames;
}
```

--------------------------------

### Load Static GIF Image

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/supported-formats.md

Loads the first frame of a GIF file into an ImageResult object.

```csharp
using (var stream = File.OpenRead("image.gif"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    // Loads first frame of animated GIF
}
```

--------------------------------

### Thread-safe image loading

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Uses Parallel.ForEach to load images concurrently, ensuring thread-specific settings like vertical flipping are applied.

```csharp
Parallel.ForEach(paths, path =>
{
    StbImage.stbi_set_flip_vertically_on_load_thread(1);
    var image = ImageResult.FromStream(File.OpenRead(path));
    Process(image);
});
```

--------------------------------

### ImageResultFloat.FromMemory

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResultFloat.md

Loads an HDR image from a byte array as floating-point data.

```APIDOC
## public static ImageResultFloat FromMemory(byte[] data, ColorComponents requiredComponents = ColorComponents.Default)

### Description
Loads an HDR image from a byte array as floating-point data.

### Parameters
- **data** (byte[]) - Required - Complete HDR image file data as byte array
- **requiredComponents** (ColorComponents) - Optional - Desired color component format for output

### Returns
ImageResultFloat object with decoded floating-point pixel data

### Throws
- InvalidOperationException: If image format is unsupported or decoding fails

### Example
```csharp
byte[] hdrData = File.ReadAllBytes("environment.hdr");
var image = ImageResultFloat.FromMemory(hdrData, ColorComponents.RedGreenBlue);
```
```

--------------------------------

### Define stbi__context class

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImageContext.md

The class definition for stbi__context, including its internal fields and stream reference.

```csharp
public class stbi__context
{
    private readonly Stream _stream;
    
    public byte[] _tempBuffer;
    public int img_n;
    public int img_out_n;
    public uint img_x;
    public uint img_y;
    
    public stbi__context(Stream stream)
    public Stream Stream { get; }
}
```

--------------------------------

### Define ColorComponents for image output

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/README.md

Specifies the desired pixel format for the decoded image. Using Default is the fastest option as it avoids conversion.

```csharp
ColorComponents.Default              // No conversion (fastest)
ColorComponents.Grey                 // Grayscale (1 byte/pixel)
ColorComponents.GreyAlpha            // Grayscale+Alpha (2 bytes/pixel)
ColorComponents.RedGreenBlue         // RGB (3 bytes/pixel)
ColorComponents.RedGreenBlueAlpha    // RGBA (4 bytes/pixel)
```

--------------------------------

### Access img_x field

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImageContext.md

Field representing the image width in pixels.

```csharp
public uint img_x;
```

--------------------------------

### ImageResult API Signatures

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Methods for loading images and animated GIFs from streams or memory with optional color component conversion.

```csharp
// Method signature
public static ImageResult FromStream(Stream stream, 
    ColorComponents requiredComponents = ColorComponents.Default)

public static ImageResult FromMemory(byte[] data,
    ColorComponents requiredComponents = ColorComponents.Default)

public static IEnumerable<AnimatedFrameResult> AnimatedGifFramesFromStream(
    Stream stream,
    ColorComponents requiredComponents = ColorComponents.Default)
```

--------------------------------

### Define Color Components

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Enumeration of available color formats and their corresponding channel counts.

```csharp
ColorComponents.Default              // Use source format
ColorComponents.Grey                 // 1 channel (L)
ColorComponents.GreyAlpha            // 2 channels (LA)
ColorComponents.RedGreenBlue         // 3 channels (RGB)
ColorComponents.RedGreenBlueAlpha    // 4 channels (RGBA)
```

--------------------------------

### ImageResultFloat.FromStream

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ImageResultFloat.md

Loads an HDR image from a Stream as floating-point data.

```APIDOC
## public static ImageResultFloat FromStream(Stream stream, ColorComponents requiredComponents = ColorComponents.Default)

### Description
Loads an HDR image from a Stream as floating-point data.

### Parameters
- **stream** (Stream) - Required - Input stream containing HDR image data
- **requiredComponents** (ColorComponents) - Optional - Desired color component format for output. If Default, uses source format.

### Returns
ImageResultFloat object with decoded floating-point pixel data

### Throws
- InvalidOperationException: If image format is unsupported or decoding fails.

### Example
```csharp
using (var stream = File.OpenRead("landscape.hdr"))
{
    var hdrImage = ImageResultFloat.FromStream(stream, ColorComponents.RedGreenBlue);
    Console.WriteLine($"HDR image: {hdrImage.Width}x{hdrImage.Height}");
    float r = hdrImage.Data[0];
    float g = hdrImage.Data[1];
    float b = hdrImage.Data[2];
}
```
```

--------------------------------

### Load BMP Image

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/supported-formats.md

Loads a BMP file from a stream into an RGBA format.

```csharp
using (var stream = File.OpenRead("image.bmp"))
{
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
}
```

--------------------------------

### Load Image with Forced RGBA Format

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Forces the image loader to output RGBA regardless of the source format, ensuring a consistent 4-byte-per-pixel structure.

```csharp
using (var stream = File.OpenRead("image.png"))
{
    // Load as RGBA regardless of source
    var image = ImageResult.FromStream(stream, ColorComponents.RedGreenBlueAlpha);
    
    Console.WriteLine($"Source: {image.SourceComp}");
    Console.WriteLine($"Loaded as: {image.Comp}");
    
    // Safe to assume 4 bytes per pixel
    int pixelCount = image.Width * image.Height;
}
```

--------------------------------

### Monitor Native Allocations

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/usage-patterns.md

Tracks native memory usage by comparing the NativeAllocations property before and after an image load operation.

```csharp
int allocationsBefore = StbImage.NativeAllocations;

var image = ImageResult.FromStream(stream);

int allocationsAfter = StbImage.NativeAllocations;
Console.WriteLine($"Native allocations: {allocationsAfter - allocationsBefore}");
```

--------------------------------

### Query Image Metadata

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/README.md

Retrieves image dimensions and format information without loading the full pixel data.

```csharp
var info = ImageInfo.FromStream(stream);
if (info.HasValue)
{
    Console.WriteLine($"Dimensions: {info.Value.Width}x{info.Value.Height}");
    Console.WriteLine($"Format: {info.Value.ColorComponents}");
    Console.WriteLine($"Bits: {info.Value.BitsPerChannel}");
}
```

--------------------------------

### Access diagnostic properties

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Retrieves native memory allocation counts and the last recorded error message.

```csharp
// Native allocation tracking
int allocations = StbImage.NativeAllocations;

// Last error message
string error = StbImage.stbi__g_failure_reason;
```

--------------------------------

### HDR Tone Mapping

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Configuration methods for HDR to LDR and LDR to HDR conversion parameters.

```APIDOC
## HDR Tone Mapping

### Methods
- **StbImage.stbi_hdr_to_ldr_gamma(float)** - Sets gamma for HDR to LDR conversion.
- **StbImage.stbi_hdr_to_ldr_scale(float)** - Sets scale for HDR to LDR conversion.
- **StbImage.stbi_ldr_to_hdr_gamma(float)** - Sets gamma for LDR to HDR conversion.
- **StbImage.stbi_ldr_to_hdr_scale(float)** - Sets scale for LDR to HDR conversion.
```

--------------------------------

### Accessing Image Properties

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Retrieves dimensions, pixel data, and color format information from loaded image objects.

```csharp
// ImageResult and ImageResultFloat
int width = image.Width;
int height = image.Height;
byte[] pixelData = image.Data;              // ImageResult only
float[] pixelData = image.Data;             // ImageResultFloat only
ColorComponents sourceFormat = image.SourceComp;
ColorComponents loadedFormat = image.Comp;

// AnimatedFrameResult (extends ImageResult)
int frameDelayMs = frame.DelayInMs;
```

--------------------------------

### Core Types and Enums

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/quick-reference.md

Defines the primary classes and enums used for image data and metadata.

```csharp
using StbImageSharp;

// Main classes
ImageResult image;              // Standard image data (byte[])
ImageResultFloat hdrImage;      // HDR image data (float[])
ImageInfo? metadata;            // Image metadata

// Enum
ColorComponents format;         // Color format specifier
```

--------------------------------

### Color Component Mapping Constants

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/StbImage.md

Defines integer constants used for mapping color components in image processing.

```csharp
public const int STBI_default = 0;
public const int STBI_grey = 1;
public const int STBI_grey_alpha = 2;
public const int STBI_rgb = 3;
public const int STBI_rgb_alpha = 4;
```

--------------------------------

### Retrieve image metadata

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/module-guide.md

Use ImageInfo.FromStream to read image dimensions and color information without loading the full pixel data.

```csharp
var info = ImageInfo.FromStream(stream);
if (info.HasValue)
{
    Console.WriteLine($"{info.Value.Width}x{info.Value.Height}");
}
```

--------------------------------

### ImageResultFloat.FromStream

Source: https://github.com/stbsharp/stbimagesharp/blob/master/_autodocs/api-reference/ColorComponents.md

Loads a floating-point image from a stream with optional color component conversion.

```APIDOC
## ImageResultFloat.FromStream

### Description
Loads a floating-point image from a stream, applying the specified color component conversion.

### Method
public static ImageResultFloat FromStream(Stream stream, ColorComponents requiredComponents = ColorComponents.Default)

### Parameters
- **stream** (Stream) - Required - The input stream containing image data.
- **requiredComponents** (ColorComponents) - Optional - The desired color format for the output image.
```
Tokens:
Raw