/*

 * Copyright 2015 Google Inc.

 *

 * Use of this source code is governed by a BSD-style license that can be

 * found in the LICENSE file.

 */

#include "GrCaps.h"

#include "GrBackendSurface.h"

#include "GrContextOptions.h"

#include "GrWindowRectangles.h"

#include "SkJSONWriter.h"

static const char* pixel_config_name(GrPixelConfig config) {

    switch (config) {

        case kUnknown_GrPixelConfig: return "Unknown";

        case kAlpha_8_GrPixelConfig: return "Alpha8";

        case kAlpha_8_as_Alpha_GrPixelConfig: return "Alpha8_asAlpha";

        case kAlpha_8_as_Red_GrPixelConfig: return "Alpha8_asRed";

        case kGray_8_GrPixelConfig: return "Gray8";

        case kGray_8_as_Lum_GrPixelConfig: return "Gray8_asLum";

        case kGray_8_as_Red_GrPixelConfig: return "Gray8_asRed";

        case kRGB_565_GrPixelConfig: return "RGB565";

        case kRGBA_4444_GrPixelConfig: return "RGBA444";

        case kRGBA_8888_GrPixelConfig: return "RGBA8888";

        case kBGRA_8888_GrPixelConfig: return "BGRA8888";

        case kSRGBA_8888_GrPixelConfig: return "SRGBA8888";

        case kSBGRA_8888_GrPixelConfig: return "SBGRA8888";

        case kRGBA_float_GrPixelConfig: return "RGBAFloat";

        case kRG_float_GrPixelConfig: return "RGFloat";

        case kAlpha_half_GrPixelConfig: return "AlphaHalf";

        case kAlpha_half_as_Red_GrPixelConfig: return "AlphaHalf_asRed";

        case kRGBA_half_GrPixelConfig: return "RGBAHalf";

    }

    SK_ABORT("Invalid pixel config");

    return "<invalid>";

}

GrCaps::GrCaps(const GrContextOptions& options) {

    fMipMapSupport = false;

    fNPOTTextureTileSupport = false;

    fSRGBSupport = false;

    fSRGBWriteControl = false;

    fSRGBDecodeDisableSupport = false;

    fDiscardRenderTargetSupport = false;

    fReuseScratchTextures = true;

    fReuseScratchBuffers = true;

    fGpuTracingSupport = false;

    fOversizedStencilSupport = false;

    fTextureBarrierSupport = false;

    fSampleLocationsSupport = false;

    fMultisampleDisableSupport = false;

    fInstanceAttribSupport = false;

    fUsesMixedSamples = false;

    fUsePrimitiveRestart = false;

    fPreferClientSideDynamicBuffers = false;

    fPreferFullscreenClears = false;

    fMustClearUploadedBufferData = false;

    fSampleShadingSupport = false;

    fFenceSyncSupport = false;

    fCrossContextTextureSupport = false;

    fBlendEquationSupport = kBasic_BlendEquationSupport;

    fAdvBlendEqBlacklist = 0;

    fMapBufferFlags = kNone_MapFlags;

    fMaxVertexAttributes = 0;

    fMaxRenderTargetSize = 1;

    fMaxPreferredRenderTargetSize = 1;

    fMaxTextureSize = 1;

    fMaxRasterSamples = 0;

    fMaxWindowRectangles = 0;

    // An default count of 4 was chosen because of the common pattern in Blink of:

    //   isect RR

    //   diff  RR

    //   isect convex_poly

    //   isect convex_poly

    // when drawing rounded div borders.

    fMaxClipAnalyticFPs = 4;

    fSuppressPrints = options.fSuppressPrints;

#if GR_TEST_UTILS

    fWireframeMode = options.fWireframeMode;

#else

    fWireframeMode = false;

#endif

    fBufferMapThreshold = options.fBufferMapThreshold;

    fBlacklistCoverageCounting = false;

    fAvoidStencilBuffers = false;

    fPreferVRAMUseOverFlushes = true;

}

void GrCaps::applyOptionsOverrides(const GrContextOptions& options) {

    this->onApplyOptionsOverrides(options);

    if (options.fDisableDriverCorrectnessWorkarounds) {

        // We always blacklist coverage counting on Vulkan currently. TODO: Either stop doing that

        // or disambiguate blacklisting from incomplete implementation.

        // SkASSERT(!fBlacklistCoverageCounting);

        SkASSERT(!fAvoidStencilBuffers);

        SkASSERT(!fAdvBlendEqBlacklist);

    }

    fMaxTextureSize = SkTMin(fMaxTextureSize, options.fMaxTextureSizeOverride);

    fMaxTileSize = fMaxTextureSize;

#if GR_TEST_UTILS

    // If the max tile override is zero, it means we should use the max texture size.

    if (options.fMaxTileSizeOverride && options.fMaxTileSizeOverride < fMaxTextureSize) {

        fMaxTileSize = options.fMaxTileSizeOverride;

    }

    if (options.fSuppressGeometryShaders) {

        fShaderCaps->fGeometryShaderSupport = false;

    }

#endif

    if (fMaxWindowRectangles > GrWindowRectangles::kMaxWindows) {

        SkDebugf("WARNING: capping window rectangles at %i. HW advertises support for %i.\n",

                 GrWindowRectangles::kMaxWindows, fMaxWindowRectangles);

        fMaxWindowRectangles = GrWindowRectangles::kMaxWindows;

    }

    fAvoidStencilBuffers = options.fAvoidStencilBuffers;

}

static SkString map_flags_to_string(uint32_t flags) {

    SkString str;

    if (GrCaps::kNone_MapFlags == flags) {

        str = "none";

    } else {

        SkASSERT(GrCaps::kCanMap_MapFlag & flags);

        SkDEBUGCODE(flags &= ~GrCaps::kCanMap_MapFlag);

        str = "can_map";

        if (GrCaps::kSubset_MapFlag & flags) {

            str.append(" partial");

        } else {

            str.append(" full");

        }

        SkDEBUGCODE(flags &= ~GrCaps::kSubset_MapFlag);

    }

    SkASSERT(0 == flags); // Make sure we handled all the flags.

    return str;

}

void GrCaps::dumpJSON(SkJSONWriter* writer) const {

    writer->beginObject();

    writer->appendBool("MIP Map Support", fMipMapSupport);

    writer->appendBool("NPOT Texture Tile Support", fNPOTTextureTileSupport);

    writer->appendBool("sRGB Support", fSRGBSupport);

    writer->appendBool("sRGB Write Control", fSRGBWriteControl);

    writer->appendBool("sRGB Decode Disable", fSRGBDecodeDisableSupport);

    writer->appendBool("Discard Render Target Support", fDiscardRenderTargetSupport);

    writer->appendBool("Reuse Scratch Textures", fReuseScratchTextures);

    writer->appendBool("Reuse Scratch Buffers", fReuseScratchBuffers);

    writer->appendBool("Gpu Tracing Support", fGpuTracingSupport);

    writer->appendBool("Oversized Stencil Support", fOversizedStencilSupport);

    writer->appendBool("Texture Barrier Support", fTextureBarrierSupport);

    writer->appendBool("Sample Locations Support", fSampleLocationsSupport);

    writer->appendBool("Multisample disable support", fMultisampleDisableSupport);

    writer->appendBool("Instance Attrib Support", fInstanceAttribSupport);

    writer->appendBool("Uses Mixed Samples", fUsesMixedSamples);

    writer->appendBool("Use primitive restart", fUsePrimitiveRestart);

    writer->appendBool("Prefer client-side dynamic buffers", fPreferClientSideDynamicBuffers);

    writer->appendBool("Prefer fullscreen clears", fPreferFullscreenClears);

    writer->appendBool("Must clear buffer memory", fMustClearUploadedBufferData);

    writer->appendBool("Sample shading support", fSampleShadingSupport);

    writer->appendBool("Fence sync support", fFenceSyncSupport);

    writer->appendBool("Cross context texture support", fCrossContextTextureSupport);

    writer->appendBool("Blacklist Coverage Counting Path Renderer [workaround]",

                       fBlacklistCoverageCounting);

    writer->appendBool("Prefer VRAM Use over flushes [workaround]", fPreferVRAMUseOverFlushes);

    if (this->advancedBlendEquationSupport()) {

        writer->appendHexU32("Advanced Blend Equation Blacklist", fAdvBlendEqBlacklist);

    }

    writer->appendS32("Max Vertex Attributes", fMaxVertexAttributes);

    writer->appendS32("Max Texture Size", fMaxTextureSize);

    writer->appendS32("Max Render Target Size", fMaxRenderTargetSize);

    writer->appendS32("Max Preferred Render Target Size", fMaxPreferredRenderTargetSize);

    writer->appendS32("Max Raster Samples", fMaxRasterSamples);

    writer->appendS32("Max Window Rectangles", fMaxWindowRectangles);

    writer->appendS32("Max Clip Analytic Fragment Processors", fMaxClipAnalyticFPs);

    static const char* kBlendEquationSupportNames[] = {

        "Basic",

        "Advanced",

        "Advanced Coherent",

    };

    GR_STATIC_ASSERT(0 == kBasic_BlendEquationSupport);

    GR_STATIC_ASSERT(1 == kAdvanced_BlendEquationSupport);

    GR_STATIC_ASSERT(2 == kAdvancedCoherent_BlendEquationSupport);

    GR_STATIC_ASSERT(SK_ARRAY_COUNT(kBlendEquationSupportNames) == kLast_BlendEquationSupport + 1);

    writer->appendString("Blend Equation Support",

                         kBlendEquationSupportNames[fBlendEquationSupport]);

    writer->appendString("Map Buffer Support", map_flags_to_string(fMapBufferFlags).c_str());

    SkASSERT(!this->isConfigRenderable(kUnknown_GrPixelConfig));

    SkASSERT(!this->isConfigTexturable(kUnknown_GrPixelConfig));

    writer->beginArray("configs");

    for (size_t i = 1; i < kGrPixelConfigCnt; ++i) {

        GrPixelConfig config = static_cast<GrPixelConfig>(i);

        writer->beginObject(nullptr, false);

        writer->appendString("name", pixel_config_name(config));

        writer->appendS32("max sample count", this->maxRenderTargetSampleCount(config));

        writer->appendBool("texturable", this->isConfigTexturable(config));

        writer->endObject();

    }

    writer->endArray();

    this->onDumpJSON(writer);

    writer->appendName("shaderCaps");

    this->shaderCaps()->dumpJSON(writer);

    writer->endObject();

}

bool GrCaps::validateSurfaceDesc(const GrSurfaceDesc& desc, GrMipMapped mipped) const {

    if (!this->isConfigTexturable(desc.fConfig)) {

        return false;

    }

    if (GrMipMapped::kYes == mipped && !this->mipMapSupport()) {

        return false;

    }

    if (desc.fWidth < 1 || desc.fHeight < 1) {

        return false;

    }

    if (SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag)) {

        if (0 == this->getRenderTargetSampleCount(desc.fSampleCnt, desc.fConfig)) {

            return false;

        }

        int maxRTSize = this->maxRenderTargetSize();

        if (desc.fWidth > maxRTSize || desc.fHeight > maxRTSize) {

            return false;

        }

    } else {

        // We currently do not support multisampled textures

        if (desc.fSampleCnt > 1) {

            return false;

        }

        int maxSize = this->maxTextureSize();

        if (desc.fWidth > maxSize || desc.fHeight > maxSize) {

            return false;

        }

    }

    return true;

}