/* Copyright Statement:
 *
 * This software/firmware and related documentation ("MediaTek Software") are
 * protected under relevant copyright laws. The information contained herein is
 * confidential and proprietary to MediaTek Inc. and/or its licensors. Without
 * the prior written permission of MediaTek inc. and/or its licensors, any
 * reproduction, modification, use or disclosure of MediaTek Software, and
 * information contained herein, in whole or in part, shall be strictly
 * prohibited.
 *
 * MediaTek Inc. (C) 2023. All rights reserved.
 *
 * BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
 * THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
 * RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
 * ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL
 * WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
 * NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH
 * RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
 * INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK SOFTWARE, AND RECEIVER AGREES
 * TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
 * RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
 * OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MEDIATEK
 * SOFTWARE. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE
 * RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
 * STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S
 * ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE
 * RELEASED HEREUNDER WILL BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE
 * MEDIATEK SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
 * CHARGE PAID BY RECEIVER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
 *
 * The following software/firmware and/or related documentation ("MediaTek
 * Software") have been modified by MediaTek Inc. All revisions are subject to
 * any receiver's applicable license agreements with MediaTek Inc.
 */

//#define LOG_NDEBUG 0
#undef LOG_TAG
#define LOG_TAG "RenderEngine"
#define ATRACE_TAG ATRACE_TAG_GRAPHICS

#include "../skia/SkiaGLRenderEngine.h"

#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <GrContextOptions.h>
#include <SkCanvas.h>
#include <SkColorFilter.h>
#include <SkColorMatrix.h>
#include <SkColorSpace.h>
#include <SkGraphics.h>
#include <SkImage.h>
#include <SkImageFilters.h>
#include <SkRegion.h>
#include <SkShadowUtils.h>
#include <SkSurface.h>
#include <android-base/stringprintf.h>
#include <gl/GrGLInterface.h>
#include <gui/TraceUtils.h>
#include <gui/HdrMetadata.h>
#include <sync/sync.h>
#include <ui/BlurRegion.h>
#include <ui/DebugUtils.h>
#include <ui/GraphicBuffer.h>
#include <utils/Trace.h>
#include <ui/gralloc_extra.h>

namespace android {
namespace renderengine {
namespace skia {
#ifdef MTK_DUMP_SKIA_GL_SHADER
void SkiaGLRenderEngine::mtkDumpShader(const android::renderengine::LayerSettings& layer, ui::Dataspace dataspace){
    if (!mDumpShader) return;
    uint32_t colorRange = 0;
    if (layer.source.buffer.buffer) {
        auto& gb = layer.source.buffer.buffer->getBuffer();
        // gb->getBufferMapper().getDataspace(gb->handle, &dataspace);
        gralloc_extra_ion_sf_info_t ext_info;
        int err = gralloc_extra_query(gb->handle, GRALLOC_EXTRA_GET_IOCTL_ION_SF_INFO, &ext_info);
        if (err) {
            ALOGE("%s: GRALLOC_EXTRA_GET_IOCTL_ION_SF_INFO err(%d)",__FUNCTION__, err);
        } else {
            colorRange = (static_cast<uint32_t>(ext_info.status) & GRALLOC_EXTRA_MASK_YUV_COLORSPACE);
        }
    }
    if (!tryGetShaderInfo(layer.name, dataspace, colorRange)){
            ALOGE("%s: tryGetShaderInfo failed of layer: %s", __FUNCTION__, layer.name.c_str());
    }
}

bool SkiaGLRenderEngine::tryGetShaderInfo(const std::string& name, ui::Dataspace dataspace, uint32_t colorRange)
{
    GLint program_id;
    glGetIntegerv(GL_CURRENT_PROGRAM,&program_id);
    if (program_id == 0) {
        ALOGE("%s: Failed to get program_id", __FUNCTION__);
        return false;
    }
    shaderInfo[name] = ShaderInfo();
    ShaderInfo& si = shaderInfo[name];
    si.program = static_cast<int32_t>(program_id);
    si.dataspace = dataspace;
    si.colorRange = colorRange;
    std::vector<GLuint> shaders;
    shaders.resize(32);
    GLsizei count = 0;
    glGetAttachedShaders(
        program_id,
        static_cast<GLsizei>(shaders.size()),
        &count,
        &shaders[0]);
    shaders.resize(static_cast<std::size_t>(count));
    for(std::size_t i = 0 ; i < shaders.size() ; i++)
    {
        GLint shader_type;
        glGetShaderiv(
            shaders[i],
            GL_SHADER_TYPE,
            &shader_type);
        std::string* target = nullptr;
        switch(shader_type)
        {
            case GL_VERTEX_SHADER:
                target = &si.v_shader;
                break;
            case GL_FRAGMENT_SHADER:
                target = &si.f_shader;
                break;
        }
        if (target != nullptr)
        {
            target->resize(65535);
            GLsizei length = 0;
            glGetShaderSource(shaders[i],
                static_cast<GLsizei>(target->size()),
                &length,
                &(*target)[0]);
            target->resize(static_cast<std::size_t>(length));
        }
    }
    GLint num_uniform = 0;
    GLint max_len_uniform = 0;
    glGetProgramiv(
        program_id,
        GL_ACTIVE_UNIFORMS,
        &num_uniform);
    glGetProgramiv(
        program_id,
        GL_ACTIVE_UNIFORM_MAX_LENGTH,
        &max_len_uniform);
    if (num_uniform > 0)
    {
        for (uint32_t i = 0 ; i < static_cast<uint32_t>(num_uniform) ; ++i )
        {
            GLsizei length = 0;
            GLint size = 0;
            GLenum type = 0;
            si.uniforms[i] = ShaderUniformInfo();
            ShaderUniformInfo& su = si.uniforms[i];
            su.name.resize(static_cast<std::size_t>(max_len_uniform));
            glGetActiveUniform(
                program_id,
                static_cast<GLuint>(i),
                static_cast<GLsizei>(max_len_uniform),
                &length,
                &size,
                &type,
                &(su.name[0]));
            su.size = static_cast<int32_t>(size);
            su.name.resize(static_cast<std::size_t>(length));
            su.location = static_cast<int32_t>(glGetUniformLocation(program_id, su.name.c_str()));
            switch (type)
            {
                case GL_FLOAT:
                    su.type = "GL_FLOAT";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLfloat v[size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformfv(program_id, static_cast<GLint>(su.location)+j, &v[j]);
                            cx += snprintf(&su.value[cx], 1024, "%f;",
                                static_cast<float>(v[j]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_FLOAT_VEC2:
                    su.type = "GL_FLOAT_VEC2";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLfloat v[2 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformfv(program_id, static_cast<GLint>(su.location)+j, &v[2*j]);
                            cx += snprintf(&su.value[cx], 1024, "%f %f;",
                                static_cast<float>(v[2*j]), static_cast<float>(v[2*j+1]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_FLOAT_VEC3:
                    su.type = "GL_FLOAT_VEC3";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLfloat v[3 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformfv(program_id, static_cast<GLint>(su.location)+j, &v[3*j]);
                            cx += snprintf(&su.value[cx], 1024, "%f %f %f;",
                                static_cast<float>(v[3*j]), static_cast<float>(v[3*j+1]), static_cast<float>(v[3*j+2]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_FLOAT_VEC4:
                    su.type = "GL_FLOAT_VEC4";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLfloat v[4 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformfv(program_id, static_cast<GLint>(su.location)+j, &v[4*j]);
                            cx += snprintf(&su.value[cx], 1024, "%f %f %f %f;",
                                static_cast<float>(v[4*j]), static_cast<float>(v[4*j+1]), static_cast<float>(v[4*j+2]), static_cast<float>(v[4*j+3]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_INT:
                    su.type = "GL_INT";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLint v[size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformiv(program_id, static_cast<GLint>(su.location)+j, &v[j]);
                            cx += snprintf(&su.value[cx], 1024, "%d;",
                                static_cast<int>(v[j]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_INT_VEC2:
                    su.type = "GL_INT_VEC2";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLint v[2 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformiv(program_id, static_cast<GLint>(su.location)+j, &v[2*j]);
                            cx += snprintf(&su.value[cx], 1024, "%d %d;",
                                static_cast<int>(v[2*j]), static_cast<int>(v[2*j+1]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_INT_VEC3:
                    su.type = "GL_INT_VEC3";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLint v[3 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformiv(program_id, static_cast<GLint>(su.location)+j, &v[3*j]);
                            cx += snprintf(&su.value[cx], 1024, "%d %d %d;",
                                static_cast<int>(v[3*j]), static_cast<int>(v[3*j+1]), static_cast<int>(v[3*j+2]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_INT_VEC4:
                    su.type = "GL_INT_VEC4";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLint v[4 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformiv(program_id, static_cast<GLint>(su.location)+j, &v[4*j]);
                            cx += snprintf(&su.value[cx], 1024, "%d %d %d %d;",
                                static_cast<int>(v[4*j]), static_cast<int>(v[4*j+1]), static_cast<int>(v[4*j+2]), static_cast<int>(v[4*j+3]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_BOOL:
                    su.type = "GL_BOOL";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLint v[size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformiv(program_id, static_cast<GLint>(su.location)+j, &v[j]);
                            cx += snprintf(&su.value[cx], 1024, "%d;",
                                static_cast<int>(v[j]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_BOOL_VEC2:
                    su.type = "GL_BOOL_VEC2";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLint v[2 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformiv(program_id, static_cast<GLint>(su.location)+j, &v[2*j]);
                            cx += snprintf(&su.value[cx], 1024, "%d %d;",
                                static_cast<int>(v[2*j]), static_cast<int>(v[2*j+1]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_BOOL_VEC3:
                    su.type = "GL_BOOL_VEC3";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLint v[3 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformiv(program_id, static_cast<GLint>(su.location)+j, &v[3*j]);
                            cx += snprintf(&su.value[cx], 1024, "%d %d %d;",
                                static_cast<int>(v[3*j]), static_cast<int>(v[3*j+1]), static_cast<int>(v[3*j+2]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_BOOL_VEC4:
                    su.type = "GL_BOOL_VEC4";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLint v[4 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformiv(program_id, static_cast<GLint>(su.location)+j, &v[4*j]);
                            cx += snprintf(&su.value[cx], 1024, "%d %d %d %d;",
                                static_cast<int>(v[4*j]), static_cast<int>(v[4*j+1]), static_cast<int>(v[4*j+2]), static_cast<int>(v[4*j+3]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_FLOAT_MAT2:
                    su.type = "GL_FLOAT_MAT2";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLfloat v[4 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformfv(program_id, static_cast<GLint>(su.location)+j, &v[4*j]);
                            cx += snprintf(&su.value[cx], 1024, "%f %f %f %f;",
                                static_cast<float>(v[4*j]), static_cast<float>(v[4*j+1]), static_cast<float>(v[4*j+2]), static_cast<float>(v[4*j+3]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_FLOAT_MAT3:
                    su.type = "GL_FLOAT_MAT3";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLfloat v[9 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformfv(program_id, static_cast<GLint>(su.location)+j, &v[9*j]);
                            cx += snprintf(&su.value[cx], 1024, "%f %f %f %f %f %f %f %f %f;",
                                static_cast<float>(v[9*j]), static_cast<float>(v[9*j+1]), static_cast<float>(v[9*j+2]),
                                static_cast<float>(v[9*j+3]), static_cast<float>(v[9*j+4]), static_cast<float>(v[9*j+5]),
                                static_cast<float>(v[9*j+6]), static_cast<float>(v[9*j+7]), static_cast<float>(v[9*j+8]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_FLOAT_MAT4:
                    su.type = "GL_FLOAT_MAT4";
                    {
                        su.value.resize(1024);
                        int cx = 0;
                        GLfloat v[16 * size];
                        for (GLint j = 0 ; j < size ; j++)
                        {
                            glGetUniformfv(program_id, static_cast<GLint>(su.location)+j, &v[16*j]);
                            cx += snprintf(&su.value[cx], 1024, "%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f %f;",
                                static_cast<float>(v[16*j]), static_cast<float>(v[16*j+1]), static_cast<float>(v[16*j+2]), static_cast<float>(v[16*j+3]),
                                static_cast<float>(v[16*j+4]), static_cast<float>(v[16*j+5]), static_cast<float>(v[16*j+6]), static_cast<float>(v[16*j+7]),
                                static_cast<float>(v[16*j+8]), static_cast<float>(v[16*j+9]), static_cast<float>(v[16*j+10]), static_cast<float>(v[16*j+11]),
                                static_cast<float>(v[16*j+12]), static_cast<float>(v[16*j+13]), static_cast<float>(v[16*j+14]), static_cast<float>(v[16*j+15]));
                        }
                        su.value.resize(cx);
                    }
                    break;
                case GL_SAMPLER_2D:
                    su.type = "GL_SAMPLER_2D";
                    break;
                case GL_SAMPLER_CUBE:
                    su.type = "GL_SAMPLER_CUBE";
                    break;
                default:
                    su.type = "UNKNOWN";
                    break;
            }
        }
    }
    return true;
}

#endif
} // namespace skia
} // namespace renderengine
} // nam