tests/blit_tests.cpp

// Copyright 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


//  XGL tests
//
//  Copyright (C) 2014 LunarG, Inc.
//
//  Permission is hereby granted, free of charge, to any person obtaining a
//  copy of this software and associated documentation files (the "Software"),
//  to deal in the Software without restriction, including without limitation
//  the rights to use, copy, modify, merge, publish, distribute, sublicense,
//  and/or sell copies of the Software, and to permit persons to whom the
//  Software is furnished to do so, subject to the following conditions:
//
//  The above copyright notice and this permission notice shall be included
//  in all copies or substantial portions of the Software.
//
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
//  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
//  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
//  DEALINGS IN THE SOFTWARE.

// Blit (copy, clear, and resolve) tests

#include <string.h>
#include <xgl.h>
#include "gtest-1.7.0/include/gtest/gtest.h"
#include "xgldevice.h"
#include "xglimage.h"
#include "xgltestframework.h"

#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))

class XglBlitTest : public XglTestFramework
{
protected:
    XGL_APPLICATION_INFO app_info;
    XglDevice *m_device;

    XGL_CMD_BUFFER m_cmd;

    XGL_MEMORY_REF m_mem_refs[8];
    XGL_UINT m_mem_ref_count;

    virtual void SetUp();
    virtual void TearDown();

    XGL_DEVICE device() { return m_device->device(); }

    void ClearMemoryRefs()
    {
        m_mem_ref_count = 0;
    }

    void AddMemoryRef(XGL_GPU_MEMORY mem, bool readonly)
    {
        ASSERT_LE(m_mem_ref_count, ARRAY_SIZE(m_mem_refs));

        m_mem_refs[m_mem_ref_count].mem = mem;
        m_mem_refs[m_mem_ref_count].flags =
            (readonly) ? XGL_MEMORY_REF_READ_ONLY_BIT : 0;
        m_mem_ref_count++;
    }

    XGL_GPU_MEMORY AllocMemory(XGL_GPU_SIZE size)
    {
        XGL_MEMORY_ALLOC_INFO info;
        XGL_GPU_MEMORY mem;
        XGL_RESULT err;

        memset(&info, 0, sizeof(info));
        info.sType = XGL_STRUCTURE_TYPE_MEMORY_ALLOC_INFO;
        info.allocationSize = size;
        info.alignment = 1;
        info.heapCount = 1;
        info.memPriority = XGL_MEMORY_PRIORITY_NORMAL;

        err = xglAllocMemory(device(), &info, &mem);
        if (err)
            mem = XGL_NULL_HANDLE;

        return mem;
    }

    XGL_GPU_MEMORY AddMemory(XGL_GPU_SIZE size, bool readonly)
    {
        XGL_GPU_MEMORY mem;

        mem = AllocMemory(size);
        if (mem)
            AddMemoryRef(mem, readonly);

        return mem;
    }

    void BeginCmd()
    {
        XGL_RESULT err;

        err = xglBeginCommandBuffer(m_cmd,
                XGL_CMD_BUFFER_OPTIMIZE_GPU_SMALL_BATCH_BIT |
                XGL_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT);
        ASSERT_XGL_SUCCESS(err);
    }

    void EndAndSubmitCmd()
    {
        XGL_RESULT err;

        err = xglEndCommandBuffer(m_cmd);
        ASSERT_XGL_SUCCESS(err);

        err = xglQueueSubmit(m_device->m_queue, 1, &m_cmd, m_mem_ref_count, m_mem_refs, NULL );
        ASSERT_XGL_SUCCESS(err);

        err = xglQueueWaitIdle(m_device->m_queue);
        ASSERT_XGL_SUCCESS(err);
    }
};

void XglBlitTest::SetUp()
{
    XGL_CMD_BUFFER_CREATE_INFO cmd_info;
    XGL_PHYSICAL_GPU gpu;
    XGL_UINT count;
    XGL_RESULT err;

    memset(&app_info, 0, sizeof(app_info));
    app_info.sType = XGL_STRUCTURE_TYPE_APPLICATION_INFO;
    app_info.pNext = NULL;
    app_info.pAppName = (const XGL_CHAR *) "blit tests";
    app_info.appVersion = 1;
    app_info.pEngineName = (const XGL_CHAR *) "unittest";
    app_info.engineVersion = 1;
    app_info.apiVersion = XGL_MAKE_VERSION(0, 22, 0);

    err = xglInitAndEnumerateGpus(&app_info, NULL, 1, &count, &gpu);
    ASSERT_XGL_SUCCESS(err);
    ASSERT_GE(1, count) << "No GPU available";

    m_device = new XglDevice(0, gpu);
    m_device->get_device_queue();

    memset(&cmd_info, 0, sizeof(cmd_info));
    cmd_info.sType = XGL_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO;
    cmd_info.queueType = XGL_QUEUE_TYPE_GRAPHICS;

    err = xglCreateCommandBuffer(device(), &cmd_info, &m_cmd);
    ASSERT_XGL_SUCCESS(err) << "xglCreateCommandBuffer failed";
}

void XglBlitTest::TearDown()
{
    XGL_UINT dummy_count;

    xglDestroyObject(m_cmd);
    xglInitAndEnumerateGpus(&app_info, NULL, 0, &dummy_count, NULL);
}

TEST_F(XglBlitTest, FillMemory)
{
    const struct {
        XGL_GPU_SIZE offset;
        XGL_GPU_SIZE size;
        XGL_UINT value;
    } ranges[] = {
        {  0, 64, 0x11111111 }, // 16-byte aligned
        { 64, 12, 0x22222222 }, // 4-byte aligned
        { 76,  4, 0x33333333 }, // min. fill size
        { 80, 20, 0x44444444 },
        { 92,  8, 0x55555555 }, // overlapped
    };
    XGL_GPU_MEMORY mem;
    XGL_RESULT err;
    void *data;
    XGL_UINT i;

    ClearMemoryRefs();

    mem = AddMemory(256, false);
    ASSERT_NE((XGL_GPU_MEMORY) XGL_NULL_HANDLE, mem);

    BeginCmd();
    for (i = 0; i < ARRAY_SIZE(ranges); i++) {
        xglCmdFillMemory(m_cmd, mem, ranges[i].offset,
                ranges[i].size, ranges[i].value);
    }
    EndAndSubmitCmd();

    err = xglMapMemory(mem, 0, &data);
    ASSERT_XGL_SUCCESS(err);

    for (i = 0; i < ARRAY_SIZE(ranges); i++) {
        const XGL_UINT expected = ranges[i].value;
        const XGL_UINT *real = (const XGL_UINT *)
            ((char *) data + ranges[i].offset);
        XGL_UINT count, j;

        count = ranges[i].size / 4;

        /* check if the next range overlaps */
        if (i + 1 < ARRAY_SIZE(ranges)) {
            if (ranges[i].offset + ranges[i].size > ranges[i + 1].offset)
                count = (ranges[i + 1].offset - ranges[i].offset) / 4;
        }

        for (j = 0; j < count; j++)
            ASSERT_EQ(expected, real[j]);
    }

    xglUnmapMemory(mem);
    xglFreeMemory(mem);
}

TEST_F(XglBlitTest, CopyMemory)
{
    XGL_GPU_MEMORY src, dst;
    XGL_MEMORY_COPY regions[17];
    XGL_RESULT err;
    void *data;
    XGL_UINT i;

    ClearMemoryRefs();

    src = AddMemory(256, false);
    ASSERT_NE((XGL_GPU_MEMORY) XGL_NULL_HANDLE, src);

    err = xglMapMemory(src, 0, &data);
    ASSERT_XGL_SUCCESS(err);
    for (i = 0; i < 256; i++)
        ((char *) data)[i] = i;
    xglUnmapMemory(src);

    dst = AddMemory(256, false);
    ASSERT_NE((XGL_GPU_MEMORY) XGL_NULL_HANDLE, dst);

    /* copy with various alignments */
    for (i = 0; i < 16; i++) {
        regions[i].copySize = i + 1;
        regions[i].srcOffset = i * 8;

        if (i > 0) {
            regions[i].destOffset = regions[i - 1].destOffset +
                                    regions[i - 1].copySize;
        } else {
            regions[i].destOffset = 0;
        }
    }

    regions[i].srcOffset = 192;
    regions[i].destOffset = 192;
    regions[i].copySize = 64;

    BeginCmd();

    xglCmdCopyMemory(m_cmd, src, dst, 16, regions);
    xglCmdCopyMemory(m_cmd, src, dst, 1, &regions[16]);

    EndAndSubmitCmd();

    err = xglMapMemory(dst, 0, &data);
    ASSERT_XGL_SUCCESS(err);

    for (i = 0; i < ARRAY_SIZE(regions); i++) {
        const unsigned char *real = (const unsigned char *) data +
            regions[i].destOffset;
        XGL_UINT j;

        for (j = 0; j < regions[i].copySize; j++)
            ASSERT_EQ(regions[i].srcOffset + j, real[j]);
    }

    xglUnmapMemory(dst);
    xglFreeMemory(src);
    xglFreeMemory(dst);
}

TEST_F(XglBlitTest, ClearColorImageBasic)
{
    const XGL_FLOAT color[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
    const XGL_UINT width = 64;
    const XGL_UINT height = 64;
    XglImage *img;
    XGL_FORMAT format;
    XGL_IMAGE_SUBRESOURCE subres;
    XGL_IMAGE_SUBRESOURCE_RANGE subres_range;
    XGL_IMAGE_STATE_TRANSITION transition;
    XGL_RESULT err;

    format.channelFormat = XGL_CH_FMT_R8G8B8A8;
    format.numericFormat = XGL_NUM_FMT_UNORM;

    subres.aspect = XGL_IMAGE_ASPECT_COLOR;
    subres.mipLevel = 0;
    subres.arraySlice = 0;

    subres_range.aspect = XGL_IMAGE_ASPECT_COLOR;
    subres_range.baseMipLevel = 0;
    subres_range.mipLevels = 1;
    subres_range.baseArraySlice = 0;
    subres_range.arraySize = 1;

    img = new XglImage(m_device);
    img->init(width, height, format, XGL_IMAGE_USAGE_COLOR_ATTACHMENT_BIT);

    ClearMemoryRefs();
    AddMemoryRef(img->memory(), false);

    BeginCmd();

    transition.image = img->image();
    transition.oldState = XGL_IMAGE_STATE_UNINITIALIZED_TARGET;
    transition.newState = XGL_IMAGE_STATE_CLEAR;
    transition.subresourceRange = subres_range;
    xglCmdPrepareImages(m_cmd, 1, &transition);

    xglCmdClearColorImage(m_cmd, img->image(), color, 1, &subres_range);

    EndAndSubmitCmd();

    {
        XGL_SUBRESOURCE_LAYOUT layout;
        XGL_SIZE layout_size= sizeof(layout);
        XGL_UINT x, y;
        void *data;

        err = img->MapMemory(&data);
        ASSERT_XGL_SUCCESS(err);

        err = xglGetImageSubresourceInfo(img->image(), &subres,
                XGL_INFO_TYPE_SUBRESOURCE_LAYOUT, &layout_size, &layout);
        ASSERT_XGL_SUCCESS(err);
        ASSERT_EQ(sizeof(layout), layout_size);

        for (y = 0; y < height; y++) {
            const XGL_UINT *real = (const XGL_UINT *)
                ((char *) data + layout.offset + layout.rowPitch * y);

            for (x = 0; x < width; x++)
                ASSERT_EQ(0xff00ff00, real[x]);
        }

        img->UnmapMemory();
    }

    delete img;
}

TEST_F(XglBlitTest, ClearDepthStencilBasic)
{
    const XGL_FLOAT clear_depth = 0.4f;
    const XGL_UINT width = 64;
    const XGL_UINT height = 64;
    XglImage *img;
    XGL_FORMAT format;
    XGL_IMAGE_SUBRESOURCE subres;
    XGL_IMAGE_SUBRESOURCE_RANGE subres_range;
    XGL_IMAGE_STATE_TRANSITION transition;
    XGL_RESULT err;

    format.channelFormat = XGL_CH_FMT_R32;
    format.numericFormat = XGL_NUM_FMT_DS;

    subres.aspect = XGL_IMAGE_ASPECT_DEPTH;
    subres.mipLevel = 0;
    subres.arraySlice = 0;

    subres_range.aspect = XGL_IMAGE_ASPECT_DEPTH;
    subres_range.baseMipLevel = 0;
    subres_range.mipLevels = 1;
    subres_range.baseArraySlice = 0;
    subres_range.arraySize = 1;

    img = new XglImage(m_device);
    img->init(width, height, format, XGL_IMAGE_USAGE_DEPTH_STENCIL_BIT,
              XGL_OPTIMAL_TILING);

    ClearMemoryRefs();
    AddMemoryRef(img->memory(), false);

    BeginCmd();

    transition.image = img->image();
    transition.oldState = XGL_IMAGE_STATE_UNINITIALIZED_TARGET;
    transition.newState = XGL_IMAGE_STATE_CLEAR;
    transition.subresourceRange = subres_range;
    xglCmdPrepareImages(m_cmd, 1, &transition);

    xglCmdClearDepthStencil(m_cmd, img->image(), clear_depth,
            0, 1, &subres_range);

    EndAndSubmitCmd();

    /*
     * TODO xglCmdCopyImageToMemory to linearize
     *
     * This works only because xglMapMemory calls intel_bo_map_gtt_async.
     */
    {
        XGL_SUBRESOURCE_LAYOUT layout;
        XGL_SIZE layout_size = sizeof(layout);
        XGL_UINT x, y;
        void *data;

        err = img->MapMemory(&data);
        ASSERT_XGL_SUCCESS(err);

        err = xglGetImageSubresourceInfo(img->image(), &subres,
                XGL_INFO_TYPE_SUBRESOURCE_LAYOUT, &layout_size, &layout);
        ASSERT_XGL_SUCCESS(err);
        ASSERT_EQ(sizeof(layout), layout_size);

        for (y = 0; y < height; y++) {
            const float *real = (const float *)
                ((char *) data + layout.offset + layout.rowPitch * y);

            for (x = 0; x < width; x++)
                ASSERT_EQ(clear_depth, real[x]);
        }

        img->UnmapMemory();
    }
}

int main(int argc, char **argv)
{
    int result;

    ::testing::InitGoogleTest(&argc, argv);
    XglTestFramework::InitArgs(&argc, argv);

    ::testing::Environment* const xgl_test_env = ::testing::AddGlobalTestEnvironment(new TestEnvironment);

    result = RUN_ALL_TESTS();

    XglTestFramework::Finish();
    return result;
}