rsdAllocation.cpp revision 733396b67724162844ea2785c7495115dc5ee8d8
1eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams/* 2bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams * Copyright (C) 2013 The Android Open Source Project 3eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * 4eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * Licensed under the Apache License, Version 2.0 (the "License"); 5eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * you may not use this file except in compliance with the License. 6eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * You may obtain a copy of the License at 7eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * 8eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * http://www.apache.org/licenses/LICENSE-2.0 9eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * 10eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * Unless required by applicable law or agreed to in writing, software 11eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * distributed under the License is distributed on an "AS IS" BASIS, 12eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * See the License for the specific language governing permissions and 14eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * limitations under the License. 15eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams */ 16eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 17eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 18eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include "rsdCore.h" 19eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include "rsdAllocation.h" 20eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 21eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include "rsAllocation.h" 22eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 237ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams#include "system/window.h" 247ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams#include "ui/Rect.h" 257ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams#include "ui/GraphicBufferMapper.h" 2693eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams 2793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 2893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#include "rsdFrameBufferObj.h" 2958fd6a5f10480551786739280d56dfa620c80b39Andy McFadden#include "gui/GLConsumer.h" 30733396b67724162844ea2785c7495115dc5ee8d8Jason Sams#include "gui/CpuConsumer.h" 31733396b67724162844ea2785c7495115dc5ee8d8Jason Sams#include "gui/Surface.h" 3293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#include "hardware/gralloc.h" 337ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 34eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include <GLES/gl.h> 35eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include <GLES2/gl2.h> 36eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include <GLES/glext.h> 3793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 38eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 39eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsusing namespace android; 40eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsusing namespace android::renderscript; 41eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 42eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 4393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 44eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsconst static GLenum gFaceOrder[] = { 45eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_POSITIVE_X, 46eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 47eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 48eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 49eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 50eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 51eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams}; 52eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 53a614ae175bbf97201b5e18984d814a1d3e86faa8Jason SamsGLenum rsdTypeToGLType(RsDataType t) { 54a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams switch (t) { 55a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_5_6_5: return GL_UNSIGNED_SHORT_5_6_5; 56a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_5_5_5_1: return GL_UNSIGNED_SHORT_5_5_5_1; 57a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_4_4_4_4: return GL_UNSIGNED_SHORT_4_4_4_4; 58a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 59a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams //case RS_TYPE_FLOAT_16: return GL_HALF_FLOAT; 60a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_FLOAT_32: return GL_FLOAT; 61a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_8: return GL_UNSIGNED_BYTE; 62a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_16: return GL_UNSIGNED_SHORT; 63a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_SIGNED_8: return GL_BYTE; 64a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_SIGNED_16: return GL_SHORT; 65a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams default: break; 66a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams } 67a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams return 0; 68a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams} 69a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 70a614ae175bbf97201b5e18984d814a1d3e86faa8Jason SamsGLenum rsdKindToGLFormat(RsDataKind k) { 71a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams switch (k) { 72a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_L: return GL_LUMINANCE; 73a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_A: return GL_ALPHA; 74a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_LA: return GL_LUMINANCE_ALPHA; 75a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_RGB: return GL_RGB; 76a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_RGBA: return GL_RGBA; 77a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_DEPTH: return GL_DEPTH_COMPONENT16; 78a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams default: break; 79a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams } 80a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams return 0; 81a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams} 8293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 83a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 84807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsuint8_t *GetOffsetPtr(const android::renderscript::Allocation *alloc, 85807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t xoff, uint32_t yoff, uint32_t lod, 86807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams RsAllocationCubemapFace face) { 87709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint8_t *ptr = (uint8_t *)alloc->mHal.drvState.lod[lod].mallocPtr; 88709a0978ae141198018ca9769f8d96292a8928e6Jason Sams ptr += face * alloc->mHal.drvState.faceOffset; 89709a0978ae141198018ca9769f8d96292a8928e6Jason Sams ptr += yoff * alloc->mHal.drvState.lod[lod].stride; 90807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams ptr += xoff * alloc->mHal.state.elementSizeBytes; 91807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams return ptr; 92807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 93807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 94a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 952382aba4a55c6ae74789c478eead8fbd96593321Jason Samsstatic void Update2DTexture(const Context *rsc, const Allocation *alloc, const void *ptr, 962382aba4a55c6ae74789c478eead8fbd96593321Jason Sams uint32_t xoff, uint32_t yoff, uint32_t lod, 972382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RsAllocationCubemapFace face, uint32_t w, uint32_t h) { 9893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 99eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 100eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 101eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsAssert(drv->textureID); 1022382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindTexture, drv->glTarget, drv->textureID); 1032382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glPixelStorei, GL_UNPACK_ALIGNMENT, 1); 104eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GLenum t = GL_TEXTURE_2D; 105eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasFaces) { 106eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams t = gFaceOrder[face]; 107eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 1082382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glTexSubImage2D, t, lod, xoff, yoff, w, h, drv->glFormat, drv->glType, ptr); 10993eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 110eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 111eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 112eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 11393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 114eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsstatic void Upload2DTexture(const Context *rsc, const Allocation *alloc, bool isFirstUpload) { 115eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 116eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1172382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindTexture, drv->glTarget, drv->textureID); 1182382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glPixelStorei, GL_UNPACK_ALIGNMENT, 1); 119eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 120eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t faceCount = 1; 121eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasFaces) { 122eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams faceCount = 6; 123eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 124eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 125eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "Upload2DTexture 1 "); 126eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams for (uint32_t face = 0; face < faceCount; face ++) { 127eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams for (uint32_t lod = 0; lod < alloc->mHal.state.type->getLODCount(); lod++) { 128807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint8_t *p = GetOffsetPtr(alloc, 0, 0, lod, (RsAllocationCubemapFace)face); 129eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 130eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GLenum t = GL_TEXTURE_2D; 131eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasFaces) { 132eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams t = gFaceOrder[face]; 133eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 134eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 135eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (isFirstUpload) { 1362382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glTexImage2D, t, lod, drv->glFormat, 137eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.state.type->getLODDimX(lod), 138eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.state.type->getLODDimY(lod), 139a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 0, drv->glFormat, drv->glType, p); 140eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 1412382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glTexSubImage2D, t, lod, 0, 0, 142eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.state.type->getLODDimX(lod), 143eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.state.type->getLODDimY(lod), 144a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams drv->glFormat, drv->glType, p); 145eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 146eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 147eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 148eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 149eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.mipmapControl == RS_ALLOCATION_MIPMAP_ON_SYNC_TO_TEXTURE) { 1502382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glGenerateMipmap, drv->glTarget); 151eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 152eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "Upload2DTexture"); 153eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 15493eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 155eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 156eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsstatic void UploadToTexture(const Context *rsc, const Allocation *alloc) { 15793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 158eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 159eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1603522f40418fdf877f5a136475dbf75e57a3b7c77Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_INPUT) { 16141e373d91a60043afa0f9abd026218b49cbc1201Jason Sams if (!drv->textureID) { 16241e373d91a60043afa0f9abd026218b49cbc1201Jason Sams RSD_CALL_GL(glGenTextures, 1, &drv->textureID); 16341e373d91a60043afa0f9abd026218b49cbc1201Jason Sams } 16441e373d91a60043afa0f9abd026218b49cbc1201Jason Sams return; 16541e373d91a60043afa0f9abd026218b49cbc1201Jason Sams } 16641e373d91a60043afa0f9abd026218b49cbc1201Jason Sams 167a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams if (!drv->glType || !drv->glFormat) { 168eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 169eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 170eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 171709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (!alloc->mHal.drvState.lod[0].mallocPtr) { 172eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 173eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 174eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 175eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams bool isFirstUpload = false; 176eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 177eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->textureID) { 1782382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glGenTextures, 1, &drv->textureID); 179eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams isFirstUpload = true; 180eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 181eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 182eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams Upload2DTexture(rsc, alloc, isFirstUpload); 183eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 184eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT)) { 185709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 186709a0978ae141198018ca9769f8d96292a8928e6Jason Sams free(alloc->mHal.drvState.lod[0].mallocPtr); 187709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = NULL; 188eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 189eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 190eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "UploadToTexture"); 19193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 192eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 193eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 194eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsstatic void AllocateRenderTarget(const Context *rsc, const Allocation *alloc) { 19593eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 196eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 197eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 198a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams if (!drv->glFormat) { 199eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 200eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 201eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 202eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->renderTargetID) { 2032382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glGenRenderbuffers, 1, &drv->renderTargetID); 204eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 205eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->renderTargetID) { 206eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams // This should generally not happen 207af12ac6a08651464f8d823add667c706f993b587Steve Block ALOGE("allocateRenderTarget failed to gen mRenderTargetID"); 208eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsc->dumpDebug(); 209eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 210eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 2112382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindRenderbuffer, GL_RENDERBUFFER, drv->renderTargetID); 2122382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glRenderbufferStorage, GL_RENDERBUFFER, drv->glFormat, 213a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams alloc->mHal.drvState.lod[0].dimX, alloc->mHal.drvState.lod[0].dimY); 214eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 215eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "AllocateRenderTarget"); 21693eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 217eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 218eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 219eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsstatic void UploadToBufferObject(const Context *rsc, const Allocation *alloc) { 22093eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 221eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 222eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 223eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsAssert(!alloc->mHal.state.type->getDimY()); 224eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsAssert(!alloc->mHal.state.type->getDimZ()); 225eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 226eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams //alloc->mHal.state.usageFlags |= RS_ALLOCATION_USAGE_GRAPHICS_VERTEX; 227eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 228eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->bufferID) { 2292382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glGenBuffers, 1, &drv->bufferID); 230eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 231eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->bufferID) { 232af12ac6a08651464f8d823add667c706f993b587Steve Block ALOGE("Upload to buffer object failed"); 233eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 234eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 235eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 2362382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindBuffer, drv->glTarget, drv->bufferID); 2372382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBufferData, drv->glTarget, alloc->mHal.state.type->getSizeBytes(), 238709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr, GL_DYNAMIC_DRAW); 2392382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindBuffer, drv->glTarget, 0); 240eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "UploadToBufferObject"); 24193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 242eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 243eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 244733396b67724162844ea2785c7495115dc5ee8d8Jason Samsstatic void DeriveYUVLayout(int yuv, Allocation::Hal::DrvState *state) { 245733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // YUV only supports basic 2d 246733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // so we can stash the plane pointers in the mipmap levels. 247733396b67724162844ea2785c7495115dc5ee8d8Jason Sams switch(yuv) { 248733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case HAL_PIXEL_FORMAT_YV12: 249733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimX = state->lod[0].dimX / 2; 250733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimY = state->lod[0].dimY / 2; 251733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].stride = rsRound(state->lod[0].stride >> 1, 16); 252733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].mallocPtr = ((uint8_t *)state->lod[0].mallocPtr) + 253733396b67724162844ea2785c7495115dc5ee8d8Jason Sams (state->lod[0].stride * state->lod[0].dimY); 254733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 255733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].dimX = state->lod[1].dimX; 256733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].dimY = state->lod[1].dimY; 257733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].stride = state->lod[1].stride; 258733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].mallocPtr = ((uint8_t *)state->lod[1].mallocPtr) + 259733396b67724162844ea2785c7495115dc5ee8d8Jason Sams (state->lod[1].stride * state->lod[1].dimY); 260733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 261733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lodCount = 3; 262733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 263733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 264733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimX = state->lod[0].dimX; 265733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimY = state->lod[0].dimY / 2; 266733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].stride = state->lod[0].stride; 267733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].mallocPtr = ((uint8_t *)state->lod[0].mallocPtr) + 268733396b67724162844ea2785c7495115dc5ee8d8Jason Sams (state->lod[0].stride * state->lod[0].dimY); 269733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lodCount = 2; 270733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 271733396b67724162844ea2785c7495115dc5ee8d8Jason Sams default: 272733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(0); 273733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 274733396b67724162844ea2785c7495115dc5ee8d8Jason Sams} 275733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 276733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 277463bfced38d97605dd8403a5e9435d9ad3394e35Jason Samsstatic size_t AllocationBuildPointerTable(const Context *rsc, const Allocation *alloc, 278463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams const Type *type, uint8_t *ptr) { 279709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].dimX = type->getDimX(); 280709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].dimY = type->getDimY(); 281f2b611e26db1c83ad5e0e0cdebcfa639b03fba75Jason Sams alloc->mHal.drvState.lod[0].dimZ = type->getDimZ(); 282709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = 0; 28394999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines // Stride needs to be 16-byte aligned too! 28494999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines size_t stride = alloc->mHal.drvState.lod[0].dimX * type->getElementSizeBytes(); 28594999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines alloc->mHal.drvState.lod[0].stride = rsRound(stride, 16); 286709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lodCount = type->getLODCount(); 287709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.faceCount = type->getDimFaces(); 288807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 289807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams size_t offsets[Allocation::MAX_LOD]; 290807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams memset(offsets, 0, sizeof(offsets)); 291807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 292709a0978ae141198018ca9769f8d96292a8928e6Jason Sams size_t o = alloc->mHal.drvState.lod[0].stride * rsMax(alloc->mHal.drvState.lod[0].dimY, 1u) * 293709a0978ae141198018ca9769f8d96292a8928e6Jason Sams rsMax(alloc->mHal.drvState.lod[0].dimZ, 1u); 294709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if(alloc->mHal.drvState.lodCount > 1) { 295709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t tx = alloc->mHal.drvState.lod[0].dimX; 296709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t ty = alloc->mHal.drvState.lod[0].dimY; 297709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t tz = alloc->mHal.drvState.lod[0].dimZ; 298709a0978ae141198018ca9769f8d96292a8928e6Jason Sams for (uint32_t lod=1; lod < alloc->mHal.drvState.lodCount; lod++) { 299709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].dimX = tx; 300709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].dimY = ty; 301709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].dimZ = tz; 30294999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines alloc->mHal.drvState.lod[lod].stride = 30394999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines rsRound(tx * type->getElementSizeBytes(), 16); 304807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams offsets[lod] = o; 305709a0978ae141198018ca9769f8d96292a8928e6Jason Sams o += alloc->mHal.drvState.lod[lod].stride * rsMax(ty, 1u) * rsMax(tz, 1u); 306807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if (tx > 1) tx >>= 1; 307807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if (ty > 1) ty >>= 1; 308807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if (tz > 1) tz >>= 1; 309807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 310bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } else if (alloc->mHal.state.yuv) { 311733396b67724162844ea2785c7495115dc5ee8d8Jason Sams DeriveYUVLayout(alloc->mHal.state.yuv, &alloc->mHal.drvState); 312733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 313733396b67724162844ea2785c7495115dc5ee8d8Jason Sams for (uint32_t ct = 1; ct < alloc->mHal.drvState.lodCount; ct++) { 314733396b67724162844ea2785c7495115dc5ee8d8Jason Sams offsets[ct] = (size_t)alloc->mHal.drvState.lod[ct].mallocPtr; 315bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 316807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 317bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams 318709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.faceOffset = o; 319807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 320709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = ptr; 321709a0978ae141198018ca9769f8d96292a8928e6Jason Sams for (uint32_t lod=1; lod < alloc->mHal.drvState.lodCount; lod++) { 322709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].mallocPtr = ptr + offsets[lod]; 323463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 324463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 325709a0978ae141198018ca9769f8d96292a8928e6Jason Sams size_t allocSize = alloc->mHal.drvState.faceOffset; 326709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if(alloc->mHal.drvState.faceCount) { 327463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams allocSize *= 6; 328463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 329463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 330463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams return allocSize; 331463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams} 332463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 333c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murraystatic uint8_t* allocAlignedMemory(size_t allocSize, bool forceZero) { 334c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // We align all allocations to a 16-byte boundary. 335c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray uint8_t* ptr = (uint8_t *)memalign(16, allocSize); 336c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (!ptr) { 337c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray return NULL; 338c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 339c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (forceZero) { 340c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray memset(ptr, 0, allocSize); 341c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 342c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray return ptr; 343c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray} 344c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 345463bfced38d97605dd8403a5e9435d9ad3394e35Jason Samsbool rsdAllocationInit(const Context *rsc, Allocation *alloc, bool forceZero) { 346463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams DrvAllocation *drv = (DrvAllocation *)calloc(1, sizeof(DrvAllocation)); 347463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams if (!drv) { 348463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams return false; 349463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 350463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams alloc->mHal.drv = drv; 351463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 352463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Calculate the object size. 353463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t allocSize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), NULL); 354463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 355807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = NULL; 3567ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT) { 357733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 358733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } else if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_INPUT) { 359733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // Allocation is allocated when the surface is created 360733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // in getSurface 3612e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } else if (alloc->mHal.state.userProvidedPtr != NULL) { 3622e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray // user-provided allocation 3632e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray // limitations: no faces, no LOD, USAGE_SCRIPT only 3649e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray if (alloc->mHal.state.usageFlags != (RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_SHARED)) { 3659e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray ALOGE("Can't use user-allocated buffers if usage is not USAGE_SCRIPT and USAGE_SHARED"); 3662e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray return false; 3672e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } 3682e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray if (alloc->getType()->getDimLOD() || alloc->getType()->getDimFaces()) { 3692e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray ALOGE("User-allocated buffers must not have multiple faces or LODs"); 3702e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray return false; 3712e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } 372c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 373c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // rows must be 16-byte aligned 374c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // validate that here, otherwise fall back to not use the user-backed allocation 375c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (((alloc->getType()->getDimX() * alloc->getType()->getElement()->getSizeBytes()) % 16) != 0) { 376c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ALOGV("User-backed allocation failed stride requirement, falling back to separate allocation"); 377c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray drv->useUserProvidedPtr = false; 378c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 379c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ptr = allocAlignedMemory(allocSize, forceZero); 380c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (!ptr) { 381c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray alloc->mHal.drv = NULL; 382c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray free(drv); 383c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray return false; 384c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 385c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 386c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } else { 387c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray drv->useUserProvidedPtr = true; 388c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ptr = (uint8_t*)alloc->mHal.state.userProvidedPtr; 389c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 3907ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } else { 391c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ptr = allocAlignedMemory(allocSize, forceZero); 392179e9a457095fea4c9e6d366c269754b882d05ddJason Sams if (!ptr) { 393ed419f37009ff5375293c198268c381460efa0f2You Kim alloc->mHal.drv = NULL; 394179e9a457095fea4c9e6d366c269754b882d05ddJason Sams free(drv); 395179e9a457095fea4c9e6d366c269754b882d05ddJason Sams return false; 396179e9a457095fea4c9e6d366c269754b882d05ddJason Sams } 397eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 398463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Build the pointer tables 399463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t verifySize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), ptr); 400463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams if(allocSize != verifySize) { 401463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams rsAssert(!"Size mismatch"); 402807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 403eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 404eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_NONE; 405eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) { 406eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasFaces) { 407eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_TEXTURE_CUBE_MAP; 408eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 409eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_TEXTURE_2D; 410eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 411eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 412eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) { 413eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_ARRAY_BUFFER; 414eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 415eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 416eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 41793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 418a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams drv->glType = rsdTypeToGLType(alloc->mHal.state.type->getElement()->getComponent().getType()); 419a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams drv->glFormat = rsdKindToGLFormat(alloc->mHal.state.type->getElement()->getComponent().getKind()); 42093eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#else 42193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams drv->glType = 0; 42293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams drv->glFormat = 0; 42393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 424a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 425eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & ~RS_ALLOCATION_USAGE_SCRIPT) { 426eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 427eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 428a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 429b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 430a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO = NULL; 431a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 432c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // fill out the initial state of the buffer if we couldn't use the user-provided ptr and USAGE_SHARED was accepted 433c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if ((alloc->mHal.state.userProvidedPtr != 0) && (drv->useUserProvidedPtr == false)) { 434c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray rsdAllocationData2D(rsc, alloc, 0, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X, alloc->getType()->getDimX(), alloc->getType()->getDimY(), alloc->mHal.state.userProvidedPtr, allocSize, 0); 435c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 436c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 437eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return true; 438eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 439eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 440eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationDestroy(const Context *rsc, Allocation *alloc) { 441eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 442eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 44393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 444eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (drv->bufferID) { 445eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams // Causes a SW crash.... 4466598201f1c4f409defac9a5af789fb53a7cc00f8Steve Block //ALOGV(" mBufferID %i", mBufferID); 447eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams //glDeleteBuffers(1, &mBufferID); 448eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams //mBufferID = 0; 449eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 450eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (drv->textureID) { 4512382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glDeleteTextures, 1, &drv->textureID); 452eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->textureID = 0; 453eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 454eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (drv->renderTargetID) { 4552382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glDeleteRenderbuffers, 1, &drv->renderTargetID); 456eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->renderTargetID = 0; 457eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 45893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 459eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 460709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 4612e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray // don't free user-allocated ptrs 462c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (!(drv->useUserProvidedPtr)) { 4632e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray free(alloc->mHal.drvState.lod[0].mallocPtr); 4642e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } 465709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = NULL; 466eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 46793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams 46893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 469a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (drv->readBackFBO != NULL) { 470a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk delete drv->readBackFBO; 471a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO = NULL; 472a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 47310c9dd709f8b52213c6792961afa9c5de807db5cJason Sams 47410c9dd709f8b52213c6792961afa9c5de807db5cJason Sams if ((alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT) && 47510c9dd709f8b52213c6792961afa9c5de807db5cJason Sams (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT)) { 47610c9dd709f8b52213c6792961afa9c5de807db5cJason Sams 47710c9dd709f8b52213c6792961afa9c5de807db5cJason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 47810c9dd709f8b52213c6792961afa9c5de807db5cJason Sams ANativeWindow *nw = alloc->mHal.state.wndSurface; 47910c9dd709f8b52213c6792961afa9c5de807db5cJason Sams 48010c9dd709f8b52213c6792961afa9c5de807db5cJason Sams GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 48110c9dd709f8b52213c6792961afa9c5de807db5cJason Sams mapper.unlock(drv->wndBuffer->handle); 48210c9dd709f8b52213c6792961afa9c5de807db5cJason Sams int32_t r = nw->queueBuffer(nw, drv->wndBuffer, -1); 48310c9dd709f8b52213c6792961afa9c5de807db5cJason Sams } 48493eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 48593eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams 486eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams free(drv); 487eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.drv = NULL; 488eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 489eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 490eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationResize(const Context *rsc, const Allocation *alloc, 491eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const Type *newType, bool zeroNew) { 492a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams const uint32_t oldDimX = alloc->mHal.drvState.lod[0].dimX; 493a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams const uint32_t dimX = newType->getDimX(); 494a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams 4959e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray // can't resize Allocations with user-allocated buffers 4969e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SHARED) { 4979e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray ALOGE("Resize cannot be called on a USAGE_SHARED allocation"); 4989e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray return; 4999e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray } 500709a0978ae141198018ca9769f8d96292a8928e6Jason Sams void * oldPtr = alloc->mHal.drvState.lod[0].mallocPtr; 501463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Calculate the object size 502463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t s = AllocationBuildPointerTable(rsc, alloc, newType, NULL); 503463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams uint8_t *ptr = (uint8_t *)realloc(oldPtr, s); 504463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Build the relative pointer tables. 505463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t verifySize = AllocationBuildPointerTable(rsc, alloc, newType, ptr); 506463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams if(s != verifySize) { 507463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams rsAssert(!"Size mismatch"); 508463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 509eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 510eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 511eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (dimX > oldDimX) { 512463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams uint32_t stride = alloc->mHal.state.elementSizeBytes; 513709a0978ae141198018ca9769f8d96292a8928e6Jason Sams memset(((uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr) + stride * oldDimX, 5142275e9cf534ff601fe42a72ff50580b230c04fe2Jason Sams 0, stride * (dimX - oldDimX)); 515eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 516eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 517eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 518a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchoukstatic void rsdAllocationSyncFromFBO(const Context *rsc, const Allocation *alloc) { 51993eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 520a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (!alloc->getIsScript()) { 521a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk return; // nothing to sync 522a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 523a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 524a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsdHal *dc = (RsdHal *)rsc->mHal.drv; 525a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsdFrameBufferObj *lastFbo = dc->gl.currentFrameBuffer; 526a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 527a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 528a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (!drv->textureID && !drv->renderTargetID) { 529a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk return; // nothing was rendered here yet, so nothing to sync 530a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 531a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (drv->readBackFBO == NULL) { 532a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO = new RsdFrameBufferObj(); 533a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO->setColorTarget(drv, 0); 534a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO->setDimensions(alloc->getType()->getDimX(), 535a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk alloc->getType()->getDimY()); 536a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 537a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 538a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk // Bind the framebuffer object so we can read back from it 539a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO->setActive(rsc); 540a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 541a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk // Do the readback 542709a0978ae141198018ca9769f8d96292a8928e6Jason Sams RSD_CALL_GL(glReadPixels, 0, 0, alloc->mHal.drvState.lod[0].dimX, 543709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].dimY, 544709a0978ae141198018ca9769f8d96292a8928e6Jason Sams drv->glFormat, drv->glType, alloc->mHal.drvState.lod[0].mallocPtr); 545a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 546a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk // Revert framebuffer to its original 547a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk lastFbo->setActive(rsc); 54893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 549a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk} 550eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 551eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 552eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationSyncAll(const Context *rsc, const Allocation *alloc, 553eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams RsAllocationUsageType src) { 554eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 555eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 556a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (src == RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 557a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if(!alloc->getIsRenderTarget()) { 558a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsc->setError(RS_ERROR_FATAL_DRIVER, 559a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "Attempting to sync allocation from render target, " 560a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "for non-render target allocation"); 561a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } else if (alloc->getType()->getElement()->getKind() != RS_KIND_PIXEL_RGBA) { 562a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsc->setError(RS_ERROR_FATAL_DRIVER, "Cannot only sync from RGBA" 563a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "render target"); 564a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } else { 565a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsdAllocationSyncFromFBO(rsc, alloc); 566a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 567eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 568eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 569eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 570eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsAssert(src == RS_ALLOCATION_USAGE_SCRIPT); 571eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 572eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) { 573eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams UploadToTexture(rsc, alloc); 574eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 575b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if ((alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) && 5760dc66936c02f285a242b6a68166d6f03618a0f07Jason Sams !(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT)) { 577eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams AllocateRenderTarget(rsc, alloc); 578eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 579eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 580eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) { 581eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams UploadToBufferObject(rsc, alloc); 582eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 583eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 584eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = false; 585eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 586eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 587eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationMarkDirty(const Context *rsc, const Allocation *alloc) { 588eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 589eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 590eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 591eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 592733396b67724162844ea2785c7495115dc5ee8d8Jason Samsvoid* rsdAllocationGetSurface(const Context *rsc, const Allocation *alloc) { 59393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 59441e373d91a60043afa0f9abd026218b49cbc1201Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 595733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 596733396b67724162844ea2785c7495115dc5ee8d8Jason Sams drv->cpuConsumer = new CpuConsumer(2); 597733396b67724162844ea2785c7495115dc5ee8d8Jason Sams sp<IGraphicBufferProducer> bp = drv->cpuConsumer->getProducerInterface(); 598733396b67724162844ea2785c7495115dc5ee8d8Jason Sams bp->incStrong(NULL); 599733396b67724162844ea2785c7495115dc5ee8d8Jason Sams return bp.get(); 60093eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#else 601733396b67724162844ea2785c7495115dc5ee8d8Jason Sams return NULL; 60293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 60341e373d91a60043afa0f9abd026218b49cbc1201Jason Sams} 60441e373d91a60043afa0f9abd026218b49cbc1201Jason Sams 60593eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 6067ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsstatic bool IoGetBuffer(const Context *rsc, Allocation *alloc, ANativeWindow *nw) { 6077ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 6087ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 609cd919a177f2b25af1b304dd4d79f0a768fed342fJamie Gennis int32_t r = native_window_dequeue_buffer_and_wait(nw, &drv->wndBuffer); 6107ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 6117ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error getting next IO output buffer."); 6127ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return false; 6137ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6147ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6157ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams // Must lock the whole surface 6167ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 6177ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams Rect bounds(drv->wndBuffer->width, drv->wndBuffer->height); 6187ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6197ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams void *dst = NULL; 6207ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams mapper.lock(drv->wndBuffer->handle, 6217ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN, 6227ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams bounds, &dst); 623709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = dst; 624709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].stride = drv->wndBuffer->stride * alloc->mHal.state.elementSizeBytes; 62594999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines rsAssert((alloc->mHal.drvState.lod[0].stride & 0xf) == 0); 626b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 6277ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return true; 6287ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 62993eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 6307ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 631733396b67724162844ea2785c7495115dc5ee8d8Jason Samsvoid rsdAllocationSetSurface(const Context *rsc, Allocation *alloc, ANativeWindow *nw) { 63293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 6337ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 6347ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 635b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 636b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams //TODO finish support for render target + script 637b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams drv->wnd = nw; 638b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams return; 639b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 640b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 641b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 6427ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams // Cleanup old surface if there is one. 6437ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (alloc->mHal.state.wndSurface) { 6447ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams ANativeWindow *old = alloc->mHal.state.wndSurface; 6457ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 6467ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams mapper.unlock(drv->wndBuffer->handle); 647cd919a177f2b25af1b304dd4d79f0a768fed342fJamie Gennis old->queueBuffer(old, drv->wndBuffer, -1); 6487ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6497ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6507ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (nw != NULL) { 6517ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams int32_t r; 652b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams uint32_t flags = 0; 653b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 654b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams flags |= GRALLOC_USAGE_SW_READ_RARELY | GRALLOC_USAGE_SW_WRITE_OFTEN; 655b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 656b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 657b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams flags |= GRALLOC_USAGE_HW_RENDER; 658b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 659b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 660b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams r = native_window_set_usage(nw, flags); 6617ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 6627ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer usage."); 6637ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return; 6647ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6657ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 666a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams r = native_window_set_buffers_dimensions(nw, alloc->mHal.drvState.lod[0].dimX, 667a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams alloc->mHal.drvState.lod[0].dimY); 6687ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 6697ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer dimensions."); 6707ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return; 6717ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6727ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 673733396b67724162844ea2785c7495115dc5ee8d8Jason Sams int format = 0; 674733396b67724162844ea2785c7495115dc5ee8d8Jason Sams const Element *e = alloc->mHal.state.type->getElement(); 675733396b67724162844ea2785c7495115dc5ee8d8Jason Sams switch(e->getType()) { 676733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case RS_TYPE_UNSIGNED_8: 677733396b67724162844ea2785c7495115dc5ee8d8Jason Sams switch (e->getVectorSize()) { 678733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case 1: 679733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(e->getKind() == RS_KIND_PIXEL_A); 680733396b67724162844ea2785c7495115dc5ee8d8Jason Sams format = PIXEL_FORMAT_A_8; 681733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 682733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case 4: 683733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(e->getKind() == RS_KIND_PIXEL_RGBA); 684733396b67724162844ea2785c7495115dc5ee8d8Jason Sams format = PIXEL_FORMAT_RGBA_8888; 685733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 686733396b67724162844ea2785c7495115dc5ee8d8Jason Sams default: 687733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(0); 688733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 689733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 690733396b67724162844ea2785c7495115dc5ee8d8Jason Sams default: 691733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(0); 692733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 693733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 694733396b67724162844ea2785c7495115dc5ee8d8Jason Sams r = native_window_set_buffers_format(nw, format); 695733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (r) { 696733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer format."); 697733396b67724162844ea2785c7495115dc5ee8d8Jason Sams return; 698733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 699733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 7007ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams r = native_window_set_buffer_count(nw, 3); 7017ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 7027ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer count."); 7037ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return; 7047ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 7057ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7067ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams IoGetBuffer(rsc, alloc, nw); 7077ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 70893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 7097ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 7107ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7117ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid rsdAllocationIoSend(const Context *rsc, Allocation *alloc) { 71293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 7137ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 7147ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams ANativeWindow *nw = alloc->mHal.state.wndSurface; 7157ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 716b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 717b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams RsdHal *dc = (RsdHal *)rsc->mHal.drv; 718b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams RSD_CALL_GL(eglSwapBuffers, dc->gl.egl.display, dc->gl.egl.surface); 7197ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return; 7207ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 7217ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 722b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 723b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 724b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams mapper.unlock(drv->wndBuffer->handle); 725cd919a177f2b25af1b304dd4d79f0a768fed342fJamie Gennis int32_t r = nw->queueBuffer(nw, drv->wndBuffer, -1); 726b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (r) { 727b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams rsc->setError(RS_ERROR_DRIVER, "Error sending IO output buffer."); 728b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams return; 729b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 730b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 731b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams IoGetBuffer(rsc, alloc, nw); 732b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 73393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 7347ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 7357ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7367ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid rsdAllocationIoReceive(const Context *rsc, Allocation *alloc) { 73793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 7383522f40418fdf877f5a136475dbf75e57a3b7c77Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 739733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 740733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 741733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (drv->lb.data != NULL) { 742733396b67724162844ea2785c7495115dc5ee8d8Jason Sams drv->cpuConsumer->unlockBuffer(drv->lb); 743733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 744733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 745733396b67724162844ea2785c7495115dc5ee8d8Jason Sams status_t ret = drv->cpuConsumer->lockNextBuffer(&drv->lb); 746733396b67724162844ea2785c7495115dc5ee8d8Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = drv->lb.data; 747733396b67724162844ea2785c7495115dc5ee8d8Jason Sams alloc->mHal.drvState.lod[0].stride = drv->lb.stride * alloc->mHal.state.elementSizeBytes; 748733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 749733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (alloc->mHal.state.yuv) { 750733396b67724162844ea2785c7495115dc5ee8d8Jason Sams DeriveYUVLayout(alloc->mHal.state.yuv, &alloc->mHal.drvState); 751733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 752733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 753733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } else { 754733396b67724162844ea2785c7495115dc5ee8d8Jason Sams alloc->mHal.state.surfaceTexture->updateTexImage(); 755733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 756733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 757733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 75893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 7597ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 7607ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7617ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 762eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationData1D(const Context *rsc, const Allocation *alloc, 763eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t xoff, uint32_t lod, uint32_t count, 764c794cd56e46408e08862c42a022090e323684197Alex Sakhartchouk const void *data, size_t sizeBytes) { 765eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 766eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 767eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes(); 768807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 769eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t size = count * eSize; 770eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 77120c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (ptr != data) { 77220c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 77320c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 77420c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (alloc->mHal.state.hasReferences) { 77520c535f54fb41348a96af98079ad377d7a310c8aStephen Hines alloc->incRefs(data, count); 77620c535f54fb41348a96af98079ad377d7a310c8aStephen Hines alloc->decRefs(ptr, count); 77720c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 77820c535f54fb41348a96af98079ad377d7a310c8aStephen Hines memcpy(ptr, data, size); 779eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 780eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 781eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 782eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 783eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationData2D(const Context *rsc, const Allocation *alloc, 784eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 785358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t w, uint32_t h, const void *data, size_t sizeBytes, size_t stride) { 786eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 787eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 788eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 789eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t lineSize = eSize * w; 790358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray if (!stride) { 791358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray stride = lineSize; 792358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray } 793eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 794709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 795eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const uint8_t *src = static_cast<const uint8_t *>(data); 796807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *dst = GetOffsetPtr(alloc, xoff, yoff, lod, face); 79720c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (dst == src) { 79820c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 79920c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 80020c535f54fb41348a96af98079ad377d7a310c8aStephen Hines drv->uploadDeferred = true; 80120c535f54fb41348a96af98079ad377d7a310c8aStephen Hines return; 80220c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 803eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 804eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams for (uint32_t line=yoff; line < (yoff+h); line++) { 805eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasReferences) { 806eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->incRefs(src, w); 807eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->decRefs(dst, w); 808eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 809eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memcpy(dst, src, lineSize); 810358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray src += stride; 811709a0978ae141198018ca9769f8d96292a8928e6Jason Sams dst += alloc->mHal.drvState.lod[lod].stride; 812eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 813bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams if (alloc->mHal.state.yuv) { 814bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams int lod = 1; 815bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams while (alloc->mHal.drvState.lod[lod].mallocPtr) { 816bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams uint32_t lineSize = alloc->mHal.drvState.lod[lod].dimX; 817bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams uint8_t *dst = GetOffsetPtr(alloc, xoff, yoff, lod, face); 818bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams 819bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams for (uint32_t line=(yoff >> 1); line < ((yoff+h)>>1); line++) { 820bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams memcpy(dst, src, lineSize); 821bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams src += lineSize; 822bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams dst += alloc->mHal.drvState.lod[lod].stride; 823bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 824bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams lod++; 825bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 826bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams 827bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 828eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 829eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 8302382aba4a55c6ae74789c478eead8fbd96593321Jason Sams Update2DTexture(rsc, alloc, data, xoff, yoff, lod, face, w, h); 831eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 832eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 833eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 834eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationData3D(const Context *rsc, const Allocation *alloc, 835eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t xoff, uint32_t yoff, uint32_t zoff, 836eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t lod, RsAllocationCubemapFace face, 837eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t w, uint32_t h, uint32_t d, const void *data, uint32_t sizeBytes) { 838eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 839eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 840eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 841807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationRead1D(const Context *rsc, const Allocation *alloc, 842807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t xoff, uint32_t lod, uint32_t count, 843807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams void *data, size_t sizeBytes) { 844807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes(); 845807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 84620c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (data != ptr) { 84720c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 84820c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 84920c535f54fb41348a96af98079ad377d7a310c8aStephen Hines memcpy(data, ptr, count * eSize); 85020c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 851807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 852807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 853807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationRead2D(const Context *rsc, const Allocation *alloc, 854358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 855358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t w, uint32_t h, void *data, size_t sizeBytes, size_t stride) { 856807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 857807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t lineSize = eSize * w; 858358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray if (!stride) { 859358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray stride = lineSize; 860358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray } 861807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 862709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 863807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *dst = static_cast<uint8_t *>(data); 864807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint8_t *src = GetOffsetPtr(alloc, xoff, yoff, lod, face); 86520c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (dst == src) { 86620c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 86720c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 86820c535f54fb41348a96af98079ad377d7a310c8aStephen Hines return; 86920c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 870807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 871807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams for (uint32_t line=yoff; line < (yoff+h); line++) { 872807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams memcpy(dst, src, lineSize); 873358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray dst += stride; 874709a0978ae141198018ca9769f8d96292a8928e6Jason Sams src += alloc->mHal.drvState.lod[lod].stride; 875807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 876807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } else { 877807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams ALOGE("Add code to readback from non-script memory"); 878807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 879807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 880807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 881358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray 882807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationRead3D(const Context *rsc, const Allocation *alloc, 883807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t xoff, uint32_t yoff, uint32_t zoff, 884807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t lod, RsAllocationCubemapFace face, 885807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t w, uint32_t h, uint32_t d, void *data, uint32_t sizeBytes) { 886807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 887807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 888807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 889807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid * rsdAllocationLock1D(const android::renderscript::Context *rsc, 890807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const android::renderscript::Allocation *alloc) { 891709a0978ae141198018ca9769f8d96292a8928e6Jason Sams return alloc->mHal.drvState.lod[0].mallocPtr; 892807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 893807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 894807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationUnlock1D(const android::renderscript::Context *rsc, 895807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const android::renderscript::Allocation *alloc) { 896807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 897807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 898807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 89974a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsdAllocationData1D_alloc(const android::renderscript::Context *rsc, 90074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 90174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstLod, uint32_t count, 90274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 903a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t srcXoff, uint32_t srcLod) { 904a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk} 905a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 906a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 907a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchoukvoid rsdAllocationData2D_alloc_script(const android::renderscript::Context *rsc, 908a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 909a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod, 910a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h, 911a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 912a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod, 913a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsAllocationCubemapFace srcFace) { 914a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t elementSize = dstAlloc->getType()->getElementSizeBytes(); 915a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk for (uint32_t i = 0; i < h; i ++) { 916807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *dstPtr = GetOffsetPtr(dstAlloc, dstXoff, dstYoff + i, dstLod, dstFace); 917807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *srcPtr = GetOffsetPtr(srcAlloc, srcXoff, srcYoff + i, srcLod, srcFace); 918a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk memcpy(dstPtr, srcPtr, w * elementSize); 919a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 920af12ac6a08651464f8d823add667c706f993b587Steve Block //ALOGE("COPIED dstXoff(%u), dstYoff(%u), dstLod(%u), dstFace(%u), w(%u), h(%u), srcXoff(%u), srcYoff(%u), srcLod(%u), srcFace(%u)", 9210a44ab45c739f00f457874418e7384492e4df979Stephen Hines // dstXoff, dstYoff, dstLod, dstFace, w, h, srcXoff, srcYoff, srcLod, srcFace); 922a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 92374a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 92474a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 92574a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsdAllocationData2D_alloc(const android::renderscript::Context *rsc, 92674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 92774a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod, 92874a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h, 92974a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 93074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod, 93174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk RsAllocationCubemapFace srcFace) { 932a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (!dstAlloc->getIsScript() && !srcAlloc->getIsScript()) { 933a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsc->setError(RS_ERROR_FATAL_DRIVER, "Non-script allocation copies not " 934a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "yet implemented."); 935a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk return; 936a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 937a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsdAllocationData2D_alloc_script(rsc, dstAlloc, dstXoff, dstYoff, 938a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk dstLod, dstFace, w, h, srcAlloc, 939a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk srcXoff, srcYoff, srcLod, srcFace); 94074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 94174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 94274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsdAllocationData3D_alloc(const android::renderscript::Context *rsc, 94374a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 94474a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff, 94574a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstLod, RsAllocationCubemapFace dstFace, 94674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t w, uint32_t h, uint32_t d, 94774a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 94874a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, 94974a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcLod, RsAllocationCubemapFace srcFace) { 95074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 95174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 952eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationElementData1D(const Context *rsc, const Allocation *alloc, 953eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t x, 954eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const void *data, uint32_t cIdx, uint32_t sizeBytes) { 955eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 956eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 957eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 958807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = GetOffsetPtr(alloc, x, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 959eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 960eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx); 961eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx); 962eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 963eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasReferences) { 964eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->incRefs(data); 965eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->decRefs(ptr); 966eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 967eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 968eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memcpy(ptr, data, sizeBytes); 969eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 970eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 971eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 972eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationElementData2D(const Context *rsc, const Allocation *alloc, 973eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t x, uint32_t y, 974eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const void *data, uint32_t cIdx, uint32_t sizeBytes) { 975eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 976eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 977eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 978807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = GetOffsetPtr(alloc, x, y, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 979eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 980eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx); 981eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx); 982eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 983eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasReferences) { 984eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->incRefs(data); 985eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->decRefs(ptr); 986eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 987eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 988eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memcpy(ptr, data, sizeBytes); 989eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 990eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 991eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 99261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsstatic void mip565(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 993709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t w = alloc->mHal.drvState.lod[lod + 1].dimX; 994709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t h = alloc->mHal.drvState.lod[lod + 1].dimY; 99561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 99661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t y=0; y < h; y++) { 99761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint16_t *oPtr = (uint16_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face); 99861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint16_t *i1 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2, lod, face); 99961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint16_t *i2 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face); 100061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 100161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t x=0; x < w; x++) { 100261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams *oPtr = rsBoxFilter565(i1[0], i1[1], i2[0], i2[1]); 100361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams oPtr ++; 100461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i1 += 2; 100561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i2 += 2; 100661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 100761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 100861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 100961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 101061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsstatic void mip8888(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 1011709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t w = alloc->mHal.drvState.lod[lod + 1].dimX; 1012709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t h = alloc->mHal.drvState.lod[lod + 1].dimY; 101361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 101461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t y=0; y < h; y++) { 101561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint32_t *oPtr = (uint32_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face); 101661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint32_t *i1 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2, lod, face); 101761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint32_t *i2 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face); 101861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 101961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t x=0; x < w; x++) { 102061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams *oPtr = rsBoxFilter8888(i1[0], i1[1], i2[0], i2[1]); 102161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams oPtr ++; 102261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i1 += 2; 102361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i2 += 2; 102461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 102561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 102661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 102761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 102861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsstatic void mip8(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 1029709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t w = alloc->mHal.drvState.lod[lod + 1].dimX; 1030709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t h = alloc->mHal.drvState.lod[lod + 1].dimY; 103161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 103261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t y=0; y < h; y++) { 103361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint8_t *oPtr = GetOffsetPtr(alloc, 0, y, lod + 1, face); 103461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint8_t *i1 = GetOffsetPtr(alloc, 0, y*2, lod, face); 103561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint8_t *i2 = GetOffsetPtr(alloc, 0, y*2+1, lod, face); 103661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 103761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t x=0; x < w; x++) { 103861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams *oPtr = (uint8_t)(((uint32_t)i1[0] + i1[1] + i2[0] + i2[1]) * 0.25f); 103961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams oPtr ++; 104061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i1 += 2; 104161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i2 += 2; 104261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 104361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 104461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 104561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 104661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsvoid rsdAllocationGenerateMipmaps(const Context *rsc, const Allocation *alloc) { 1047709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if(!alloc->mHal.drvState.lod[0].mallocPtr) { 104861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams return; 104961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 105061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint32_t numFaces = alloc->getType()->getDimFaces() ? 6 : 1; 105161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t face = 0; face < numFaces; face ++) { 105261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t lod=0; lod < (alloc->getType()->getLODCount() -1); lod++) { 105361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams switch (alloc->getType()->getElement()->getSizeBits()) { 105461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams case 32: 105561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mip8888(alloc, lod, (RsAllocationCubemapFace)face); 105661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams break; 105761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams case 16: 105861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mip565(alloc, lod, (RsAllocationCubemapFace)face); 105961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams break; 106061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams case 8: 106161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mip8(alloc, lod, (RsAllocationCubemapFace)face); 106261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams break; 106361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 106461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 106561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 106661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 106761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 1068eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1069