src/pixelflinger2/buffer.cpp - platform/external/mesa3d - Git at Google

 /**
  **
  ** 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;
 }
	/**
	**
	** 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;
	}