Misaki.HighPerformance/Misaki.HighPerformance.Image/StbImage.cs

using Misaki.HighPerformance.Image.Runtime;
using System;
using System.IO;
using System.Runtime.InteropServices;

namespace Misaki.HighPerformance.Image;

public static unsafe partial class StbImage
{
    public static string stbi__g_failure_reason;
    public static readonly char[] stbi__parse_png_file_invalid_chunk = new char[25];

    public static int NativeAllocations
    {
        get
        {
            return MemoryStats.Allocations;
        }
    }

    public class stbi__context
    {
        private readonly Stream _stream;

        public byte[] _tempBuffer;
        public int img_n = 0;
        public int img_out_n = 0;
        public uint img_x = 0;
        public uint img_y = 0;

        public stbi__context(Stream stream)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            _stream = stream;
        }

        public Stream Stream
        {
            get
            {
                return _stream;
            }
        }
    }

    private static int stbi__err(string str)
    {
        stbi__g_failure_reason = str;
        return 0;
    }

    public static byte stbi__get8(stbi__context s)
    {
        var b = s.Stream.ReadByte();
        if (b == -1)
        {
            return 0;
        }

        return (byte)b;
    }

    public static void stbi__skip(stbi__context s, int skip)
    {
        s.Stream.Seek(skip, SeekOrigin.Current);
    }

    public static void stbi__rewind(stbi__context s)
    {
        s.Stream.Seek(0, SeekOrigin.Begin);
    }

    public static int stbi__at_eof(stbi__context s)
    {
        return s.Stream.Position == s.Stream.Length ? 1 : 0;
    }

    public static int stbi__getn(stbi__context s, byte* buf, int size)
    {
        if (s._tempBuffer == null ||
            s._tempBuffer.Length < size)
        {
            s._tempBuffer = new byte[size * 2];
        }

        var result = s.Stream.Read(s._tempBuffer, 0, size);
        Marshal.Copy(s._tempBuffer, 0, new IntPtr(buf), result);

        return result;
    }
}