opengl/libagl/TextureObjectManager.cpp - android_frameworks_native - Gitiles

 /*
  ** Copyright 2006, 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 <stdio.h>
 #include <stdlib.h>
 #include "context.h"
 #include "TextureObjectManager.h"

 #include <private/ui/android_natives_priv.h>

 namespace android {
 // ----------------------------------------------------------------------------

 EGLTextureObject::EGLTextureObject()
     : mSize(0)
 {
     init();
 }

 EGLTextureObject::~EGLTextureObject()
 {
     if (!direct) {
         if (mSize && surface.data)
             free(surface.data);
         if (mMipmaps)
             freeMipmaps();
     }
 }

 void EGLTextureObject::init()
 {
     memset(&surface, 0, sizeof(surface));
     surface.version = sizeof(surface);
     mMipmaps = 0;
     mNumExtraLod = 0;
     mIsComplete = false;
     wraps = GL_REPEAT;
     wrapt = GL_REPEAT;
     min_filter = GL_LINEAR;
     mag_filter = GL_LINEAR;
     internalformat = 0;
     memset(crop_rect, 0, sizeof(crop_rect));
     generate_mipmap = GL_FALSE;
     direct = GL_FALSE;
     buffer = 0;
 }

 void EGLTextureObject::copyParameters(const sp<EGLTextureObject>& old)
 {
     wraps = old->wraps;
     wrapt = old->wrapt;
     min_filter = old->min_filter;
     mag_filter = old->mag_filter;
     memcpy(crop_rect, old->crop_rect, sizeof(crop_rect));
     generate_mipmap = old->generate_mipmap;
     direct = old->direct;
 }

 status_t EGLTextureObject::allocateMipmaps()
 {
     // here, by construction, mMipmaps=0 && mNumExtraLod=0

     if (!surface.data)
         return NO_INIT;

     int w = surface.width;
     int h = surface.height;
     const int numLods = 31 - gglClz(max(w,h));
     if (numLods <= 0)
         return NO_ERROR;

     mMipmaps = (GGLSurface*)malloc(numLods * sizeof(GGLSurface));
     if (!mMipmaps)
         return NO_MEMORY;

     memset(mMipmaps, 0, numLods * sizeof(GGLSurface));
     mNumExtraLod = numLods;
     return NO_ERROR;
 }

 void EGLTextureObject::freeMipmaps()
 {
     if (mMipmaps) {
         for (int i=0 ; i<mNumExtraLod ; i++) {
             if (mMipmaps[i].data) {
                 free(mMipmaps[i].data);
             }
         }
         free(mMipmaps);
         mMipmaps = 0;
         mNumExtraLod = 0;
     }
 }

 const GGLSurface& EGLTextureObject::mip(int lod) const
 {
     if (lod<=0 || !mMipmaps)
         return surface;
     lod = min(lod-1, mNumExtraLod-1);
     return mMipmaps[lod];
 }

 GGLSurface& EGLTextureObject::editMip(int lod)
 {
     return const_cast<GGLSurface&>(mip(lod));
 }

 status_t EGLTextureObject::setSurface(GGLSurface const* s)
 {
     // XXX: glFlush() on 's'
     if (mSize && surface.data) {
         free(surface.data);
     }
     surface = *s;
     internalformat = 0;
     buffer = 0;

     // we should keep the crop_rect, but it's delicate because
     // the new size of the surface could make it invalid.
     // so for now, we just loose it.
     memset(crop_rect, 0, sizeof(crop_rect));

     // it would be nice if we could keep the generate_mipmap flag,
     // we would have to generate them right now though.
     generate_mipmap = GL_FALSE;

     direct = GL_TRUE;
     mSize = 0;  // we don't own this surface
     if (mMipmaps)
         freeMipmaps();
     mIsComplete = true;
     return NO_ERROR;
 }

 status_t EGLTextureObject::setImage(ANativeWindowBuffer* native_buffer)
 {
     GGLSurface sur;
     sur.version = sizeof(GGLSurface);
     sur.width = native_buffer->width;
     sur.height= native_buffer->height;
     sur.stride= native_buffer->stride;
     sur.format= native_buffer->format;
     sur.data  = 0;
     setSurface(&sur);
     buffer = native_buffer;
     return NO_ERROR;
 }

 status_t EGLTextureObject::reallocate(
         GLint level, int w, int h, int s,
         int format, int compressedFormat, int bpr)
 {
     const size_t size = h * bpr;
     if (level == 0)
     {
         if (size!=mSize || !surface.data) {
             if (mSize && surface.data) {
                 free(surface.data);
             }
             surface.data = (GGLubyte*)malloc(size);
             if (!surface.data) {
                 mSize = 0;
                 mIsComplete = false;
                 return NO_MEMORY;
             }
             mSize = size;
         }
         surface.version = sizeof(GGLSurface);
         surface.width  = w;
         surface.height = h;
         surface.stride = s;
         surface.format = format;
         surface.compressedFormat = compressedFormat;
         if (mMipmaps)
             freeMipmaps();
         mIsComplete = true;
     }
     else
     {
         if (!mMipmaps) {
             if (allocateMipmaps() != NO_ERROR)
                 return NO_MEMORY;
         }

         ALOGW_IF(level-1 >= mNumExtraLod,
                 "specifying mipmap level %d, but # of level is %d",
                 level, mNumExtraLod+1);

         GGLSurface& mipmap = editMip(level);
         if (mipmap.data)
             free(mipmap.data);

         mipmap.data = (GGLubyte*)malloc(size);
         if (!mipmap.data) {
             memset(&mipmap, 0, sizeof(GGLSurface));
             mIsComplete = false;
             return NO_MEMORY;
         }

         mipmap.version = sizeof(GGLSurface);
         mipmap.width  = w;
         mipmap.height = h;
         mipmap.stride = s;
         mipmap.format = format;
         mipmap.compressedFormat = compressedFormat;

         // check if the texture is complete
         mIsComplete = true;
         const GGLSurface* prev = &surface;
         for (int i=0 ; i<mNumExtraLod ; i++) {
             const GGLSurface* curr = mMipmaps + i;
             if (curr->format != surface.format) {
                 mIsComplete = false;
                 break;
             }

             uint32_t w = (prev->width  >> 1) ? : 1;
             uint32_t h = (prev->height >> 1) ? : 1;
             if (w != curr->width || h != curr->height) {
                 mIsComplete = false;
                 break;
             }
             prev = curr;
         }
     }
     return NO_ERROR;
 }

 // ----------------------------------------------------------------------------

 EGLSurfaceManager::EGLSurfaceManager()
     : TokenManager()
 {
 }

 EGLSurfaceManager::~EGLSurfaceManager()
 {
     // everything gets freed automatically here...
 }

 sp<EGLTextureObject> EGLSurfaceManager::createTexture(GLuint name)
 {
     sp<EGLTextureObject> result;

     Mutex::Autolock _l(mLock);
     if (mTextures.indexOfKey(name) >= 0)
         return result; // already exists!

     result = new EGLTextureObject();

     status_t err = mTextures.add(name, result);
     if (err < 0)
         result.clear();

     return result;
 }

 sp<EGLTextureObject> EGLSurfaceManager::removeTexture(GLuint name)
 {
     Mutex::Autolock _l(mLock);
     const ssize_t index = mTextures.indexOfKey(name);
     if (index >= 0) {
         sp<EGLTextureObject> result(mTextures.valueAt(index));
         mTextures.removeItemsAt(index);
         return result;
     }
     return 0;
 }

 sp<EGLTextureObject> EGLSurfaceManager::replaceTexture(GLuint name)
 {
     sp<EGLTextureObject> tex;
     Mutex::Autolock _l(mLock);
     const ssize_t index = mTextures.indexOfKey(name);
     if (index >= 0) {
         const sp<EGLTextureObject>& old = mTextures.valueAt(index);
         const uint32_t refs = old->getStrongCount();
         if (ggl_likely(refs == 1)) {
             // we're the only owner
             tex = old;
         } else {
             // keep the texture's parameters
             tex = new EGLTextureObject();
             tex->copyParameters(old);
             mTextures.removeItemsAt(index);
             mTextures.add(name, tex);
         }
     }
     return tex;
 }

 void EGLSurfaceManager::deleteTextures(GLsizei n, const GLuint *tokens)
 {
     // free all textures
     Mutex::Autolock _l(mLock);
     for (GLsizei i=0 ; i<n ; i++) {
         const GLuint t(*tokens++);
         if (t) {
             mTextures.removeItem(t);
         }
     }
 }

 sp<EGLTextureObject> EGLSurfaceManager::texture(GLuint name)
 {
     Mutex::Autolock _l(mLock);
     const ssize_t index = mTextures.indexOfKey(name);
     if (index >= 0)
         return mTextures.valueAt(index);
     return 0;
 }

 // ----------------------------------------------------------------------------
 }; // namespace android
	/*
	** Copyright 2006, 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 <stdio.h>
	#include <stdlib.h>
	#include "context.h"
	#include "TextureObjectManager.h"

	#include <private/ui/android_natives_priv.h>

	namespace android {
	// ----------------------------------------------------------------------------

	EGLTextureObject::EGLTextureObject()
	: mSize(0)
	{
	init();
	}

	EGLTextureObject::~EGLTextureObject()
	{
	if (!direct) {
	if (mSize && surface.data)
	free(surface.data);
	if (mMipmaps)
	freeMipmaps();
	}
	}

	void EGLTextureObject::init()
	{
	memset(&surface, 0, sizeof(surface));
	surface.version = sizeof(surface);
	mMipmaps = 0;
	mNumExtraLod = 0;
	mIsComplete = false;
	wraps = GL_REPEAT;
	wrapt = GL_REPEAT;
	min_filter = GL_LINEAR;
	mag_filter = GL_LINEAR;
	internalformat = 0;
	memset(crop_rect, 0, sizeof(crop_rect));
	generate_mipmap = GL_FALSE;
	direct = GL_FALSE;
	buffer = 0;
	}

	void EGLTextureObject::copyParameters(const sp<EGLTextureObject>& old)
	{
	wraps = old->wraps;
	wrapt = old->wrapt;
	min_filter = old->min_filter;
	mag_filter = old->mag_filter;
	memcpy(crop_rect, old->crop_rect, sizeof(crop_rect));
	generate_mipmap = old->generate_mipmap;
	direct = old->direct;
	}

	status_t EGLTextureObject::allocateMipmaps()
	{
	// here, by construction, mMipmaps=0 && mNumExtraLod=0

	if (!surface.data)
	return NO_INIT;

	int w = surface.width;
	int h = surface.height;
	const int numLods = 31 - gglClz(max(w,h));
	if (numLods <= 0)
	return NO_ERROR;

	mMipmaps = (GGLSurface)malloc(numLods sizeof(GGLSurface));
	if (!mMipmaps)
	return NO_MEMORY;

	memset(mMipmaps, 0, numLods * sizeof(GGLSurface));
	mNumExtraLod = numLods;
	return NO_ERROR;
	}

	void EGLTextureObject::freeMipmaps()
	{
	if (mMipmaps) {
	for (int i=0 ; i<mNumExtraLod ; i++) {
	if (mMipmaps[i].data) {
	free(mMipmaps[i].data);
	}
	}
	free(mMipmaps);
	mMipmaps = 0;
	mNumExtraLod = 0;
	}
	}

	const GGLSurface& EGLTextureObject::mip(int lod) const
	{
	if (lod<=0 \|\| !mMipmaps)
	return surface;
	lod = min(lod-1, mNumExtraLod-1);
	return mMipmaps[lod];
	}

	GGLSurface& EGLTextureObject::editMip(int lod)
	{
	return const_cast<GGLSurface&>(mip(lod));
	}

	status_t EGLTextureObject::setSurface(GGLSurface const* s)
	{
	// XXX: glFlush() on 's'
	if (mSize && surface.data) {
	free(surface.data);
	}
	surface = *s;
	internalformat = 0;
	buffer = 0;

	// we should keep the crop_rect, but it's delicate because
	// the new size of the surface could make it invalid.
	// so for now, we just loose it.
	memset(crop_rect, 0, sizeof(crop_rect));

	// it would be nice if we could keep the generate_mipmap flag,
	// we would have to generate them right now though.
	generate_mipmap = GL_FALSE;

	direct = GL_TRUE;
	mSize = 0; // we don't own this surface
	if (mMipmaps)
	freeMipmaps();
	mIsComplete = true;
	return NO_ERROR;
	}

	status_t EGLTextureObject::setImage(ANativeWindowBuffer* native_buffer)
	{
	GGLSurface sur;
	sur.version = sizeof(GGLSurface);
	sur.width = native_buffer->width;
	sur.height= native_buffer->height;
	sur.stride= native_buffer->stride;
	sur.format= native_buffer->format;
	sur.data = 0;
	setSurface(&sur);
	buffer = native_buffer;
	return NO_ERROR;
	}

	status_t EGLTextureObject::reallocate(
	GLint level, int w, int h, int s,
	int format, int compressedFormat, int bpr)
	{
	const size_t size = h * bpr;
	if (level == 0)
	{
	if (size!=mSize \|\| !surface.data) {
	if (mSize && surface.data) {
	free(surface.data);
	}
	surface.data = (GGLubyte*)malloc(size);
	if (!surface.data) {
	mSize = 0;
	mIsComplete = false;
	return NO_MEMORY;
	}
	mSize = size;
	}
	surface.version = sizeof(GGLSurface);
	surface.width = w;
	surface.height = h;
	surface.stride = s;
	surface.format = format;
	surface.compressedFormat = compressedFormat;
	if (mMipmaps)
	freeMipmaps();
	mIsComplete = true;
	}
	else
	{
	if (!mMipmaps) {
	if (allocateMipmaps() != NO_ERROR)
	return NO_MEMORY;
	}

	ALOGW_IF(level-1 >= mNumExtraLod,
	"specifying mipmap level %d, but # of level is %d",
	level, mNumExtraLod+1);

	GGLSurface& mipmap = editMip(level);
	if (mipmap.data)
	free(mipmap.data);

	mipmap.data = (GGLubyte*)malloc(size);
	if (!mipmap.data) {
	memset(&mipmap, 0, sizeof(GGLSurface));
	mIsComplete = false;
	return NO_MEMORY;
	}

	mipmap.version = sizeof(GGLSurface);
	mipmap.width = w;
	mipmap.height = h;
	mipmap.stride = s;
	mipmap.format = format;
	mipmap.compressedFormat = compressedFormat;

	// check if the texture is complete
	mIsComplete = true;
	const GGLSurface* prev = &surface;
	for (int i=0 ; i<mNumExtraLod ; i++) {
	const GGLSurface* curr = mMipmaps + i;
	if (curr->format != surface.format) {
	mIsComplete = false;
	break;
	}

	uint32_t w = (prev->width >> 1) ? : 1;
	uint32_t h = (prev->height >> 1) ? : 1;
	if (w != curr->width \|\| h != curr->height) {
	mIsComplete = false;
	break;
	}
	prev = curr;
	}
	}
	return NO_ERROR;
	}

	// ----------------------------------------------------------------------------

	EGLSurfaceManager::EGLSurfaceManager()
	: TokenManager()
	{
	}

	EGLSurfaceManager::~EGLSurfaceManager()
	{
	// everything gets freed automatically here...
	}

	sp<EGLTextureObject> EGLSurfaceManager::createTexture(GLuint name)
	{
	sp<EGLTextureObject> result;

	Mutex::Autolock _l(mLock);
	if (mTextures.indexOfKey(name) >= 0)
	return result; // already exists!

	result = new EGLTextureObject();

	status_t err = mTextures.add(name, result);
	if (err < 0)
	result.clear();

	return result;
	}

	sp<EGLTextureObject> EGLSurfaceManager::removeTexture(GLuint name)
	{
	Mutex::Autolock _l(mLock);
	const ssize_t index = mTextures.indexOfKey(name);
	if (index >= 0) {
	sp<EGLTextureObject> result(mTextures.valueAt(index));
	mTextures.removeItemsAt(index);
	return result;
	}
	return 0;
	}

	sp<EGLTextureObject> EGLSurfaceManager::replaceTexture(GLuint name)
	{
	sp<EGLTextureObject> tex;
	Mutex::Autolock _l(mLock);
	const ssize_t index = mTextures.indexOfKey(name);
	if (index >= 0) {
	const sp<EGLTextureObject>& old = mTextures.valueAt(index);
	const uint32_t refs = old->getStrongCount();
	if (ggl_likely(refs == 1)) {
	// we're the only owner
	tex = old;
	} else {
	// keep the texture's parameters
	tex = new EGLTextureObject();
	tex->copyParameters(old);
	mTextures.removeItemsAt(index);
	mTextures.add(name, tex);
	}
	}
	return tex;
	}

	void EGLSurfaceManager::deleteTextures(GLsizei n, const GLuint *tokens)
	{
	// free all textures
	Mutex::Autolock _l(mLock);
	for (GLsizei i=0 ; i<n ; i++) {
	const GLuint t(*tokens++);
	if (t) {
	mTextures.removeItem(t);
	}
	}
	}

	sp<EGLTextureObject> EGLSurfaceManager::texture(GLuint name)
	{
	Mutex::Autolock _l(mLock);
	const ssize_t index = mTextures.indexOfKey(name);
	if (index >= 0)
	return mTextures.valueAt(index);
	return 0;
	}

	// ----------------------------------------------------------------------------
	}; // namespace android