コード例 #1
0
        public AnimatedGifFrame[] ReadAnimatedGif(Stream stream, out int x, out int y, out int comp, int req_comp)
        {
            try
            {
                x = y = comp = 0;

                var res = new List <AnimatedGifFrame>();
                _stream = stream;

                var context = new Stb.stbi__context();
                Stb.stbi__start_callbacks(context, _callbacks, null);

                if (Stb.stbi__gif_test(context) == 0)
                {
                    throw new Exception("Input stream is not GIF file.");
                }

                var g = new Stb.stbi__gif();

                do
                {
                    int ccomp;
                    var result = Stb.stbi__gif_load_next(context, g, &ccomp, req_comp);
                    if (result == null)
                    {
                        break;
                    }

                    comp = ccomp;
                    var c    = req_comp != 0 ? req_comp : comp;
                    var data = new byte[g.w * g.h * c];
                    Marshal.Copy(new IntPtr(result), data, 0, data.Length);
                    Operations.Free(result);

                    var frame = new AnimatedGifFrame
                    {
                        Data  = data,
                        Delay = g.delay
                    };
                    res.Add(frame);
                } while (true);

                Operations.Free(g._out_);

                if (res.Count > 0)
                {
                    x = g.w;
                    y = g.h;
                }

                return(res.ToArray());
            }
            finally
            {
                _stream = null;
            }
        }
コード例 #2
0
        public void Write(Image image, ImageWriterFormat format, Stream dest)
        {
            if (image?.Data == null)
            {
                throw new ArgumentNullException(nameof(image));
            }

            try
            {
                _stream = dest;
                fixed(byte *b = &image.Data[0])
                {
                    switch (format)
                    {
                    case ImageWriterFormat.Bmp:
                        Stb.stbi_write_bmp_to_func(WriteCallback, null, image.Width, image.Height, image.Comp, b);
                        break;

                    case ImageWriterFormat.Tga:
                        Stb.stbi_write_tga_to_func(WriteCallback, null, image.Width, image.Height, image.Comp, b);
                        break;

                    case ImageWriterFormat.Hdr:
                    {
                        var f = new float[image.Data.Length];
                        for (var i = 0; i < image.Data.Length; ++i)
                        {
                            f[i] = image.Data[i] / 255.0f;
                        }

                        fixed(float *fptr = f)
                        {
                            Stb.stbi_write_hdr_to_func(WriteCallback, null, image.Width, image.Height, image.Comp, fptr);
                        }
                    }
                    break;

                    case ImageWriterFormat.Png:
                        Stb.stbi_write_png_to_func(WriteCallback, null, image.Width, image.Height, image.Comp, b, image.Width * image.Comp);
                        break;

                    default:
                        throw new ArgumentOutOfRangeException(nameof(format), format, null);
                    }
                }
            }
            finally
            {
                _stream = null;
            }
        }
コード例 #3
0
        public Image Read(Stream stream, int req_comp = Stb.STBI_default)
        {
            _stream = stream;

            try
            {
                int x, y, comp;
                var result = Stb.stbi_load_from_callbacks(_callbacks, null, &x, &y, &comp, req_comp);

                var image = new Image
                {
                    Width      = x,
                    Height     = y,
                    SourceComp = comp,
                    Comp       = req_comp == Stb.STBI_default ? comp : req_comp
                };

                if (result == null)
                {
                    throw new Exception(Stb.LastError);
                }

                // Convert to array
                var data = new byte[x * y * image.Comp];
                Marshal.Copy(new IntPtr(result), data, 0, data.Length);
                Operations.Free(result);

                image.Data = data;

                return(image);
            }
            finally
            {
                _stream = null;
            }
        }