CPBitmap Reader

cpbitmap.cs

using System;
using System.IO;
using System.Threading.Tasks;

namespace CodeRinseRepeat.CPBitmapReader
{
    public sealed class CPBitmap
    {
        public int Width { get; set; }
        public int Height { get; set; }
        public byte[] Data { get; set; }

        private CPBitmap() { }

        public static async Task<CPBitmap> ReadAsync(Stream stream)
        {
            // We need to be able to seek the stream--the data we want starts
            // at -24 bytes from the end. If we can't seek the stream, read it
            // into memory, pass it off.
            if (!stream.CanRead)
                throw new ArgumentException(
                    "Given stream cannot be read.",
                    nameof(stream)
                );

            if (!stream.CanSeek) {
                var memoryStream = new MemoryStream();
                await stream.CopyToAsync(memoryStream);
                stream = memoryStream;
            }

            stream.Seek(-24, SeekOrigin.End);

            // We need to grab a BinaryReader so we can read the W & H. The first 4 bytes 
            // we don't care about, the following 8 are the width and height.
            var reader = new BinaryReader(stream);

            reader.ReadInt32();
            int width = reader.ReadInt32(), height = reader.ReadInt32();

            // Now that we know the W&H, we need to rewind the stream back to the beginning.
            stream.Seek(0, SeekOrigin.Begin);

            // We'll use a MemoryStream to make writing the data a little easier.
            var imageData = new MemoryStream();

            // CPBitmaps are BGRA32 data, so each scanline is width * 4 bytes.
            var scanlineBuffer = new byte[width * 4];

            for (var i = 0; i < height; i++) {
                // Each scanline is composed of `width` 4-byte pixels, with some padding. I don't
                // have enough test data to verify the padding, but I'm going to guess it's always
                // a full 8 bytes.
                var read = await stream.ReadAsync(scanlineBuffer, 0, scanlineBuffer.Length);
                await imageData.WriteAsync(scanlineBuffer, 0, read);
            }

            return new CPBitmap {
                Width = width,
                Height = height,
                Data = imageData.ToArray()
            };
        }

        private static Task<CPBitmap> ReadAsync(byte[] data)
        {
            // Wrap a stream over the data...
            var memoryStream = new MemoryStream(data);
            return ReadAsync(memoryStream);
        }
    }
}