/**
**
** Copyright 2010, The Android Open Source Project
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include "src/pixelflinger2/pixelflinger2.h"
#include "src/pixelflinger2/texture.h"
#include "src/mesa/main/mtypes.h"
#if !USE_LLVM_SCANLINE
static void Saturate(Vec4<BlendComp_t> * color)
{
color->r = MIN2(MAX2(color->r, 0), 255);
color->g = MIN2(MAX2(color->g, 0), 255);
color->b = MIN2(MAX2(color->b, 0), 255);
color->a = MIN2(MAX2(color->a, 0), 255);
}
static inline void RGBAIntToRGBAIntx4(unsigned rgba, Vec4<BlendComp_t> * color) __attribute__((always_inline));
static inline void RGBAIntToRGBAIntx4(unsigned rgba, Vec4<BlendComp_t> * color)
{
color->r = rgba & 0xff;
color->g = (rgba >>= 8) & 0xff;
color->b = (rgba >>= 8) & 0xff;
color->a = (rgba >>= 8);
}
static inline void RGBAFloatx4ToRGBAIntx4(Vector4 * v, Vec4<BlendComp_t> * color)
{
color->r = v->r * 255;
color->g = v->g * 255;
color->b = v->b * 255;
color->a = v->a * 255;
}
static inline unsigned RGBAIntx4ToRGBAInt(const Vec4<BlendComp_t> * color);
static inline unsigned RGBAIntx4ToRGBAInt(const Vec4<BlendComp_t> * color)
{
return color->r | (color->g << 8) | (color->b << 16) | (color->a << 24);
}
//static inline Pixel Vector4ToPixelRGBA(const Vector4 * color) __attribute__((always_inline));
//static inline Pixel Vector4ToPixelRGBA(const Vector4 * color)
//{
// Pixel pixel;
//#if defined(__ARM_HAVE_NEON) && USE_NEON
// int32x4_t c = vcvtq_s32_f32(vmulq_n_f32(color->f4, 255.0f));
// c = vminq_s32(c, vdupq_n_s32(255));
// c = vmaxq_s32(c, vdupq_n_s32(0));
// pixel.channels[0] = (unsigned char)vgetq_lane_s32(c, 0);
// pixel.channels[1] = (unsigned char)vgetq_lane_s32(c, 1);
// pixel.channels[2] = (unsigned char)vgetq_lane_s32(c, 2);
// pixel.channels[3] = (unsigned char)vgetq_lane_s32(c, 3);
//#else
// pixel.channels[0] = (unsigned char)MIN2(MAX2((short)(color->r * 255), 0), 255);
// pixel.channels[1] = (unsigned char)MIN2(MAX2((short)(color->g * 255), 0), 255);
// pixel.channels[2] = (unsigned char)MIN2(MAX2((short)(color->b * 255), 0), 255);
// pixel.channels[3] = (unsigned char)MIN2(MAX2((short)(color->a * 255), 0), 255);
//#endif //#if USE_FIXED_POINT
// return pixel;
//}
template<typename T>
static inline void BlendFactor(const unsigned mode, T & factor, const T & src,
const T & dst, const T & constant, const T & one,
const T & zero, const BlendComp_t & srcA, const BlendComp_t & dstA,
const BlendComp_t & constantA, const BlendComp_t & sOne) __attribute__((always_inline));
template<typename T>
static inline void BlendFactor(const unsigned mode, T & factor, const T & src,
const T & dst, const T & constant, const T & one,
const T & zero, const BlendComp_t & srcA, const BlendComp_t & dstA,
const BlendComp_t & constantA, const BlendComp_t & sOne)
{
switch (mode) {
case 0: // GL_ZERO
factor = zero;
return;
case 1: // GL_ONE
factor = one;
return;
case 2: // GL_SRC_COLOR:
factor = src;
return;
case 3: // GL_ONE_MINUS_SRC_COLOR:
factor = one;
factor -= src;
return;
case 4: // GL_DST_COLOR:
factor = dst;
return;
case 5: // GL_ONE_MINUS_DST_COLOR:
factor = one;
factor -= dst;
return;
case 6: // GL_SRC_ALPHA:
factor = srcA;
return;
case 7: // GL_ONE_MINUS_SRC_ALPHA:
factor = sOne - srcA;
return;
case 8: // GL_DST_ALPHA:
factor = dstA;
return;
case 9: // GL_ONE_MINUS_DST_ALPHA:
factor = sOne - dstA;
return;
case 10: // GL_SRC_ALPHA_SATURATE: // valid only for source color; src alpha = 1
factor = MIN2(srcA, sOne - dstA);
return;
case 11: // GL_CONSTANT_COLOR:
factor = constant;
return;
case 12: // GL_ONE_MINUS_CONSTANT_COLOR:
factor = one;
factor -= constant;
return;
case 13: // GL_CONSTANT_ALPHA:
factor = constantA;
return;
case 14: // GL_ONE_MINUS_CONSTANT_ALPHA:
factor = sOne - constantA;
return;
default:
assert(0);
return;
}
}
unsigned char StencilOp(const unsigned op, unsigned char s, const unsigned char ref)
{
switch (op) {
case 0: // GL_ZERO
return 0;
case 1: // GL_KEEP
return s;
case 2: // GL_REPLACE
return ref;
case 3: // GL_INCR
if (s < 255)
return ++s;
return s;
case 4: // GL_DECR
if (s > 0)
return --s;
return 0;
case 5: // GL_INVERT
return ~s;
case 6: // GL_INCR_WRAP
return ++s;
case 7: // GL_DECR_WRAP
return --s;
default:
assert(0);
return s;
}
}
#endif // #if !USE_LLVM_SCANLINE
#ifdef USE_LLVM_SCANLINE
typedef void (* ScanLineFunction_t)(VertexOutput * start, VertexOutput * step,
const float (*constants)[4], void * frame,
int * depth, unsigned char * stencil,
GGLActiveStencil *, unsigned count);
#endif
void GGLScanLine(const gl_shader_program * program, const GGLPixelFormat colorFormat,
void * frameBuffer, int * depthBuffer, unsigned char * stencilBuffer,
unsigned bufferWidth, unsigned bufferHeight, GGLActiveStencil * activeStencil,
const VertexOutput_t * start, const VertexOutput_t * end, const float (*constants)[4])
{
#if !USE_LLVM_SCANLINE
assert(!"only for USE_LLVM_SCANLINE");
#endif
// ALOGD("pf2: GGLScanLine program=%p format=0x%.2X frameBuffer=%p depthBuffer=%p stencilBuffer=%p ",
// program, colorFormat, frameBuffer, depthBuffer, stencilBuffer);
const unsigned int varyingCount = program->VaryingSlots;
const unsigned y = start->position.y, startX = start->position.x,
endX = end->position.x;
assert(bufferWidth > startX && bufferWidth > endX);
assert(bufferHeight > y);
char * frame = (char *)frameBuffer;
if (GGL_PIXEL_FORMAT_RGBA_8888 == colorFormat)
frame += (y * bufferWidth + startX) * 4;
else if (GGL_PIXEL_FORMAT_RGB_565 == colorFormat)
frame += (y * bufferWidth + startX) * 2;
else
assert(0);
const VectorComp_t div = VectorComp_t_CTR(1 / (float)(endX - startX));
//memcpy(ctx->glCtx->CurrentProgram->ValuesVertexOutput, start, sizeof(*start));
// shader symbols are mapped to gl_shader_program_Values*
//VertexOutput & vertex(*(VertexOutput*)ctx->glCtx->CurrentProgram->ValuesVertexOutput);
VertexOutput vertex(*start);
VertexOutput vertexDx(*end);
vertexDx.position -= start->position;
vertexDx.position *= div;
//printf("vertexDx.position.z=%.8g \n", vertexDx.position.z);
for (unsigned i = 0; i < varyingCount; i++) {
vertexDx.varyings[i] -= start->varyings[i];
vertexDx.varyings[i] *= div;
}
vertexDx.frontFacingPointCoord -= start->frontFacingPointCoord;
vertexDx.frontFacingPointCoord *= div; // gl_PointCoord, only zw
vertexDx.frontFacingPointCoord.y = 0; // gl_FrontFacing not interpolated
int * depth = depthBuffer + y * bufferWidth + startX;
unsigned char * stencil = stencilBuffer + y * bufferWidth + startX;
// TODO DXL consider inverting gl_FragCoord.y
ScanLineFunction_t scanLineFunction = (ScanLineFunction_t)
program->_LinkedShaders[MESA_SHADER_FRAGMENT]->function;
// ALOGD("pf2 GGLScanLine scanline=%p start=%p constants=%p", scanLineFunction, &vertex, constants);
if (endX >= startX)
scanLineFunction(&vertex, &vertexDx, constants, frame, depth, stencil, activeStencil, endX - startX + 1);
// ALOGD("pf2: GGLScanLine end");
}
template <bool StencilTest, bool DepthTest, bool DepthWrite, bool BlendEnable>
void ScanLine(const GGLInterface * iface, const VertexOutput * start, const VertexOutput * end)
{
GGL_GET_CONST_CONTEXT(ctx, iface);
GGLScanLine(ctx->CurrentProgram, ctx->frameSurface.format, ctx->frameSurface.data,
(int *)ctx->depthSurface.data, (unsigned char *)ctx->stencilSurface.data,
ctx->frameSurface.width, ctx->frameSurface.height, &ctx->activeStencil,
start, end, ctx->CurrentProgram->ValuesUniform);
// GGL_GET_CONST_CONTEXT(ctx, iface);
// // assert((unsigned)start->position.y == (unsigned)end->position.y);
// //
// // assert(GGL_PIXEL_FORMAT_RGBA_8888 == ctx->frameSurface.format);
// // assert(GGL_PIXEL_FORMAT_Z_32 == ctx->depthSurface.format);
// // assert(ctx->frameSurface.width == ctx->depthSurface.width);
// // assert(ctx->frameSurface.height == ctx->depthSurface.height);
//
// const unsigned int varyingCount = ctx->glCtx->CurrentProgram->VaryingSlots;
// const unsigned y = start->position.y, startX = start->position.x,
// endX = end->position.x;
//
// //assert(ctx->frameSurface.width > startX && ctx->frameSurface.width > endX);
// //assert(ctx->frameSurface.height > y);
//
// unsigned * frame = (unsigned *)ctx->frameSurface.data
// + y * ctx->frameSurface.width + startX;
// const VectorComp_t div = VectorComp_t_CTR(1 / (float)(endX - startX));
//
// //memcpy(ctx->glCtx->CurrentProgram->ValuesVertexOutput, start, sizeof(*start));
// // shader symbols are mapped to gl_shader_program_Values*
// //VertexOutput & vertex(*(VertexOutput*)ctx->glCtx->CurrentProgram->ValuesVertexOutput);
// VertexOutput vertex(*start);
// VertexOutput vertexDx(*end);
//
// vertexDx.position -= start->position;
// vertexDx.position *= div;
// //printf("vertexDx.position.z=%.8g \n", vertexDx.position.z);
// for (unsigned i = 0; i < varyingCount; i++) {
// vertexDx.varyings[i] -= start->varyings[i];
// vertexDx.varyings[i] *= div;
// }
// vertexDx.frontFacingPointCoord -= start->frontFacingPointCoord;
// vertexDx.frontFacingPointCoord *= div; // gl_PointCoord, only zw
// vertexDx.frontFacingPointCoord.y = 0; // gl_FrontFacing not interpolated
//
//#if USE_FORCED_FIXEDPOINT
// for (unsigned j = 0; j < 4; j++) {
// for (unsigned i = 0; i < varyingCount; i++) {
// vertex.varyings[i].i[j] = vertex.varyings[i].f[j] * 65536;
// vertexDx.varyings[i].i[j] = vertexDx.varyings[i].f[j] * 65536;
// }
// vertex.position.i[j] = vertex.position.f[j] * 65536;
// vertexDx.position.i[j] = vertexDx.position.f[j] * 65536;
// vertex.frontFacingPointCoord.i[j] = vertex.frontFacingPointCoord.f[j] * 65536;
// }
//#endif
//
// int * depth = (int *)ctx->depthSurface.data + y * ctx->frameSurface.width + startX;
// unsigned char * stencil = (unsigned char *)ctx->stencilSurface.data + y * ctx->frameSurface.width + startX;
//
//#if !USE_LLVM_TEXTURE_SAMPLER
// extern const GGLContext * textureGGLContext;
// textureGGLContext = ctx;
//#endif
//
// // TODO DXL consider inverting gl_FragCoord.y
//
//#if USE_LLVM_SCANLINE
// ScanLineFunction_t scanLineFunction = (ScanLineFunction_t)
// ctx->glCtx->CurrentProgram->_LinkedShaders[MESA_SHADER_FRAGMENT]->function;
// if (endX >= startX) {
// scanLineFunction(&vertex, &vertexDx, ctx->glCtx->CurrentProgram->ValuesUniform, frame, depth, stencil, &ctx->activeStencil, endX - startX + 1);
// }
//#else
//
// int z;
// bool sCmp = true; // default passed, unless failed by stencil test
// unsigned char s; // masked stored stencil value
// const unsigned char sMask = ctx->activeStencil.mask;
// const unsigned char sRef = ctx->activeStencil.ref;
// const unsigned sFunc = ctx->activeStencil.face ? 0x200 | ctx->backStencil.func :
// 0x200 | ctx->frontStencil.func;
// const unsigned ssFail = ctx->activeStencil.face ? ctx->backStencil.sFail :
// ctx->frontStencil.sFail;
// const unsigned sdFail = ctx->activeStencil.face ? ctx->backStencil.dFail :
// ctx->frontStencil.dFail;
// const unsigned sdPass = ctx->activeStencil.face ? ctx->backStencil.dPass :
// ctx->frontStencil.dPass;
//
// for (unsigned x = startX; x <= endX; x++) {
// //assert(abs((int)(vertex.position.x) - (int)x) < 2);
// //assert((unsigned)vertex.position.y == y);
// if (StencilTest) {
// s = *stencil & sMask;
// switch (sFunc) {
// case GL_NEVER:
// sCmp = false;
// break;
// case GL_LESS:
// sCmp = sRef < s;
// break;
// case GL_EQUAL:
// sCmp = sRef == s;
// break;
// case GL_LEQUAL:
// sCmp = sRef <= s;
// break;
// case GL_GREATER:
// sCmp = sRef > s;
// break;
// case GL_NOTEQUAL:
// sCmp = sRef != s;
// break;
// case GL_GEQUAL:
// sCmp = sRef >= s;
// break;
// case GL_ALWAYS:
// sCmp = true;
// break;
// default:
// assert(0);
// break;
// }
// }
//
// if (!StencilTest || sCmp) {
// z = vertex.position.i[2];
// if (z & 0x80000000) // negative float has leading 1
// z ^= 0x7fffffff; // bigger negative is smaller
// bool zCmp = true;
// if (DepthTest) {
// switch (0x200 | ctx->state.bufferState.depthFunc) {
// case GL_NEVER:
// zCmp = false;
// break;
// case GL_LESS:
// zCmp = z < *depth;
// break;
// case GL_EQUAL:
// zCmp = z == *depth;
// break;
// case GL_LEQUAL:
// zCmp = z <= *depth;
// break;
// case GL_GREATER:
// zCmp = z > *depth;
// break;
// case GL_NOTEQUAL:
// zCmp = z != *depth;
// break;
// case GL_GEQUAL:
// zCmp = z >= *depth;
// break;
// case GL_ALWAYS:
// zCmp = true;
// break;
// default:
// assert(0);
// break;
// }
// }
// if (!DepthTest || zCmp) {
// float * varying = (float *)ctx->glCtx->CurrentProgram->ValuesVertexOutput;
// ShaderFunction_t function = (ShaderFunction_t)ctx->glCtx->CurrentProgram->_LinkedShaders[MESA_SHADER_FRAGMENT]->function;
// function(&vertex, &vertex, ctx->glCtx->CurrentProgram->ValuesUniform);
// //ctx->glCtx->CurrentProgram->_LinkedShaders[MESA_SHADER_FRAGMENT]->function();
// if (BlendEnable) {
// BlendComp_t sOne = 255, sZero = 0;
// Vec4<BlendComp_t> one = sOne, zero = sZero;
//
// Vec4<BlendComp_t> src;
//// if (outputRegDesc.IsInt32Color())
//// RGBAIntToRGBAIntx4(vertex.fragColor[0].u[0], &src);
//// else if (outputRegDesc.IsVectorType(Float))
// RGBAFloatx4ToRGBAIntx4(&vertex.fragColor[0], &src);
//// else if (outputRegDesc.IsVectorType(Fixed8))
//// {
//// src.u[0] = vertex.fragColor[0].u[0];
//// src.u[1] = vertex.fragColor[0].u[1];
//// src.u[2] = vertex.fragColor[0].u[2];
//// src.u[3] = vertex.fragColor[0].u[3];
//// }
//// else
//// assert(0);
//
// Vec4<BlendComp_t> dst;
// unsigned dc = *frame;
// dst.r = dc & 255;
// dst.g = (dc >>= 8) & 255;
// dst.b = (dc >>= 8) & 255;
// dst.a = (dc >>= 8) & 255;
//
// Vec4<BlendComp_t> sf, df;
// Vec4<BlendComp_t> blendStateColor(ctx->state.blendState.color[0], ctx->state.blendState.color[1],
// ctx->state.blendState.color[2], ctx->state.blendState.color[3]);
//
// BlendFactor(ctx->state.blendState.scf, sf, src, dst,
// blendStateColor, one, zero, src.a, dst.a,
// blendStateColor.a, sOne);
// if (ctx->state.blendState.scf != ctx->state.blendState.saf)
// BlendFactor(ctx->state.blendState.saf, sf.a, src.a, dst.a,
// blendStateColor.a, sOne, sZero, src.a, dst.a,
// blendStateColor.a, sOne);
// BlendFactor(ctx->state.blendState.dcf, df, src, dst,
// blendStateColor, one, zero, src.a, dst.a,
// blendStateColor.a, sOne);
// if (ctx->state.blendState.dcf != ctx->state.blendState.daf)
// BlendFactor(ctx->state.blendState.daf, df.a, src.a, dst.a,
// blendStateColor.a, sOne, sZero, src.a, dst.a,
// blendStateColor.a, sOne);
//
// Vec4<BlendComp_t> sfs(sf), dfs(df);
// sfs.LShr(7);
// sf += sfs;
// dfs.LShr(7);
// df += dfs;
//
// src *= sf;
// dst *= df;
// Vec4<BlendComp_t> res(src);
// switch (ctx->state.blendState.ce + GL_FUNC_ADD) {
// case GL_FUNC_ADD:
// res += dst;
// break;
// case GL_FUNC_SUBTRACT:
// res -= dst;
// break;
// case GL_FUNC_REVERSE_SUBTRACT:
// res = dst;
// res -= src;
// break;
// default:
// assert(0);
// break;
// }
// if (ctx->state.blendState.ce != ctx->state.blendState.ae)
// switch (ctx->state.blendState.ce + GL_FUNC_ADD) {
// case GL_FUNC_ADD:
// res.a = src.a + dst.a;
// break;
// case GL_FUNC_SUBTRACT:
// res.a = src.a - dst.a;
// break;
// case GL_FUNC_REVERSE_SUBTRACT:
// res.a = dst.a - src.a;
// break;
// default:
// assert(0);
// break;
// }
//
// res.AShr(8);
// Saturate(&res);
// *frame = RGBAIntx4ToRGBAInt(&res);
// } else {
//// if (outputRegDesc.IsInt32Color())
//// *frame = vertex.fragColor[0].u[0];
//// else if (outputRegDesc.IsVectorType(Float))
// {
// Vec4<BlendComp_t> src;
// RGBAFloatx4ToRGBAIntx4(&vertex.fragColor[0], &src);
// Saturate(&src);
// *frame = RGBAIntx4ToRGBAInt(&src);
// }
//// else if (outputRegDesc.IsVectorType(Fixed16))
//// {
//// Vec4<BlendComp_t> & src = (Vec4<BlendComp_t> &)vertex.fragColor[0];
//// src.r = (src.r * 255 >> 16);
//// src.g = (src.g * 255 >> 16);
//// src.b = (src.b * 255 >> 16);
//// src.a = (src.a * 255 >> 16);
//// Saturate(&src);
//// *frame = RGBAIntx4ToRGBAInt(&src);
//// }
//// else if (outputRegDesc.IsVectorType(Fixed8))
//// {
//// Vec4<BlendComp_t> & src = (Vec4<BlendComp_t> &)vertex.fragColor[0];
//// Saturate(&src);
//// *frame = RGBAIntx4ToRGBAInt(&src);
//// }
//// else
//// assert(0);
// }
//
// if (DepthWrite)
// *depth = z;
// if (StencilTest)
// *stencil = StencilOp(sdPass, s, sRef);
// } else if (StencilTest)
// *stencil = StencilOp(sdFail, s, sRef);
// } else if (StencilTest)
// *stencil = StencilOp(ssFail, s, sRef);
//
// frame++;
// depth++;
// stencil++;
//
//#if USE_FORCED_FIXEDPOINT
// for (unsigned j = 0; j < 4; j++) {
// if (ctx->glCtx->Shader.CurrentProgram->FragmentProgram->UsesFragCoord)
// vertex.position.i[j] += vertexDx.position.i[j];
// for (unsigned i = 0; i < varyingCount; i++)
// vertex.varyings[i].i[j] += vertexDx.varyings[i].i[j];
// }
// vertex.position.i[2] += vertexDx.position.i[2];
// if (ctx->glCtx->Shader.CurrentProgram->FragmentProgram->UsesPointCoord) {
// vertex.frontFacingPointCoord.i[2] = vertexDx.frontFacingPointCoord.i[2];
// vertex.frontFacingPointCoord.i[3] = vertexDx.frontFacingPointCoord.i[3];
// }
//#else
// if (ctx->glCtx->CurrentProgram->UsesFragCoord)
// vertex.position += vertexDx.position;
// else if (ctx->state.bufferState.depthTest)
// vertex.position.z += vertexDx.position.z;
//
// for (unsigned i = 0; i < varyingCount; i++)
// vertex.varyings[i] += vertexDx.varyings[i];
// if (ctx->glCtx->CurrentProgram->UsesPointCoord) {
// vertex.frontFacingPointCoord.z += vertexDx.frontFacingPointCoord.z;
// vertex.frontFacingPointCoord.w += vertexDx.frontFacingPointCoord.w;
// }
//#endif // #if USE_FORCED_FIXEDPOINT
// }
//
//#endif // #if USE_LLVM_SCANLINE
//
//#if !USE_LLVM_TEXTURE_SAMPLER
// textureGGLContext = NULL;
//#endif
}
static void PickScanLine(GGLInterface * iface)
{
GGL_GET_CONTEXT(ctx, iface);
ctx->interface.ScanLine = NULL;
if (ctx->state.bufferState.stencilTest) {
if (ctx->state.bufferState.depthTest) {
if (ctx->state.blendState.enable)
ctx->interface.ScanLine = ScanLine<true, true, true, true>;
else
ctx->interface.ScanLine = ScanLine<true, true, true, false>;
} else {
if (ctx->state.blendState.enable)
ctx->interface.ScanLine = ScanLine<true, false, false, true>;
else
ctx->interface.ScanLine = ScanLine<true, false, false, false>;
}
} else {
if (ctx->state.bufferState.depthTest) {
if (ctx->state.blendState.enable)
ctx->interface.ScanLine = ScanLine<false, true, true, true>;
else
ctx->interface.ScanLine = ScanLine<false, true, true, false>;
} else {
if (ctx->state.blendState.enable)
ctx->interface.ScanLine = ScanLine<false, false, false, true>;
else
ctx->interface.ScanLine = ScanLine<false, false, false, false>;
}
}
assert(ctx->interface.ScanLine);
}
void InitializeScanLineFunctions(GGLInterface * iface)
{
GGL_GET_CONTEXT(ctx, iface);
ctx->PickScanLine = PickScanLine;
}