src/pixelflinger2/buffer.cpp

/**
 **
 ** 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 "src/pixelflinger2/pixelflinger2.h"

#include <string.h>
#include <stdio.h>

void SetShaderVerifyFunctions(GGLInterface *);

static void DepthFunc(GGLInterface * iface, GLenum func)
{
   GGL_GET_CONTEXT(ctx, iface);
   if (GL_NEVER > func || GL_ALWAYS < func)
      return gglError(GL_INVALID_ENUM);
   ctx->state.bufferState.depthFunc = func & 0x7;
   SetShaderVerifyFunctions(iface);
}

static void StencilFuncSeparate(GGLInterface * iface, GLenum face, GLenum func, GLint ref, GLuint mask)
{
   GGL_GET_CONTEXT(ctx, iface);
   if (GL_FRONT > face || GL_FRONT_AND_BACK < face)
      return gglError(GL_INVALID_ENUM);
   if (GL_NEVER > func || GL_ALWAYS < func)
      return gglError(GL_INVALID_ENUM);
   mask &= 0xff;
   ref = MAX2(MIN2(ref, 0xff), 0);
   ref &= mask;
   if (GL_FRONT == face || GL_FRONT_AND_BACK == face) {
      ctx->state.frontStencil.ref = ref;
      ctx->state.frontStencil.mask = mask;
      ctx->state.frontStencil.func = func & 0x7;
   }
   if (GL_BACK == face || GL_FRONT_AND_BACK == face) {
      ctx->state.backStencil.ref = ref;
      ctx->state.backStencil.mask = mask;
      ctx->state.backStencil.func = func & 0x7;
   }
   SetShaderVerifyFunctions(iface);
}

static unsigned StencilOpEnum(GLenum func, unsigned oldValue)
{
   switch (func) {
   case GL_ZERO:
      return 0;
   case GL_KEEP: // fall through
   case GL_REPLACE: // fall through
   case GL_INCR: // fall through
   case GL_DECR:
      return func - GL_KEEP + 1;
      break;
   case GL_INVERT:
      return 5;
   case GL_INCR_WRAP:
      return 6;
   case GL_DECR_WRAP:
      return 7;
   default:
      gglError(GL_INVALID_ENUM);
      return oldValue;
   }
}

static void StencilOpSeparate(GGLInterface * iface, GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
   GGL_GET_CONTEXT(ctx, iface);
   if (GL_FRONT > face || GL_FRONT_AND_BACK < face)
      return gglError(GL_INVALID_ENUM);
   if (GL_FRONT == face || GL_FRONT_AND_BACK == face) {
      ctx->state.frontStencil.sFail = StencilOpEnum(sfail, ctx->state.frontStencil.sFail);
      ctx->state.frontStencil.dFail = StencilOpEnum(dpfail, ctx->state.frontStencil.dFail);
      ctx->state.frontStencil.dPass = StencilOpEnum(dppass, ctx->state.frontStencil.dPass);
   }
   if (GL_BACK == face || GL_FRONT_AND_BACK == face) {
      ctx->state.backStencil.sFail = StencilOpEnum(sfail, ctx->state.backStencil.sFail);
      ctx->state.backStencil.dFail = StencilOpEnum(dpfail, ctx->state.backStencil.dFail);
      ctx->state.backStencil.dPass = StencilOpEnum(dppass, ctx->state.backStencil.dPass);
   }
   SetShaderVerifyFunctions(iface);
}

static void StencilSelect(const GGLInterface * iface, GLenum face)
{
   GGL_GET_CONTEXT(ctx, iface);
   if (GL_FRONT == face) {
      ctx->activeStencil.face = 0;
      ctx->activeStencil.ref = ctx->state.frontStencil.ref;
      ctx->activeStencil.mask = ctx->state.frontStencil.mask;
   } else if (GL_BACK == face) {
      ctx->activeStencil.face = 1;
      ctx->activeStencil.ref = ctx->state.backStencil.ref;
      ctx->activeStencil.mask = ctx->state.backStencil.mask;
   }
}

static void ClearStencil(GGLInterface * iface, GLint s)
{
   GGL_GET_CONTEXT(ctx, iface);
   ctx->clearState.stencil = 0x01010101 * ((unsigned &)s & 0xff);
}

static void ClearColor(GGLInterface * iface, GLclampf r, GLclampf g, GLclampf b, GLclampf a)
{
   GGL_GET_CONTEXT(ctx, iface);
   r = MAX2(MIN2(r, 1.0f), 0);
   g = MAX2(MIN2(g, 1.0f), 0);
   b = MAX2(MIN2(b, 1.0f), 0);
   a = MAX2(MIN2(a, 1.0f), 0);
   ctx->clearState.color = (unsigned(a * 255) << 24) | (unsigned(b * 255) << 16) |
                           (unsigned(g * 255) << 8) | unsigned(r * 255);
}

static void ClearDepthf(GGLInterface * iface, GLclampf d)
{
   GGL_GET_CONTEXT(ctx, iface);
   // assuming ieee 754 32 bit float and 32 bit 2's complement int
   assert(sizeof(d) == sizeof(ctx->clearState.depth));
   ctx->clearState.depth = (int &)d; // bit reinterpretation
   if (0x80000000 & ctx->clearState.depth) // smaller negative float has bigger int representation, so flip
      ctx->clearState.depth ^= 0x7fffffff; // since -FLT_MAX is close to -1 when bitcasted
}

static void Clear(const GGLInterface * iface, GLbitfield buf)
{
   GGL_GET_CONST_CONTEXT(ctx, iface);

   // TODO DXL scissor test
   if (GL_COLOR_BUFFER_BIT & buf && ctx->frameSurface.data) {
      if (GGL_PIXEL_FORMAT_RGBA_8888 == ctx->frameSurface.format) {
         unsigned * const end = (unsigned *)ctx->frameSurface.data +
                                ctx->frameSurface.width * ctx->frameSurface.height;
         const unsigned color = ctx->clearState.color;
         for (unsigned * start = (unsigned *)ctx->frameSurface.data; start < end; start++)
            *start = color;
      } else if (GGL_PIXEL_FORMAT_RGB_565 == ctx->frameSurface.format) {
         short * const end = (short *)ctx->frameSurface.data +
                             ctx->frameSurface.width * ctx->frameSurface.height;
         unsigned r = ctx->clearState.color & 0xf8, g = ctx->clearState.color & 0xfc00,
                      b = ctx->clearState.color & 0xf80000;
         const short color = (b >> 19) | (g >> 5) | (r >> 3);
         for (short * start = (short *)ctx->frameSurface.data; start < end; start++)
            *start = color;
      } else
         assert(0);
   }
   if (GL_DEPTH_BUFFER_BIT & buf && ctx->depthSurface.data) {
      assert(GGL_PIXEL_FORMAT_Z_32 == ctx->depthSurface.format);
      unsigned * const end = (unsigned *)ctx->depthSurface.data +
                             ctx->depthSurface.width * ctx->depthSurface.height;
      const unsigned depth = ctx->clearState.depth;
      for (unsigned * start = (unsigned *)ctx->depthSurface.data; start < end; start++)
         *start = depth;
   }
   if (GL_STENCIL_BUFFER_BIT & buf && ctx->stencilSurface.data) {
      assert(GGL_PIXEL_FORMAT_S_8 == ctx->stencilSurface.format);
      unsigned * const end = (unsigned *)((unsigned char *)ctx->stencilSurface.data +
                                          ctx->stencilSurface.width * ctx->stencilSurface.height);
      unsigned * start = (unsigned *)ctx->stencilSurface.data;
      const unsigned stencil = ctx->clearState.stencil;
      for (start; start < end; start++)
         *start = stencil;
      start--;
      for (unsigned char * i = (unsigned char *)start; i < (unsigned char *)end; i++)
         *i = stencil & 0xff;
   }
}

static void SetBuffer(GGLInterface * iface, const GLenum type, GGLSurface * surface)
{
   GGL_GET_CONTEXT(ctx, iface);
   bool changed = false;
   if (GL_COLOR_BUFFER_BIT == type) {
      if (surface) {
         ctx->frameSurface = *surface;
         changed |= ctx->frameSurface.format ^ surface->format;
         switch (surface->format) {
         case GGL_PIXEL_FORMAT_RGBA_8888:
         case GGL_PIXEL_FORMAT_RGB_565:
            break;
         case GGL_PIXEL_FORMAT_RGBX_8888:
         default:
            ALOGD("pf2: SetBuffer 0x%.04X format=0x%.02X \n", type, surface ? surface->format : 0);
            assert(0);
         }
      } else {
         memset(&ctx->frameSurface, 0, sizeof(ctx->frameSurface));
         changed = true;
      }
      ctx->state.bufferState.colorFormat = ctx->frameSurface.format;
   } else if (GL_DEPTH_BUFFER_BIT == type) {
      if (surface) {
         ctx->depthSurface = *surface;
         changed |= ctx->depthSurface.format ^ surface->format;
         assert(GGL_PIXEL_FORMAT_Z_32 == ctx->depthSurface.format);
      } else {
         memset(&ctx->depthSurface, 0, sizeof(ctx->depthSurface));
         changed = true;
      }
      ctx->state.bufferState.depthFormat = ctx->depthSurface.format;
   } else if (GL_STENCIL_BUFFER_BIT == type) {
      if (surface) {
         ctx->stencilSurface = *surface;
         changed |= ctx->stencilSurface.format ^ surface->format;
         assert(GGL_PIXEL_FORMAT_S_8 == ctx->stencilSurface.format);
      } else {
         memset(&ctx->stencilSurface, 0, sizeof(ctx->stencilSurface));
         changed = true;
      }
      ctx->state.bufferState.stencilFormat = ctx->stencilSurface.format;
   } else
      gglError(GL_INVALID_ENUM);
   if (changed) {
      SetShaderVerifyFunctions(iface);
   }
}

void InitializeBufferFunctions(GGLInterface * iface)
{
   iface->DepthFunc = DepthFunc;
   iface->StencilFuncSeparate = StencilFuncSeparate;
   iface->StencilOpSeparate = StencilOpSeparate;
   iface->StencilSelect = StencilSelect;
   iface->ClearStencil = ClearStencil;
   iface->ClearColor = ClearColor;
   iface->ClearDepthf = ClearDepthf;
   iface->Clear = Clear;
   iface->SetBuffer = SetBuffer;
}