425 lines
19 KiB
C++
425 lines
19 KiB
C++
|
/* 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
|
||
|
|
|