rsdAllocation.cpp revision 9d8e5af146326250ebc1e9b3c93402bd0e7669bb
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 2449d8e5af146326250ebc1e9b3c93402bd0e7669bbJason Samsstatic size_t 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. 2479d8e5af146326250ebc1e9b3c93402bd0e7669bbJason Sams size_t uvSize = 0; 248733396b67724162844ea2785c7495115dc5ee8d8Jason Sams switch(yuv) { 249733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case HAL_PIXEL_FORMAT_YV12: 250733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimX = state->lod[0].dimX / 2; 251733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimY = state->lod[0].dimY / 2; 252733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].stride = rsRound(state->lod[0].stride >> 1, 16); 253733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].mallocPtr = ((uint8_t *)state->lod[0].mallocPtr) + 254733396b67724162844ea2785c7495115dc5ee8d8Jason Sams (state->lod[0].stride * state->lod[0].dimY); 2559d8e5af146326250ebc1e9b3c93402bd0e7669bbJason Sams uvSize += state->lod[1].stride * state->lod[1].dimY; 256733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 257733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].dimX = state->lod[1].dimX; 258733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].dimY = state->lod[1].dimY; 259733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].stride = state->lod[1].stride; 260733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].mallocPtr = ((uint8_t *)state->lod[1].mallocPtr) + 261733396b67724162844ea2785c7495115dc5ee8d8Jason Sams (state->lod[1].stride * state->lod[1].dimY); 2629d8e5af146326250ebc1e9b3c93402bd0e7669bbJason Sams uvSize += state->lod[2].stride * state->lod[2].dimY; 263733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 264733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lodCount = 3; 265733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 266733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 267733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimX = state->lod[0].dimX; 268733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimY = state->lod[0].dimY / 2; 269733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].stride = state->lod[0].stride; 270733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].mallocPtr = ((uint8_t *)state->lod[0].mallocPtr) + 271733396b67724162844ea2785c7495115dc5ee8d8Jason Sams (state->lod[0].stride * state->lod[0].dimY); 2729d8e5af146326250ebc1e9b3c93402bd0e7669bbJason Sams uvSize += state->lod[1].stride * state->lod[1].dimY; 273733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lodCount = 2; 274733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 275733396b67724162844ea2785c7495115dc5ee8d8Jason Sams default: 276733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(0); 277733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 2789d8e5af146326250ebc1e9b3c93402bd0e7669bbJason Sams return uvSize; 279733396b67724162844ea2785c7495115dc5ee8d8Jason Sams} 280733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 281733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 282463bfced38d97605dd8403a5e9435d9ad3394e35Jason Samsstatic size_t AllocationBuildPointerTable(const Context *rsc, const Allocation *alloc, 283463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams const Type *type, uint8_t *ptr) { 284709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].dimX = type->getDimX(); 285709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].dimY = type->getDimY(); 286f2b611e26db1c83ad5e0e0cdebcfa639b03fba75Jason Sams alloc->mHal.drvState.lod[0].dimZ = type->getDimZ(); 287709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = 0; 28894999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines // Stride needs to be 16-byte aligned too! 28994999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines size_t stride = alloc->mHal.drvState.lod[0].dimX * type->getElementSizeBytes(); 29094999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines alloc->mHal.drvState.lod[0].stride = rsRound(stride, 16); 291709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lodCount = type->getLODCount(); 292709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.faceCount = type->getDimFaces(); 293807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 294807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams size_t offsets[Allocation::MAX_LOD]; 295807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams memset(offsets, 0, sizeof(offsets)); 296807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 297709a0978ae141198018ca9769f8d96292a8928e6Jason Sams size_t o = alloc->mHal.drvState.lod[0].stride * rsMax(alloc->mHal.drvState.lod[0].dimY, 1u) * 298709a0978ae141198018ca9769f8d96292a8928e6Jason Sams rsMax(alloc->mHal.drvState.lod[0].dimZ, 1u); 299709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if(alloc->mHal.drvState.lodCount > 1) { 300709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t tx = alloc->mHal.drvState.lod[0].dimX; 301709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t ty = alloc->mHal.drvState.lod[0].dimY; 302709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t tz = alloc->mHal.drvState.lod[0].dimZ; 303709a0978ae141198018ca9769f8d96292a8928e6Jason Sams for (uint32_t lod=1; lod < alloc->mHal.drvState.lodCount; lod++) { 304709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].dimX = tx; 305709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].dimY = ty; 306709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].dimZ = tz; 30794999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines alloc->mHal.drvState.lod[lod].stride = 30894999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines rsRound(tx * type->getElementSizeBytes(), 16); 309807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams offsets[lod] = o; 310709a0978ae141198018ca9769f8d96292a8928e6Jason Sams o += alloc->mHal.drvState.lod[lod].stride * rsMax(ty, 1u) * rsMax(tz, 1u); 311807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if (tx > 1) tx >>= 1; 312807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if (ty > 1) ty >>= 1; 313807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if (tz > 1) tz >>= 1; 314807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 315bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } else if (alloc->mHal.state.yuv) { 3169d8e5af146326250ebc1e9b3c93402bd0e7669bbJason Sams o += DeriveYUVLayout(alloc->mHal.state.yuv, &alloc->mHal.drvState); 317733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 318733396b67724162844ea2785c7495115dc5ee8d8Jason Sams for (uint32_t ct = 1; ct < alloc->mHal.drvState.lodCount; ct++) { 319733396b67724162844ea2785c7495115dc5ee8d8Jason Sams offsets[ct] = (size_t)alloc->mHal.drvState.lod[ct].mallocPtr; 320bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 321807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 322bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams 323709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.faceOffset = o; 324807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 325709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = ptr; 326709a0978ae141198018ca9769f8d96292a8928e6Jason Sams for (uint32_t lod=1; lod < alloc->mHal.drvState.lodCount; lod++) { 327709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].mallocPtr = ptr + offsets[lod]; 328463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 329463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 330709a0978ae141198018ca9769f8d96292a8928e6Jason Sams size_t allocSize = alloc->mHal.drvState.faceOffset; 331709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if(alloc->mHal.drvState.faceCount) { 332463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams allocSize *= 6; 333463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 334463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 335463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams return allocSize; 336463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams} 337463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 338c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murraystatic uint8_t* allocAlignedMemory(size_t allocSize, bool forceZero) { 339c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // We align all allocations to a 16-byte boundary. 340c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray uint8_t* ptr = (uint8_t *)memalign(16, allocSize); 341c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (!ptr) { 342c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray return NULL; 343c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 344c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (forceZero) { 345c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray memset(ptr, 0, allocSize); 346c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 347c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray return ptr; 348c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray} 349c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 350463bfced38d97605dd8403a5e9435d9ad3394e35Jason Samsbool rsdAllocationInit(const Context *rsc, Allocation *alloc, bool forceZero) { 351463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams DrvAllocation *drv = (DrvAllocation *)calloc(1, sizeof(DrvAllocation)); 352463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams if (!drv) { 353463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams return false; 354463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 355463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams alloc->mHal.drv = drv; 356463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 357463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Calculate the object size. 358463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t allocSize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), NULL); 359463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 360807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = NULL; 3617ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT) { 362733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 363733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } else if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_INPUT) { 364733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // Allocation is allocated when the surface is created 365733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // in getSurface 3662e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } else if (alloc->mHal.state.userProvidedPtr != NULL) { 3672e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray // user-provided allocation 3682e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray // limitations: no faces, no LOD, USAGE_SCRIPT only 3699e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray if (alloc->mHal.state.usageFlags != (RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_SHARED)) { 3709e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray ALOGE("Can't use user-allocated buffers if usage is not USAGE_SCRIPT and USAGE_SHARED"); 3712e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray return false; 3722e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } 3732e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray if (alloc->getType()->getDimLOD() || alloc->getType()->getDimFaces()) { 3742e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray ALOGE("User-allocated buffers must not have multiple faces or LODs"); 3752e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray return false; 3762e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } 377c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 378c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // rows must be 16-byte aligned 379c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // validate that here, otherwise fall back to not use the user-backed allocation 380c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (((alloc->getType()->getDimX() * alloc->getType()->getElement()->getSizeBytes()) % 16) != 0) { 381c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ALOGV("User-backed allocation failed stride requirement, falling back to separate allocation"); 382c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray drv->useUserProvidedPtr = false; 383c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 384c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ptr = allocAlignedMemory(allocSize, forceZero); 385c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (!ptr) { 386c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray alloc->mHal.drv = NULL; 387c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray free(drv); 388c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray return false; 389c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 390c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 391c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } else { 392c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray drv->useUserProvidedPtr = true; 393c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ptr = (uint8_t*)alloc->mHal.state.userProvidedPtr; 394c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 3957ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } else { 396c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ptr = allocAlignedMemory(allocSize, forceZero); 397179e9a457095fea4c9e6d366c269754b882d05ddJason Sams if (!ptr) { 398ed419f37009ff5375293c198268c381460efa0f2You Kim alloc->mHal.drv = NULL; 399179e9a457095fea4c9e6d366c269754b882d05ddJason Sams free(drv); 400179e9a457095fea4c9e6d366c269754b882d05ddJason Sams return false; 401179e9a457095fea4c9e6d366c269754b882d05ddJason Sams } 402eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 403463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Build the pointer tables 404463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t verifySize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), ptr); 405463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams if(allocSize != verifySize) { 406463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams rsAssert(!"Size mismatch"); 407807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 408eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 409eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_NONE; 410eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) { 411eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasFaces) { 412eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_TEXTURE_CUBE_MAP; 413eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 414eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_TEXTURE_2D; 415eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 416eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 417eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) { 418eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_ARRAY_BUFFER; 419eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 420eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 421eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 42293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 423a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams drv->glType = rsdTypeToGLType(alloc->mHal.state.type->getElement()->getComponent().getType()); 424a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams drv->glFormat = rsdKindToGLFormat(alloc->mHal.state.type->getElement()->getComponent().getKind()); 42593eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#else 42693eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams drv->glType = 0; 42793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams drv->glFormat = 0; 42893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 429a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 430eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & ~RS_ALLOCATION_USAGE_SCRIPT) { 431eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 432eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 433a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 434b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 435a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO = NULL; 436a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 437c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // fill out the initial state of the buffer if we couldn't use the user-provided ptr and USAGE_SHARED was accepted 438c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if ((alloc->mHal.state.userProvidedPtr != 0) && (drv->useUserProvidedPtr == false)) { 439c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim 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); 440c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 441c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 442eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return true; 443eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 444eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 445eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationDestroy(const Context *rsc, Allocation *alloc) { 446eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 447eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 44893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 449eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (drv->bufferID) { 450eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams // Causes a SW crash.... 4516598201f1c4f409defac9a5af789fb53a7cc00f8Steve Block //ALOGV(" mBufferID %i", mBufferID); 452eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams //glDeleteBuffers(1, &mBufferID); 453eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams //mBufferID = 0; 454eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 455eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (drv->textureID) { 4562382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glDeleteTextures, 1, &drv->textureID); 457eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->textureID = 0; 458eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 459eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (drv->renderTargetID) { 4602382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glDeleteRenderbuffers, 1, &drv->renderTargetID); 461eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->renderTargetID = 0; 462eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 46393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 464eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 465709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 4662e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray // don't free user-allocated ptrs 467c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (!(drv->useUserProvidedPtr)) { 4682e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray free(alloc->mHal.drvState.lod[0].mallocPtr); 4692e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } 470709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = NULL; 471eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 47293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams 47393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 474a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (drv->readBackFBO != NULL) { 475a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk delete drv->readBackFBO; 476a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO = NULL; 477a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 47810c9dd709f8b52213c6792961afa9c5de807db5cJason Sams 47910c9dd709f8b52213c6792961afa9c5de807db5cJason Sams if ((alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT) && 48010c9dd709f8b52213c6792961afa9c5de807db5cJason Sams (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT)) { 48110c9dd709f8b52213c6792961afa9c5de807db5cJason Sams 48210c9dd709f8b52213c6792961afa9c5de807db5cJason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 4833a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray ANativeWindow *nw = drv->wndSurface; 4843a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (nw) { 4853a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 4863a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray mapper.unlock(drv->wndBuffer->handle); 4873a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray int32_t r = nw->queueBuffer(nw, drv->wndBuffer, -1); 4883a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 48910c9dd709f8b52213c6792961afa9c5de807db5cJason Sams } 49093eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 49193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams 492eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams free(drv); 493eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.drv = NULL; 494eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 495eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 496eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationResize(const Context *rsc, const Allocation *alloc, 497eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const Type *newType, bool zeroNew) { 498a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams const uint32_t oldDimX = alloc->mHal.drvState.lod[0].dimX; 499a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams const uint32_t dimX = newType->getDimX(); 500a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams 5019e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray // can't resize Allocations with user-allocated buffers 5029e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SHARED) { 5039e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray ALOGE("Resize cannot be called on a USAGE_SHARED allocation"); 5049e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray return; 5059e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray } 506709a0978ae141198018ca9769f8d96292a8928e6Jason Sams void * oldPtr = alloc->mHal.drvState.lod[0].mallocPtr; 507463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Calculate the object size 508463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t s = AllocationBuildPointerTable(rsc, alloc, newType, NULL); 509463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams uint8_t *ptr = (uint8_t *)realloc(oldPtr, s); 510463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Build the relative pointer tables. 511463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t verifySize = AllocationBuildPointerTable(rsc, alloc, newType, ptr); 512463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams if(s != verifySize) { 513463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams rsAssert(!"Size mismatch"); 514463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 515eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 516eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 517eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (dimX > oldDimX) { 518463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams uint32_t stride = alloc->mHal.state.elementSizeBytes; 519709a0978ae141198018ca9769f8d96292a8928e6Jason Sams memset(((uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr) + stride * oldDimX, 5202275e9cf534ff601fe42a72ff50580b230c04fe2Jason Sams 0, stride * (dimX - oldDimX)); 521eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 522eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 523eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 524a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchoukstatic void rsdAllocationSyncFromFBO(const Context *rsc, const Allocation *alloc) { 52593eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 526a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (!alloc->getIsScript()) { 527a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk return; // nothing to sync 528a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 529a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 530a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsdHal *dc = (RsdHal *)rsc->mHal.drv; 531a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsdFrameBufferObj *lastFbo = dc->gl.currentFrameBuffer; 532a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 533a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 534a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (!drv->textureID && !drv->renderTargetID) { 535a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk return; // nothing was rendered here yet, so nothing to sync 536a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 537a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (drv->readBackFBO == NULL) { 538a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO = new RsdFrameBufferObj(); 539a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO->setColorTarget(drv, 0); 540a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO->setDimensions(alloc->getType()->getDimX(), 541a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk alloc->getType()->getDimY()); 542a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 543a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 544a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk // Bind the framebuffer object so we can read back from it 545a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO->setActive(rsc); 546a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 547a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk // Do the readback 548709a0978ae141198018ca9769f8d96292a8928e6Jason Sams RSD_CALL_GL(glReadPixels, 0, 0, alloc->mHal.drvState.lod[0].dimX, 549709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].dimY, 550709a0978ae141198018ca9769f8d96292a8928e6Jason Sams drv->glFormat, drv->glType, alloc->mHal.drvState.lod[0].mallocPtr); 551a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 552a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk // Revert framebuffer to its original 553a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk lastFbo->setActive(rsc); 55493eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 555a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk} 556eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 557eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 558eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationSyncAll(const Context *rsc, const Allocation *alloc, 559eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams RsAllocationUsageType src) { 560eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 561eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 562a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (src == RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 563a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if(!alloc->getIsRenderTarget()) { 564a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsc->setError(RS_ERROR_FATAL_DRIVER, 565a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "Attempting to sync allocation from render target, " 566a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "for non-render target allocation"); 567a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } else if (alloc->getType()->getElement()->getKind() != RS_KIND_PIXEL_RGBA) { 568a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsc->setError(RS_ERROR_FATAL_DRIVER, "Cannot only sync from RGBA" 569a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "render target"); 570a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } else { 571a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsdAllocationSyncFromFBO(rsc, alloc); 572a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 573eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 574eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 575eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 576eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsAssert(src == RS_ALLOCATION_USAGE_SCRIPT); 577eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 578eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) { 579eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams UploadToTexture(rsc, alloc); 580eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 581b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if ((alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) && 5820dc66936c02f285a242b6a68166d6f03618a0f07Jason Sams !(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT)) { 583eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams AllocateRenderTarget(rsc, alloc); 584eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 585eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 586eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) { 587eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams UploadToBufferObject(rsc, alloc); 588eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 589eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 590eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = false; 591eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 592eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 593eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationMarkDirty(const Context *rsc, const Allocation *alloc) { 594eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 595eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 596eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 597eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 598733396b67724162844ea2785c7495115dc5ee8d8Jason Samsvoid* rsdAllocationGetSurface(const Context *rsc, const Allocation *alloc) { 59993eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 60041e373d91a60043afa0f9abd026218b49cbc1201Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 601733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 602733396b67724162844ea2785c7495115dc5ee8d8Jason Sams drv->cpuConsumer = new CpuConsumer(2); 603733396b67724162844ea2785c7495115dc5ee8d8Jason Sams sp<IGraphicBufferProducer> bp = drv->cpuConsumer->getProducerInterface(); 604733396b67724162844ea2785c7495115dc5ee8d8Jason Sams bp->incStrong(NULL); 605733396b67724162844ea2785c7495115dc5ee8d8Jason Sams return bp.get(); 60693eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#else 607733396b67724162844ea2785c7495115dc5ee8d8Jason Sams return NULL; 60893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 60941e373d91a60043afa0f9abd026218b49cbc1201Jason Sams} 61041e373d91a60043afa0f9abd026218b49cbc1201Jason Sams 61193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 6127ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsstatic bool IoGetBuffer(const Context *rsc, Allocation *alloc, ANativeWindow *nw) { 6137ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 6147ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 615cd919a177f2b25af1b304dd4d79f0a768fed342fJamie Gennis int32_t r = native_window_dequeue_buffer_and_wait(nw, &drv->wndBuffer); 6167ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 6177ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error getting next IO output buffer."); 6187ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return false; 6197ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6207ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6217ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams // Must lock the whole surface 6227ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 6237ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams Rect bounds(drv->wndBuffer->width, drv->wndBuffer->height); 6247ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6257ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams void *dst = NULL; 6267ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams mapper.lock(drv->wndBuffer->handle, 6277ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN, 6287ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams bounds, &dst); 629709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = dst; 630709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].stride = drv->wndBuffer->stride * alloc->mHal.state.elementSizeBytes; 63194999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines rsAssert((alloc->mHal.drvState.lod[0].stride & 0xf) == 0); 632b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 6337ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return true; 6347ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 63593eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 6367ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 637733396b67724162844ea2785c7495115dc5ee8d8Jason Samsvoid rsdAllocationSetSurface(const Context *rsc, Allocation *alloc, ANativeWindow *nw) { 63893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 6397ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 6403a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray ANativeWindow *old = drv->wndSurface; 6413a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 6423a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (nw) { 6433a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray nw->incStrong(NULL); 6443a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 6457ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 646b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 647b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams //TODO finish support for render target + script 648b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams drv->wnd = nw; 649b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams return; 650b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 651b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 6527ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams // Cleanup old surface if there is one. 6533a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (drv->wndSurface) { 6543a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray ANativeWindow *old = drv->wndSurface; 6557ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 6567ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams mapper.unlock(drv->wndBuffer->handle); 6573a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray old->cancelBuffer(old, drv->wndBuffer, -1); 6583a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray drv->wndSurface = NULL; 6593a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray old->decStrong(NULL); 6607ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6617ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6627ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (nw != NULL) { 6637ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams int32_t r; 664b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams uint32_t flags = 0; 6653a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray r = native_window_set_buffer_count(nw, 3); 6663a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (r) { 6673a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer count."); 6683a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray goto error; 6693a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 6703a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 671b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 672b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams flags |= GRALLOC_USAGE_SW_READ_RARELY | GRALLOC_USAGE_SW_WRITE_OFTEN; 673b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 674b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 675b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams flags |= GRALLOC_USAGE_HW_RENDER; 676b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 677b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 678b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams r = native_window_set_usage(nw, flags); 6797ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 6807ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer usage."); 6813a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray goto error; 6827ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6837ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 684a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams r = native_window_set_buffers_dimensions(nw, alloc->mHal.drvState.lod[0].dimX, 685a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams alloc->mHal.drvState.lod[0].dimY); 6867ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 6877ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer dimensions."); 6883a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray goto error; 6897ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6907ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 691733396b67724162844ea2785c7495115dc5ee8d8Jason Sams int format = 0; 692733396b67724162844ea2785c7495115dc5ee8d8Jason Sams const Element *e = alloc->mHal.state.type->getElement(); 693733396b67724162844ea2785c7495115dc5ee8d8Jason Sams switch(e->getType()) { 694733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case RS_TYPE_UNSIGNED_8: 695733396b67724162844ea2785c7495115dc5ee8d8Jason Sams switch (e->getVectorSize()) { 696733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case 1: 697733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(e->getKind() == RS_KIND_PIXEL_A); 698733396b67724162844ea2785c7495115dc5ee8d8Jason Sams format = PIXEL_FORMAT_A_8; 699733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 700733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case 4: 701733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(e->getKind() == RS_KIND_PIXEL_RGBA); 702733396b67724162844ea2785c7495115dc5ee8d8Jason Sams format = PIXEL_FORMAT_RGBA_8888; 703733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 704733396b67724162844ea2785c7495115dc5ee8d8Jason Sams default: 705733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(0); 706733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 707733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 708733396b67724162844ea2785c7495115dc5ee8d8Jason Sams default: 709733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(0); 710733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 711733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 712733396b67724162844ea2785c7495115dc5ee8d8Jason Sams r = native_window_set_buffers_format(nw, format); 713733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (r) { 714733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer format."); 7153a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray goto error; 7167ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 7177ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7187ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams IoGetBuffer(rsc, alloc, nw); 7193a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray drv->wndSurface = nw; 7203a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 7213a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 7223a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray return; 7233a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 7243a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray error: 7253a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 7263a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (nw) { 7273a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray nw->decStrong(NULL); 7287ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 7293a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 7303a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 73193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 7327ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 7337ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7347ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid rsdAllocationIoSend(const Context *rsc, Allocation *alloc) { 73593eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 7367ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 7373a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray ANativeWindow *nw = drv->wndSurface; 738b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 739b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams RsdHal *dc = (RsdHal *)rsc->mHal.drv; 740b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams RSD_CALL_GL(eglSwapBuffers, dc->gl.egl.display, dc->gl.egl.surface); 7417ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return; 7427ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 7433a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (nw) { 7443a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 7453a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 7463a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray mapper.unlock(drv->wndBuffer->handle); 7473a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray int32_t r = nw->queueBuffer(nw, drv->wndBuffer, -1); 7483a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (r) { 7493a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray rsc->setError(RS_ERROR_DRIVER, "Error sending IO output buffer."); 7503a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray return; 7513a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 7527ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7533a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray IoGetBuffer(rsc, alloc, nw); 754b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 7553a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } else { 7563a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray rsc->setError(RS_ERROR_DRIVER, "Sent IO buffer with no attached surface."); 7573a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray return; 758b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 75993eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 7607ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 7617ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7627ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid rsdAllocationIoReceive(const Context *rsc, Allocation *alloc) { 76393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 7643522f40418fdf877f5a136475dbf75e57a3b7c77Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 765733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 766733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 767733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (drv->lb.data != NULL) { 768733396b67724162844ea2785c7495115dc5ee8d8Jason Sams drv->cpuConsumer->unlockBuffer(drv->lb); 769733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 770733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 771733396b67724162844ea2785c7495115dc5ee8d8Jason Sams status_t ret = drv->cpuConsumer->lockNextBuffer(&drv->lb); 772733396b67724162844ea2785c7495115dc5ee8d8Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = drv->lb.data; 773733396b67724162844ea2785c7495115dc5ee8d8Jason Sams alloc->mHal.drvState.lod[0].stride = drv->lb.stride * alloc->mHal.state.elementSizeBytes; 774733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 775733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (alloc->mHal.state.yuv) { 776733396b67724162844ea2785c7495115dc5ee8d8Jason Sams DeriveYUVLayout(alloc->mHal.state.yuv, &alloc->mHal.drvState); 777733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 778733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 779733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } else { 7803a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray drv->surfaceTexture->updateTexImage(); 781733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 782733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 783733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 78493eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 7857ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 7867ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7877ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 788eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationData1D(const Context *rsc, const Allocation *alloc, 789eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t xoff, uint32_t lod, uint32_t count, 790c794cd56e46408e08862c42a022090e323684197Alex Sakhartchouk const void *data, size_t sizeBytes) { 791eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 792eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 793eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes(); 794807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 795eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t size = count * eSize; 796eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 79720c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (ptr != data) { 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 if (alloc->mHal.state.hasReferences) { 80120c535f54fb41348a96af98079ad377d7a310c8aStephen Hines alloc->incRefs(data, count); 80220c535f54fb41348a96af98079ad377d7a310c8aStephen Hines alloc->decRefs(ptr, count); 80320c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 80420c535f54fb41348a96af98079ad377d7a310c8aStephen Hines memcpy(ptr, data, size); 805eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 806eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 807eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 808eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 809eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationData2D(const Context *rsc, const Allocation *alloc, 810eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 811358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t w, uint32_t h, const void *data, size_t sizeBytes, size_t stride) { 812eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 813eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 814eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 815eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t lineSize = eSize * w; 816358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray if (!stride) { 817358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray stride = lineSize; 818358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray } 819eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 820709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 821eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const uint8_t *src = static_cast<const uint8_t *>(data); 822807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *dst = GetOffsetPtr(alloc, xoff, yoff, lod, face); 82320c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (dst == src) { 82420c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 82520c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 82620c535f54fb41348a96af98079ad377d7a310c8aStephen Hines drv->uploadDeferred = true; 82720c535f54fb41348a96af98079ad377d7a310c8aStephen Hines return; 82820c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 829eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 830eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams for (uint32_t line=yoff; line < (yoff+h); line++) { 831eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasReferences) { 832eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->incRefs(src, w); 833eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->decRefs(dst, w); 834eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 835eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memcpy(dst, src, lineSize); 836358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray src += stride; 837709a0978ae141198018ca9769f8d96292a8928e6Jason Sams dst += alloc->mHal.drvState.lod[lod].stride; 838eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 839bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams if (alloc->mHal.state.yuv) { 840bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams int lod = 1; 841bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams while (alloc->mHal.drvState.lod[lod].mallocPtr) { 842bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams uint32_t lineSize = alloc->mHal.drvState.lod[lod].dimX; 843bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams uint8_t *dst = GetOffsetPtr(alloc, xoff, yoff, lod, face); 844bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams 845bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams for (uint32_t line=(yoff >> 1); line < ((yoff+h)>>1); line++) { 846bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams memcpy(dst, src, lineSize); 847bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams src += lineSize; 848bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams dst += alloc->mHal.drvState.lod[lod].stride; 849bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 850bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams lod++; 851bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 852bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams 853bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 854eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 855eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 8562382aba4a55c6ae74789c478eead8fbd96593321Jason Sams Update2DTexture(rsc, alloc, data, xoff, yoff, lod, face, w, h); 857eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 858eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 859eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 860eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationData3D(const Context *rsc, const Allocation *alloc, 861eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t xoff, uint32_t yoff, uint32_t zoff, 862eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t lod, RsAllocationCubemapFace face, 863eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t w, uint32_t h, uint32_t d, const void *data, uint32_t sizeBytes) { 864eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 865eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 866eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 867807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationRead1D(const Context *rsc, const Allocation *alloc, 868807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t xoff, uint32_t lod, uint32_t count, 869807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams void *data, size_t sizeBytes) { 870807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes(); 871807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 87220c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (data != ptr) { 87320c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 87420c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 87520c535f54fb41348a96af98079ad377d7a310c8aStephen Hines memcpy(data, ptr, count * eSize); 87620c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 877807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 878807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 879807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationRead2D(const Context *rsc, const Allocation *alloc, 880358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 881358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t w, uint32_t h, void *data, size_t sizeBytes, size_t stride) { 882807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 883807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t lineSize = eSize * w; 884358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray if (!stride) { 885358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray stride = lineSize; 886358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray } 887807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 888709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 889807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *dst = static_cast<uint8_t *>(data); 890807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint8_t *src = GetOffsetPtr(alloc, xoff, yoff, lod, face); 89120c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (dst == src) { 89220c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 89320c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 89420c535f54fb41348a96af98079ad377d7a310c8aStephen Hines return; 89520c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 896807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 897807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams for (uint32_t line=yoff; line < (yoff+h); line++) { 898807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams memcpy(dst, src, lineSize); 899358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray dst += stride; 900709a0978ae141198018ca9769f8d96292a8928e6Jason Sams src += alloc->mHal.drvState.lod[lod].stride; 901807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 902807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } else { 903807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams ALOGE("Add code to readback from non-script memory"); 904807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 905807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 906807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 907358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray 908807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationRead3D(const Context *rsc, const Allocation *alloc, 909807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t xoff, uint32_t yoff, uint32_t zoff, 910807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t lod, RsAllocationCubemapFace face, 911807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t w, uint32_t h, uint32_t d, void *data, uint32_t sizeBytes) { 912807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 913807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 914807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 915807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid * rsdAllocationLock1D(const android::renderscript::Context *rsc, 916807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const android::renderscript::Allocation *alloc) { 917709a0978ae141198018ca9769f8d96292a8928e6Jason Sams return alloc->mHal.drvState.lod[0].mallocPtr; 918807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 919807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 920807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationUnlock1D(const android::renderscript::Context *rsc, 921807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const android::renderscript::Allocation *alloc) { 922807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 923807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 924807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 92574a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsdAllocationData1D_alloc(const android::renderscript::Context *rsc, 92674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 92774a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstLod, uint32_t count, 92874a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 929a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t srcXoff, uint32_t srcLod) { 930a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk} 931a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 932a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 933a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchoukvoid rsdAllocationData2D_alloc_script(const android::renderscript::Context *rsc, 934a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 935a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod, 936a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h, 937a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 938a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod, 939a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsAllocationCubemapFace srcFace) { 940a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t elementSize = dstAlloc->getType()->getElementSizeBytes(); 941a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk for (uint32_t i = 0; i < h; i ++) { 942807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *dstPtr = GetOffsetPtr(dstAlloc, dstXoff, dstYoff + i, dstLod, dstFace); 943807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *srcPtr = GetOffsetPtr(srcAlloc, srcXoff, srcYoff + i, srcLod, srcFace); 944a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk memcpy(dstPtr, srcPtr, w * elementSize); 945a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 946af12ac6a08651464f8d823add667c706f993b587Steve Block //ALOGE("COPIED dstXoff(%u), dstYoff(%u), dstLod(%u), dstFace(%u), w(%u), h(%u), srcXoff(%u), srcYoff(%u), srcLod(%u), srcFace(%u)", 9470a44ab45c739f00f457874418e7384492e4df979Stephen Hines // dstXoff, dstYoff, dstLod, dstFace, w, h, srcXoff, srcYoff, srcLod, srcFace); 948a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 94974a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 95074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 95174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsdAllocationData2D_alloc(const android::renderscript::Context *rsc, 95274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 95374a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod, 95474a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h, 95574a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 95674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod, 95774a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk RsAllocationCubemapFace srcFace) { 958a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (!dstAlloc->getIsScript() && !srcAlloc->getIsScript()) { 959a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsc->setError(RS_ERROR_FATAL_DRIVER, "Non-script allocation copies not " 960a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "yet implemented."); 961a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk return; 962a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 963a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsdAllocationData2D_alloc_script(rsc, dstAlloc, dstXoff, dstYoff, 964a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk dstLod, dstFace, w, h, srcAlloc, 965a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk srcXoff, srcYoff, srcLod, srcFace); 96674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 96774a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 96874a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsdAllocationData3D_alloc(const android::renderscript::Context *rsc, 96974a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 97074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff, 97174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstLod, RsAllocationCubemapFace dstFace, 97274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t w, uint32_t h, uint32_t d, 97374a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 97474a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, 97574a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcLod, RsAllocationCubemapFace srcFace) { 97674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 97774a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 978eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationElementData1D(const Context *rsc, const Allocation *alloc, 979eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t x, 980eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const void *data, uint32_t cIdx, uint32_t sizeBytes) { 981eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 982eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 983eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 984807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = GetOffsetPtr(alloc, x, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 985eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 986eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx); 987eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx); 988eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 989eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasReferences) { 990eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->incRefs(data); 991eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->decRefs(ptr); 992eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 993eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 994eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memcpy(ptr, data, sizeBytes); 995eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 996eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 997eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 998eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationElementData2D(const Context *rsc, const Allocation *alloc, 999eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t x, uint32_t y, 1000eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const void *data, uint32_t cIdx, uint32_t sizeBytes) { 1001eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 1002eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1003eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 1004807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = GetOffsetPtr(alloc, x, y, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 1005eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1006eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx); 1007eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx); 1008eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1009eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasReferences) { 1010eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->incRefs(data); 1011eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->decRefs(ptr); 1012eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 1013eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1014eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memcpy(ptr, data, sizeBytes); 1015eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 1016eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 1017eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 101861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsstatic void mip565(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 1019709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t w = alloc->mHal.drvState.lod[lod + 1].dimX; 1020709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t h = alloc->mHal.drvState.lod[lod + 1].dimY; 102161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 102261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t y=0; y < h; y++) { 102361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint16_t *oPtr = (uint16_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face); 102461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint16_t *i1 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2, lod, face); 102561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint16_t *i2 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face); 102661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 102761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t x=0; x < w; x++) { 102861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams *oPtr = rsBoxFilter565(i1[0], i1[1], i2[0], i2[1]); 102961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams oPtr ++; 103061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i1 += 2; 103161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i2 += 2; 103261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 103361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 103461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 103561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 103661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsstatic void mip8888(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 1037709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t w = alloc->mHal.drvState.lod[lod + 1].dimX; 1038709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t h = alloc->mHal.drvState.lod[lod + 1].dimY; 103961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 104061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t y=0; y < h; y++) { 104161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint32_t *oPtr = (uint32_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face); 104261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint32_t *i1 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2, lod, face); 104361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint32_t *i2 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face); 104461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 104561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t x=0; x < w; x++) { 104661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams *oPtr = rsBoxFilter8888(i1[0], i1[1], i2[0], i2[1]); 104761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams oPtr ++; 104861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i1 += 2; 104961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i2 += 2; 105061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 105161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 105261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 105361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 105461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsstatic void mip8(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 1055709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t w = alloc->mHal.drvState.lod[lod + 1].dimX; 1056709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t h = alloc->mHal.drvState.lod[lod + 1].dimY; 105761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 105861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t y=0; y < h; y++) { 105961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint8_t *oPtr = GetOffsetPtr(alloc, 0, y, lod + 1, face); 106061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint8_t *i1 = GetOffsetPtr(alloc, 0, y*2, lod, face); 106161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint8_t *i2 = GetOffsetPtr(alloc, 0, y*2+1, lod, face); 106261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 106361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t x=0; x < w; x++) { 106461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams *oPtr = (uint8_t)(((uint32_t)i1[0] + i1[1] + i2[0] + i2[1]) * 0.25f); 106561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams oPtr ++; 106661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i1 += 2; 106761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i2 += 2; 106861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 106961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 107061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 107161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 107261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsvoid rsdAllocationGenerateMipmaps(const Context *rsc, const Allocation *alloc) { 1073709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if(!alloc->mHal.drvState.lod[0].mallocPtr) { 107461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams return; 107561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 107661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint32_t numFaces = alloc->getType()->getDimFaces() ? 6 : 1; 107761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t face = 0; face < numFaces; face ++) { 107861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t lod=0; lod < (alloc->getType()->getLODCount() -1); lod++) { 107961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams switch (alloc->getType()->getElement()->getSizeBits()) { 108061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams case 32: 108161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mip8888(alloc, lod, (RsAllocationCubemapFace)face); 108261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams break; 108361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams case 16: 108461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mip565(alloc, lod, (RsAllocationCubemapFace)face); 108561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams break; 108661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams case 8: 108761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mip8(alloc, lod, (RsAllocationCubemapFace)face); 108861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams break; 108961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 109061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 109161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 109261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 109361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 1094eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1095