/*
 * Copyright 2017 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

// This is a GPU-backend specific test. It relies on static intializers to work

#include "include/core/SkTypes.h"

#include "include/core/SkSurface.h"
#include "include/gpu/GrTexture.h"
#include "src/gpu/GrContextPriv.h"
#include "src/gpu/GrGpu.h"
#include "src/gpu/GrResourceProvider.h"
#include "src/gpu/GrSurfaceProxy.h"
#include "src/gpu/SkGr.h"
#include "tests/Test.h"
#include "tools/gpu/GrContextFactory.h"

using sk_gpu_test::GrContextFactory;

void fill_transfer_data(int left, int top, int width, int height, int bufferWidth,
                        GrColor* data) {

    // build red-green gradient
    for (int j = top; j < top + height; ++j) {
        for (int i = left; i < left + width; ++i) {
            unsigned int red = (unsigned int)(256.f*((i - left) / (float)width));
            unsigned int green = (unsigned int)(256.f*((j - top) / (float)height));
            data[i + j*bufferWidth] = GrColorPackRGBA(red - (red>>8),
                                                      green - (green>>8), 0xff, 0xff);
        }
    }
}

bool do_buffers_contain_same_values(const GrColor* bufferA,
                                    const GrColor* bufferB,
                                    int width,
                                    int height,
                                    size_t rowBytesA,
                                    size_t rowBytesB,
                                    bool swiz) {
    for (int j = 0; j < height; ++j) {
        for (int i = 0; i < width; ++i) {
            auto colorA = bufferA[i];
            if (swiz) {
                colorA = GrColorPackRGBA(GrColorUnpackB(colorA), GrColorUnpackG(colorA),
                                         GrColorUnpackR(colorA), GrColorUnpackA(colorA));
            }
            if (colorA != bufferB[i]) {
                return false;
            }
        }
        bufferA = reinterpret_cast<const GrColor*>(reinterpret_cast<const char*>(bufferA) +
                                                   rowBytesA);
        bufferB = reinterpret_cast<const GrColor*>(reinterpret_cast<const char*>(bufferB) +
                                                   rowBytesB);
    }
    return true;
}

void basic_transfer_to_test(skiatest::Reporter* reporter, GrContext* context, GrColorType colorType,
                            bool renderTarget) {
    if (GrCaps::kNone_MapFlags == context->priv().caps()->mapBufferFlags()) {
        return;
    }

    auto resourceProvider = context->priv().resourceProvider();
    GrGpu* gpu = context->priv().getGpu();

    // set up the data
    const int kTextureWidth = 16;
    const int kTextureHeight = 16;
#ifdef SK_BUILD_FOR_IOS
    // UNPACK_ROW_LENGTH is broken on iOS so rowBytes needs to match data width
    const int kBufferWidth = GrBackendApi::kOpenGL == context->backend() ? 16 : 20;
#else
    const int kBufferWidth = 20;
#endif
    const int kBufferHeight = 16;
    size_t rowBytes = kBufferWidth * sizeof(GrColor);
    SkAutoTMalloc<GrColor> srcBuffer(kBufferWidth*kBufferHeight);
    SkAutoTMalloc<GrColor> dstBuffer(kBufferWidth*kBufferHeight);

    fill_transfer_data(0, 0, kTextureWidth, kTextureHeight, kBufferWidth, srcBuffer.get());

    // create and fill transfer buffer
    size_t size = rowBytes*kBufferHeight;
    sk_sp<GrGpuBuffer> buffer(resourceProvider->createBuffer(size, GrGpuBufferType::kXferCpuToGpu,
                                                             kDynamic_GrAccessPattern));
    if (!buffer) {
        return;
    }

    void* data = buffer->map();
    memcpy(data, srcBuffer.get(), size);
    buffer->unmap();

    // create texture
    GrSurfaceDesc desc;
    desc.fFlags = renderTarget ? kRenderTarget_GrSurfaceFlag : kNone_GrSurfaceFlags;
    desc.fWidth = kTextureWidth;
    desc.fHeight = kTextureHeight;
    desc.fConfig = GrColorTypeToPixelConfig(colorType);
    desc.fSampleCnt = 1;

    if (!context->priv().caps()->isConfigTexturable(desc.fConfig) ||
        (renderTarget && !context->priv().caps()->isConfigRenderable(desc.fConfig))) {
        return;
    }

    sk_sp<GrTexture> tex = resourceProvider->createTexture(
        desc, SkBudgeted::kNo, GrResourceProvider::Flags::kNoPendingIO);
    if (!tex) {
        return;
    }

    //////////////////////////
    // transfer full data

    bool result;
    result = gpu->transferPixelsTo(tex.get(), 0, 0, kTextureWidth, kTextureHeight, colorType,
                                   buffer.get(), 0, rowBytes);
    REPORTER_ASSERT(reporter, result);

    memset(dstBuffer.get(), 0xCDCD, size);
    result = gpu->readPixels(tex.get(), 0, 0, kTextureWidth, kTextureHeight, colorType,
                             dstBuffer.get(), rowBytes);
    if (result) {
        REPORTER_ASSERT(reporter, do_buffers_contain_same_values(srcBuffer,
                                                                 dstBuffer,
                                                                 kTextureWidth,
                                                                 kTextureHeight,
                                                                 rowBytes,
                                                                 rowBytes,
                                                                 false));
    }

    //////////////////////////
    // transfer partial data
#ifdef SK_BUILD_FOR_IOS
    // UNPACK_ROW_LENGTH is broken on iOS so we can't do partial transfers
    if (GrBackendApi::kOpenGL == context->backend()) {
        return;
    }
#endif
    const int kLeft = 2;
    const int kTop = 10;
    const int kWidth = 10;
    const int kHeight = 2;

    // change color of subrectangle
    fill_transfer_data(kLeft, kTop, kWidth, kHeight, kBufferWidth, srcBuffer.get());
    data = buffer->map();
    memcpy(data, srcBuffer.get(), size);
    buffer->unmap();

    size_t offset = sizeof(GrColor) * (kTop * kBufferWidth + kLeft);
    result = gpu->transferPixelsTo(tex.get(), kLeft, kTop, kWidth, kHeight, colorType,
                                   buffer.get(), offset, rowBytes);
    REPORTER_ASSERT(reporter, result);

    memset(dstBuffer.get(), 0xCDCD, size);
    result = gpu->readPixels(tex.get(), 0, 0, kTextureWidth, kTextureHeight, colorType,
                             dstBuffer.get(), rowBytes);
    if (result) {
        REPORTER_ASSERT(reporter, do_buffers_contain_same_values(srcBuffer,
                                                                 dstBuffer,
                                                                 kTextureWidth,
                                                                 kTextureHeight,
                                                                 rowBytes,
                                                                 rowBytes,
                                                                 false));
    }
}

void basic_transfer_from_test(skiatest::Reporter* reporter, const sk_gpu_test::ContextInfo& ctxInfo,
                              GrColorType colorType, bool renderTarget) {
    auto context = ctxInfo.grContext();
    if (GrCaps::kNone_MapFlags == context->priv().caps()->mapBufferFlags()) {
        return;
    }

    // On OpenGL ES it may not be possible to read back in to BGRA becagse GL_RGBA/GL_UNSIGNED_BYTE
    // may be the only allowed format/type params to glReadPixels. So read back into GL_RGBA.
    // TODO(bsalomon): Make this work in GrGLGpu.
    auto readColorType = colorType;
    if (GrColorType::kBGRA_8888 == colorType &&
        ctxInfo.type() == sk_gpu_test::GrContextFactory::kGLES_ContextType) {
        readColorType = GrColorType::kRGBA_8888;
    }

    auto resourceProvider = context->priv().resourceProvider();
    GrGpu* gpu = context->priv().getGpu();

    const int kTextureWidth = 16;
    const int kTextureHeight = 16;

    // We'll do a full texture read into the buffer followed by a partial read. These values
    // describe the partial read subrect.
    const int kPartialLeft = 2;
    const int kPartialTop = 10;
    const int kPartialWidth = 10;
    const int kPartialHeight = 2;

    size_t bpp = GrColorTypeBytesPerPixel(readColorType);
    size_t fullBufferRowBytes = kTextureWidth * bpp;
    size_t partialBufferRowBytes = kPartialWidth * bpp;
    size_t offsetAlignment = context->priv().caps()->transferFromOffsetAlignment(readColorType);
    SkASSERT(offsetAlignment);

    size_t bufferSize = fullBufferRowBytes * kTextureHeight;
    // Arbitrary starting offset for the partial read.
    size_t partialReadOffset = GrSizeAlignUp(11, offsetAlignment);
    bufferSize = SkTMax(bufferSize, partialReadOffset + partialBufferRowBytes * kPartialHeight);

    sk_sp<GrGpuBuffer> buffer(resourceProvider->createBuffer(
            bufferSize, GrGpuBufferType::kXferGpuToCpu, kDynamic_GrAccessPattern));
    REPORTER_ASSERT(reporter, buffer);
    if (!buffer) {
        return;
    }

    int expectedTransferCnt = 0;
    gpu->stats()->reset();
    // create texture
    GrSurfaceDesc desc;
    desc.fFlags = renderTarget ? kRenderTarget_GrSurfaceFlag : kNone_GrSurfaceFlags;
    desc.fWidth = kTextureWidth;
    desc.fHeight = kTextureHeight;
    desc.fConfig = GrColorTypeToPixelConfig(colorType);
    desc.fSampleCnt = 1;

    if (!context->priv().caps()->isConfigTexturable(desc.fConfig) ||
        (renderTarget && !context->priv().caps()->isConfigRenderable(desc.fConfig))) {
        return;
    }

    SkAutoTMalloc<GrColor> textureData(kTextureWidth * kTextureHeight);
    size_t textureDataRowBytes = kTextureWidth * sizeof(GrColor);
    fill_transfer_data(0, 0, kTextureWidth, kTextureHeight, kTextureWidth, textureData.get());
    GrMipLevel data;
    data.fPixels = textureData.get();
    data.fRowBytes = kTextureWidth * sizeof(GrColor);
    sk_sp<GrTexture> tex = resourceProvider->createTexture(desc, SkBudgeted::kNo, &data, 1);
    if (!tex) {
        return;
    }

    //////////////////////////
    // transfer full data
    bool result = gpu->transferPixelsFrom(tex.get(), 0, 0, kTextureWidth, kTextureHeight,
                                          readColorType, buffer.get(), 0);
    if (!result) {
        ERRORF(reporter, "transferPixelsFrom failed.");
        return;
    }
    ++expectedTransferCnt;

    GrFlushInfo flushInfo;
    flushInfo.fFlags = kSyncCpu_GrFlushFlag;
    if (context->priv().caps()->mapBufferFlags() & GrCaps::kAsyncRead_MapFlag) {
        gpu->finishFlush(nullptr, 0, SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo,
                         GrPrepareForExternalIORequests());
    }

    const auto* map = reinterpret_cast<const GrColor*>(buffer->map());
    REPORTER_ASSERT(reporter, map);
    if (!map) {
        return;
    }
    REPORTER_ASSERT(reporter, do_buffers_contain_same_values(textureData.get(),
                                                             map,
                                                             kTextureWidth,
                                                             kTextureHeight,
                                                             textureDataRowBytes,
                                                             fullBufferRowBytes,
                                                             readColorType != colorType));
    buffer->unmap();

    ///////////////////////
    // Now test a partial read at an offset into the buffer.
    result = gpu->transferPixelsFrom(tex.get(), kPartialLeft, kPartialTop, kPartialWidth,
                                     kPartialHeight, readColorType, buffer.get(),
                                     partialReadOffset);
    if (!result) {
        ERRORF(reporter, "transferPixelsFrom failed.");
        return;
    }
    ++expectedTransferCnt;

    if (context->priv().caps()->mapBufferFlags() & GrCaps::kAsyncRead_MapFlag) {
        gpu->finishFlush(nullptr, 0, SkSurface::BackendSurfaceAccess::kNoAccess, flushInfo,
                         GrPrepareForExternalIORequests());
    }

    map = reinterpret_cast<const GrColor*>(buffer->map());
    REPORTER_ASSERT(reporter, map);
    if (!map) {
        return;
    }
    const GrColor* textureDataStart = reinterpret_cast<const GrColor*>(
            reinterpret_cast<const char*>(textureData.get()) +
            textureDataRowBytes * kPartialTop + sizeof(GrColor) * kPartialLeft);
    const GrColor* bufferStart = reinterpret_cast<const GrColor*>(
            reinterpret_cast<const char*>(map) + partialReadOffset);
    REPORTER_ASSERT(reporter, do_buffers_contain_same_values(textureDataStart,
                                                             bufferStart,
                                                             kPartialWidth,
                                                             kPartialHeight,
                                                             textureDataRowBytes,
                                                             partialBufferRowBytes,
                                                             readColorType != colorType));
    buffer->unmap();
#if GR_GPU_STATS
    REPORTER_ASSERT(reporter, gpu->stats()->transfersFromSurface() == expectedTransferCnt);
#else
    (void)expectedTransferCnt;
#endif
}

DEF_GPUTEST_FOR_RENDERING_CONTEXTS(TransferPixelsToTest, reporter, ctxInfo) {
    if (!ctxInfo.grContext()->priv().caps()->transferBufferSupport()) {
        return;
    }
    // RGBA
    basic_transfer_to_test(reporter, ctxInfo.grContext(), GrColorType::kRGBA_8888, false);
    basic_transfer_to_test(reporter, ctxInfo.grContext(), GrColorType::kRGBA_8888, true);
    basic_transfer_to_test(reporter, ctxInfo.grContext(), GrColorType::kRGBA_8888_SRGB, false);
    basic_transfer_to_test(reporter, ctxInfo.grContext(), GrColorType::kRGBA_8888_SRGB, true);

    // BGRA
    basic_transfer_to_test(reporter, ctxInfo.grContext(), GrColorType::kBGRA_8888, false);
    basic_transfer_to_test(reporter, ctxInfo.grContext(), GrColorType::kBGRA_8888, true);
}

// TODO(bsalomon): Metal
DEF_GPUTEST_FOR_RENDERING_CONTEXTS(TransferPixelsFromTest, reporter, ctxInfo) {
    if (!ctxInfo.grContext()->priv().caps()->transferBufferSupport()) {
        return;
    }
    // RGBA
    basic_transfer_from_test(reporter, ctxInfo, GrColorType::kRGBA_8888, false);
    basic_transfer_from_test(reporter, ctxInfo, GrColorType::kRGBA_8888, true);
    basic_transfer_from_test(reporter, ctxInfo, GrColorType::kRGBA_8888_SRGB, false);
    basic_transfer_from_test(reporter, ctxInfo, GrColorType::kRGBA_8888_SRGB, true);

    // BGRA
    basic_transfer_from_test(reporter, ctxInfo, GrColorType::kBGRA_8888, false);
    basic_transfer_from_test(reporter, ctxInfo, GrColorType::kBGRA_8888, true);
}