Image.cpp

/*
 * Copyright (C) 2023 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "Image.h"

#include <fstream>
#include <ostream>

namespace gfxstream {

// Loads:
//   rgbaPixels[0] = R for x:0 y:0
//   rgbaPixels[1] = G for x:0 y:0
//   rgbaPixels[2] = B for x:0 y:0
//   rgbaPixels[3] = A for x:0 y:0
gfxstream::expected<RGBAImage, std::string> LoadRGBAFromBitmapFile(
        const std::string& filename) {
    std::ifstream bitmap(filename, std::ofstream::in | std::ofstream::binary);
    if (!bitmap.is_open()) {
        return gfxstream::unexpected("Failed to open " + filename);
    }

    std::vector<char> bitmapBytes((std::istreambuf_iterator<char>(bitmap)),
                                   std::istreambuf_iterator<char>());

    if (bitmapBytes[0] != 0x42) {
        return gfxstream::unexpected("Failed to open " + filename + ": invalid bitmap file?");
    }
    if (bitmapBytes[1] != 0x4D) {
        return gfxstream::unexpected("Failed to open " + filename + ": invalid bitmap file?");
    }

    auto ReadUint16AtByte = [&](const uint32_t offset) {
        return *reinterpret_cast<uint16_t*>(&bitmapBytes[offset]);
    };
    auto ReadUint32AtByte = [&](const uint32_t offset) {
        return *reinterpret_cast<uint32_t*>(&bitmapBytes[offset]);
    };

    uint32_t w = ReadUint32AtByte(18);
    uint32_t h = ReadUint32AtByte(22);

    uint32_t planes = ReadUint16AtByte(26);
    if (planes != 1) {
        return gfxstream::unexpected("Failed to open " + filename + ": unhandled number of planes.");
    }
    uint32_t bpp = ReadUint16AtByte(28);
    if (bpp != 32) {
        return gfxstream::unexpected("Failed to open " + filename + ": unhandled bpp.");
    }

    uint32_t rChannelMask = ReadUint32AtByte(54);
    uint32_t gChannelMask = ReadUint32AtByte(58);
    uint32_t bChannelMask = ReadUint32AtByte(62);
    uint32_t aChannelMask = ReadUint32AtByte(66);

    RGBAImage out;
    out.width = w;
    out.height = h;
    out.pixels.reserve(w * h * 4);

    uint32_t bitmapHeadersSize = ReadUint32AtByte(10);
    uint32_t bitmapPixelsOffset = bitmapHeadersSize;

    auto GetChannel = [](uint32_t pixel, uint32_t channelMask) {
        if (channelMask == 0) {
            return static_cast<uint8_t>(0xFF);
        } else if (channelMask == 0x000000FF) {
            return static_cast<uint8_t>((pixel & channelMask) >> 0);
        } else if (channelMask == 0x0000FF00) {
            return static_cast<uint8_t>((pixel & channelMask) >> 8);
        } else if (channelMask == 0x00FF0000) {
            return static_cast<uint8_t>((pixel & channelMask) >> 16);
        } else if (channelMask == 0xFF000000) {
            return static_cast<uint8_t>((pixel & channelMask) >> 24);
        } else {
            return static_cast<uint8_t>(0);
        }
    };

    for (uint32_t y = 0; y < h; y++) {
        uint32_t flippedY = h - y - 1;
        for (uint32_t x = 0; x < w; x++) {
            uint32_t pixelOffset = (flippedY * w * 4) + (x * 4);
            uint32_t pixel = ReadUint32AtByte(bitmapPixelsOffset + pixelOffset);

            uint8_t r = GetChannel(pixel, rChannelMask);
            uint8_t g = GetChannel(pixel, gChannelMask);
            uint8_t b = GetChannel(pixel, bChannelMask);
            uint8_t a = GetChannel(pixel, aChannelMask);

            out.pixels.push_back(r);
            out.pixels.push_back(g);
            out.pixels.push_back(b);
            out.pixels.push_back(a);
        }
    }

    return out;
}

// Assumes:
//   rgbaPixels[0] = R for x:0 y:0
//   rgbaPixels[1] = G for x:0 y:0
//   rgbaPixels[2] = B for x:0 y:0
//   rgbaPixels[3] = A for x:0 y:0
gfxstream::expected<Ok, std::string> SaveRGBAToBitmapFile(
        uint32_t w,
        uint32_t h,
        const uint8_t* rgbaPixels,
        const std::string& filename) {
    std::ofstream bitmap(filename, std::ofstream::out | std::ofstream::binary);
    if (!bitmap.is_open()) {
        return gfxstream::unexpected("Failed to save " + filename + ": failed to open.");
    }

    static constexpr const uint32_t kBytesPerPixel = 4;
    uint32_t bitmapPixelsSize = w * h * kBytesPerPixel;
    uint32_t bitmapHeaderSize = 14;
    uint32_t bitmapDibHeaderSize = 108;
    uint32_t bitmapHeadersSize = bitmapHeaderSize + bitmapDibHeaderSize;
    uint32_t bitmapFileSize = bitmapHeadersSize + bitmapPixelsSize;

    auto WriteAsBytes = [&](const auto& value) {
        bitmap.write(reinterpret_cast<const char*>(&value), sizeof(value));
    };
    auto WriteCharAsBytes = [&](const char value) { WriteAsBytes(value); };
    auto WriteUint16AsBytes = [&](const uint16_t value) { WriteAsBytes(value); };
    auto WriteUint32AsBytes = [&](const uint32_t value) { WriteAsBytes(value); };

    WriteCharAsBytes(0x42);                   // "B"
    WriteCharAsBytes(0x4D);                   // "M"
    WriteUint32AsBytes(bitmapFileSize);
    WriteCharAsBytes(0);                      // reserved 1
    WriteCharAsBytes(0);                      // reserved 1
    WriteCharAsBytes(0);                      // reserved 2
    WriteCharAsBytes(0);                      // reserved 2
    WriteUint32AsBytes(bitmapHeadersSize);    // offset to actual pixel data
    WriteUint32AsBytes(bitmapDibHeaderSize);
    WriteUint32AsBytes(w);
    WriteUint32AsBytes(h);
    WriteUint16AsBytes(1);                    // number of planes
    WriteUint16AsBytes(32);                   // bits per pixel
    WriteUint32AsBytes(0x03);                 // compression/format
    WriteUint32AsBytes(bitmapPixelsSize);     // image size
    WriteUint32AsBytes(0);                    // horizontal print reset
    WriteUint32AsBytes(0);                    // vertical print reset
    WriteUint32AsBytes(0);                    // num_palette_colors
    WriteUint32AsBytes(0);                    // num_important_colors
    WriteUint32AsBytes(0x000000FF);           // red channel mask
    WriteUint32AsBytes(0x0000FF00);           // green channel mask
    WriteUint32AsBytes(0x00FF0000);           // blue channel mask
    WriteUint32AsBytes(0xFF000000);           // alpha channel mask
    WriteUint32AsBytes(0x206e6957);           // "win"
    for (uint32_t i = 0; i < 36; i++) {
        WriteCharAsBytes(0);
    }                                         // cie color space
    WriteUint32AsBytes(0);                    // "win"
    WriteUint32AsBytes(0);                    // "win"
    WriteUint32AsBytes(0);                    // "win"

    uint32_t stribeBytes = w * 4;
    for (uint32_t currentY = 0; currentY < h; currentY++) {
        uint32_t flippedY = h - currentY - 1;
        const uint8_t* currentPixel = rgbaPixels + (stribeBytes * flippedY);
        for (uint32_t currentX = 0; currentX < w; currentX++) {
            WriteAsBytes(*currentPixel);
            ++currentPixel;
            WriteAsBytes(*currentPixel);
            ++currentPixel;
            WriteAsBytes(*currentPixel);
            ++currentPixel;
            WriteAsBytes(*currentPixel);
            ++currentPixel;
        }
    }

    bitmap.close();

    return Ok{};
}

gfxstream::expected<YUV420Image, std::string> LoadYUV420FromBitmapFile(
        const std::string& filename) {
    auto rgbaImage = GFXSTREAM_EXPECT(LoadRGBAFromBitmapFile(filename));
    return ConvertRGBA8888ToYUV420(rgbaImage);
}

RGBAImage FillWithColor(uint32_t width,
                        uint32_t height,
                        uint8_t red,
                        uint8_t green,
                        uint8_t blue,
                        uint8_t alpha) {
    RGBAImage out;
    out.width = width;
    out.height = height;
    out.pixels.reserve(width * height * 4);
    for (uint32_t y = 0; y < height; y++) {
        for (uint32_t x = 0; x < width; x++) {
            out.pixels.push_back(red);
            out.pixels.push_back(green);
            out.pixels.push_back(blue);
            out.pixels.push_back(alpha);
        }
    }
    return out;
}

namespace {

uint8_t Clamp(int x) {
    if (x > 255) {
        return 255;
    }
    if (x < 0) {
        return 0;
    }
    return static_cast<uint8_t>(x);
}

// BT.601 with "Studio Swing" / narrow range.
void ConvertRGBA8888PixelToYUV(const uint8_t r,
                               const uint8_t g,
                               const uint8_t b,
                               uint8_t* out_y,
                               uint8_t* out_u,
                               uint8_t* out_v) {
    const int r_int = static_cast<int>(r);
    const int g_int = static_cast<int>(g);
    const int b_int = static_cast<int>(b);
    *out_y = Clamp(((( 66 * r_int) + (129 * g_int) +  (25 * b_int) + 128) >> 8) + 16);
    *out_u = Clamp((((-38 * r_int) -  (74 * g_int) + (112 * b_int) + 128) >> 8) + 128);
    *out_v = Clamp((((112 * r_int) -  (94 * g_int) -  (18 * b_int) + 128) >> 8) + 128);
}

}  // namespace

YUV420Image ConvertRGBA8888ToYUV420(const RGBAImage& rgbaImage) {
    const uint32_t w = rgbaImage.width;
    const uint32_t h = rgbaImage.height;

    YUV420Image yuvImage;
    yuvImage.width = w;
    yuvImage.height = h;
    yuvImage.y.reserve(w * h);
    yuvImage.u.reserve((w / 2) * (h / 2));
    yuvImage.v.reserve((w / 2) * (h / 2));

    const auto* input = rgbaImage.pixels.data();
    for (uint32_t y = 0; y < h; y++) {
        for (uint32_t x = 0; x < w; x++) {
            const uint8_t r = *input;
            ++input;
            const uint8_t g = *input;
            ++input;
            const uint8_t b = *input;
            ++input;
            // const uint8_t a = *input;
            ++input;

            uint8_t pixelY;
            uint8_t pixelU;
            uint8_t pixelV;
            ConvertRGBA8888PixelToYUV(r, g, b, &pixelY, &pixelU, &pixelV);

            yuvImage.y.push_back(pixelY);
            if ((x % 2 == 0) && (y % 2 == 0)) {
                yuvImage.u.push_back(pixelU);
                yuvImage.v.push_back(pixelV);
            }
        }
    }

    return yuvImage;
}

namespace {

bool PixelsAreSimilar(uint32_t pixel1, uint32_t pixel2) {
    const uint8_t* pixel1_rgba = reinterpret_cast<const uint8_t*>(&pixel1);
    const uint8_t* pixel2_rgba = reinterpret_cast<const uint8_t*>(&pixel2);

    constexpr const uint32_t kDefaultTolerance = 2;
    for (uint32_t channel = 0; channel < 4; channel++) {
        const uint8_t pixel1_channel = pixel1_rgba[channel];
        const uint8_t pixel2_channel = pixel2_rgba[channel];
        if ((std::max(pixel1_channel, pixel2_channel) -
             std::min(pixel1_channel, pixel2_channel)) > kDefaultTolerance) {
            return false;
        }
    }
    return true;
}

}  // namespace

gfxstream::expected<Ok, std::vector<PixelDiff>> CompareImages(
        const RGBAImage& expected,
        const RGBAImage& actual) {
    const uint32_t width = expected.width;
    const uint32_t height = expected.height;

    constexpr const uint32_t kMaxReportedIncorrectPixels = 10;

    const auto* expectedPixels = reinterpret_cast<const uint32_t*>(expected.pixels.data());
    const auto* actualPixels =reinterpret_cast<const uint32_t*>(actual.pixels.data());

    std::vector<PixelDiff> pixelDiffs;

    for (uint32_t y = 0; y < width; y++) {
        for (uint32_t x = 0; x < height; x++) {
            const uint32_t expectedPixel = expectedPixels[y * height + x];
            const uint32_t actualPixel = actualPixels[y * height + x];
            if (!PixelsAreSimilar(expectedPixel, actualPixel)) {
                if (pixelDiffs.size() < kMaxReportedIncorrectPixels) {
                    const uint8_t* expectedPixelRgba = reinterpret_cast<const uint8_t*>(&expectedPixel);
                    const uint8_t* actualPixelRgba = reinterpret_cast<const uint8_t*>(&actualPixel);
                    pixelDiffs.push_back(PixelDiff{
                        .x = x,
                        .y = y,
                        .expectedR = expectedPixelRgba[0],
                        .expectedG = expectedPixelRgba[1],
                        .expectedB = expectedPixelRgba[2],
                        .expectedA = expectedPixelRgba[3],
                        .actualR = actualPixelRgba[0],
                        .actualG = actualPixelRgba[1],
                        .actualB = actualPixelRgba[2],
                        .actualA = actualPixelRgba[3],
                    });
                }
            }
        }
    }

    if (!pixelDiffs.empty()) {
        return gfxstream::unexpected(std::move(pixelDiffs));
    }

    return Ok{};
}

}  // namespace gfxstream