rsdAllocation.cpp revision 3a25fdd3786c1a08b783d8a83ef94b756347ff5c
1eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams/* 2bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams * Copyright (C) 2013 The Android Open Source Project 3eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * 4eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * Licensed under the Apache License, Version 2.0 (the "License"); 5eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * you may not use this file except in compliance with the License. 6eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * You may obtain a copy of the License at 7eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * 8eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * http://www.apache.org/licenses/LICENSE-2.0 9eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * 10eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * Unless required by applicable law or agreed to in writing, software 11eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * distributed under the License is distributed on an "AS IS" BASIS, 12eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * See the License for the specific language governing permissions and 14eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams * limitations under the License. 15eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams */ 16eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 17eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 18eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include "rsdCore.h" 19eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include "rsdAllocation.h" 20eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 21eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include "rsAllocation.h" 22eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 237ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams#include "system/window.h" 247ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams#include "ui/Rect.h" 257ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams#include "ui/GraphicBufferMapper.h" 2693eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams 2793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 2893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#include "rsdFrameBufferObj.h" 2958fd6a5f10480551786739280d56dfa620c80b39Andy McFadden#include "gui/GLConsumer.h" 30733396b67724162844ea2785c7495115dc5ee8d8Jason Sams#include "gui/CpuConsumer.h" 31733396b67724162844ea2785c7495115dc5ee8d8Jason Sams#include "gui/Surface.h" 3293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#include "hardware/gralloc.h" 337ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 34eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include <GLES/gl.h> 35eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include <GLES2/gl2.h> 36eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include <GLES/glext.h> 3793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 38eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 39eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsusing namespace android; 40eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsusing namespace android::renderscript; 41eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 42eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 4393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 44eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsconst static GLenum gFaceOrder[] = { 45eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_POSITIVE_X, 46eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 47eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 48eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 49eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 50eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 51eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams}; 52eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 53a614ae175bbf97201b5e18984d814a1d3e86faa8Jason SamsGLenum rsdTypeToGLType(RsDataType t) { 54a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams switch (t) { 55a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_5_6_5: return GL_UNSIGNED_SHORT_5_6_5; 56a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_5_5_5_1: return GL_UNSIGNED_SHORT_5_5_5_1; 57a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_4_4_4_4: return GL_UNSIGNED_SHORT_4_4_4_4; 58a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 59a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams //case RS_TYPE_FLOAT_16: return GL_HALF_FLOAT; 60a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_FLOAT_32: return GL_FLOAT; 61a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_8: return GL_UNSIGNED_BYTE; 62a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_UNSIGNED_16: return GL_UNSIGNED_SHORT; 63a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_SIGNED_8: return GL_BYTE; 64a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_TYPE_SIGNED_16: return GL_SHORT; 65a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams default: break; 66a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams } 67a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams return 0; 68a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams} 69a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 70a614ae175bbf97201b5e18984d814a1d3e86faa8Jason SamsGLenum rsdKindToGLFormat(RsDataKind k) { 71a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams switch (k) { 72a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_L: return GL_LUMINANCE; 73a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_A: return GL_ALPHA; 74a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_LA: return GL_LUMINANCE_ALPHA; 75a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_RGB: return GL_RGB; 76a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_RGBA: return GL_RGBA; 77a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams case RS_KIND_PIXEL_DEPTH: return GL_DEPTH_COMPONENT16; 78a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams default: break; 79a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams } 80a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams return 0; 81a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams} 8293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 83a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 84807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsuint8_t *GetOffsetPtr(const android::renderscript::Allocation *alloc, 85807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t xoff, uint32_t yoff, uint32_t lod, 86807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams RsAllocationCubemapFace face) { 87709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint8_t *ptr = (uint8_t *)alloc->mHal.drvState.lod[lod].mallocPtr; 88709a0978ae141198018ca9769f8d96292a8928e6Jason Sams ptr += face * alloc->mHal.drvState.faceOffset; 89709a0978ae141198018ca9769f8d96292a8928e6Jason Sams ptr += yoff * alloc->mHal.drvState.lod[lod].stride; 90807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams ptr += xoff * alloc->mHal.state.elementSizeBytes; 91807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams return ptr; 92807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 93807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 94a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 952382aba4a55c6ae74789c478eead8fbd96593321Jason Samsstatic void Update2DTexture(const Context *rsc, const Allocation *alloc, const void *ptr, 962382aba4a55c6ae74789c478eead8fbd96593321Jason Sams uint32_t xoff, uint32_t yoff, uint32_t lod, 972382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RsAllocationCubemapFace face, uint32_t w, uint32_t h) { 9893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 99eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 100eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 101eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsAssert(drv->textureID); 1022382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindTexture, drv->glTarget, drv->textureID); 1032382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glPixelStorei, GL_UNPACK_ALIGNMENT, 1); 104eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GLenum t = GL_TEXTURE_2D; 105eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasFaces) { 106eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams t = gFaceOrder[face]; 107eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 1082382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glTexSubImage2D, t, lod, xoff, yoff, w, h, drv->glFormat, drv->glType, ptr); 10993eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 110eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 111eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 112eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 11393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 114eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsstatic void Upload2DTexture(const Context *rsc, const Allocation *alloc, bool isFirstUpload) { 115eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 116eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1172382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindTexture, drv->glTarget, drv->textureID); 1182382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glPixelStorei, GL_UNPACK_ALIGNMENT, 1); 119eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 120eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t faceCount = 1; 121eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasFaces) { 122eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams faceCount = 6; 123eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 124eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 125eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "Upload2DTexture 1 "); 126eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams for (uint32_t face = 0; face < faceCount; face ++) { 127eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams for (uint32_t lod = 0; lod < alloc->mHal.state.type->getLODCount(); lod++) { 128807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint8_t *p = GetOffsetPtr(alloc, 0, 0, lod, (RsAllocationCubemapFace)face); 129eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 130eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams GLenum t = GL_TEXTURE_2D; 131eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasFaces) { 132eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams t = gFaceOrder[face]; 133eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 134eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 135eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (isFirstUpload) { 1362382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glTexImage2D, t, lod, drv->glFormat, 137eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.state.type->getLODDimX(lod), 138eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.state.type->getLODDimY(lod), 139a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 0, drv->glFormat, drv->glType, p); 140eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 1412382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glTexSubImage2D, t, lod, 0, 0, 142eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.state.type->getLODDimX(lod), 143eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.state.type->getLODDimY(lod), 144a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams drv->glFormat, drv->glType, p); 145eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 146eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 147eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 148eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 149eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.mipmapControl == RS_ALLOCATION_MIPMAP_ON_SYNC_TO_TEXTURE) { 1502382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glGenerateMipmap, drv->glTarget); 151eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 152eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "Upload2DTexture"); 153eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 15493eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 155eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 156eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsstatic void UploadToTexture(const Context *rsc, const Allocation *alloc) { 15793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 158eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 159eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1603522f40418fdf877f5a136475dbf75e57a3b7c77Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_INPUT) { 16141e373d91a60043afa0f9abd026218b49cbc1201Jason Sams if (!drv->textureID) { 16241e373d91a60043afa0f9abd026218b49cbc1201Jason Sams RSD_CALL_GL(glGenTextures, 1, &drv->textureID); 16341e373d91a60043afa0f9abd026218b49cbc1201Jason Sams } 16441e373d91a60043afa0f9abd026218b49cbc1201Jason Sams return; 16541e373d91a60043afa0f9abd026218b49cbc1201Jason Sams } 16641e373d91a60043afa0f9abd026218b49cbc1201Jason Sams 167a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams if (!drv->glType || !drv->glFormat) { 168eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 169eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 170eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 171709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (!alloc->mHal.drvState.lod[0].mallocPtr) { 172eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 173eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 174eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 175eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams bool isFirstUpload = false; 176eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 177eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->textureID) { 1782382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glGenTextures, 1, &drv->textureID); 179eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams isFirstUpload = true; 180eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 181eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 182eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams Upload2DTexture(rsc, alloc, isFirstUpload); 183eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 184eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT)) { 185709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 186709a0978ae141198018ca9769f8d96292a8928e6Jason Sams free(alloc->mHal.drvState.lod[0].mallocPtr); 187709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = NULL; 188eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 189eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 190eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "UploadToTexture"); 19193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 192eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 193eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 194eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsstatic void AllocateRenderTarget(const Context *rsc, const Allocation *alloc) { 19593eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 196eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 197eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 198a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams if (!drv->glFormat) { 199eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 200eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 201eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 202eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->renderTargetID) { 2032382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glGenRenderbuffers, 1, &drv->renderTargetID); 204eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 205eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->renderTargetID) { 206eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams // This should generally not happen 207af12ac6a08651464f8d823add667c706f993b587Steve Block ALOGE("allocateRenderTarget failed to gen mRenderTargetID"); 208eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsc->dumpDebug(); 209eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 210eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 2112382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindRenderbuffer, GL_RENDERBUFFER, drv->renderTargetID); 2122382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glRenderbufferStorage, GL_RENDERBUFFER, drv->glFormat, 213a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams alloc->mHal.drvState.lod[0].dimX, alloc->mHal.drvState.lod[0].dimY); 214eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 215eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "AllocateRenderTarget"); 21693eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 217eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 218eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 219eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsstatic void UploadToBufferObject(const Context *rsc, const Allocation *alloc) { 22093eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 221eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 222eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 223eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsAssert(!alloc->mHal.state.type->getDimY()); 224eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsAssert(!alloc->mHal.state.type->getDimZ()); 225eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 226eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams //alloc->mHal.state.usageFlags |= RS_ALLOCATION_USAGE_GRAPHICS_VERTEX; 227eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 228eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->bufferID) { 2292382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glGenBuffers, 1, &drv->bufferID); 230eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 231eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!drv->bufferID) { 232af12ac6a08651464f8d823add667c706f993b587Steve Block ALOGE("Upload to buffer object failed"); 233eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 234eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 235eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 2362382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindBuffer, drv->glTarget, drv->bufferID); 2372382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBufferData, drv->glTarget, alloc->mHal.state.type->getSizeBytes(), 238709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr, GL_DYNAMIC_DRAW); 2392382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glBindBuffer, drv->glTarget, 0); 240eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsdGLCheckError(rsc, "UploadToBufferObject"); 24193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 242eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 243eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 244733396b67724162844ea2785c7495115dc5ee8d8Jason Samsstatic void DeriveYUVLayout(int yuv, Allocation::Hal::DrvState *state) { 245733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // YUV only supports basic 2d 246733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // so we can stash the plane pointers in the mipmap levels. 247733396b67724162844ea2785c7495115dc5ee8d8Jason Sams switch(yuv) { 248733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case HAL_PIXEL_FORMAT_YV12: 249733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimX = state->lod[0].dimX / 2; 250733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimY = state->lod[0].dimY / 2; 251733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].stride = rsRound(state->lod[0].stride >> 1, 16); 252733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].mallocPtr = ((uint8_t *)state->lod[0].mallocPtr) + 253733396b67724162844ea2785c7495115dc5ee8d8Jason Sams (state->lod[0].stride * state->lod[0].dimY); 254733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 255733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].dimX = state->lod[1].dimX; 256733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].dimY = state->lod[1].dimY; 257733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].stride = state->lod[1].stride; 258733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[2].mallocPtr = ((uint8_t *)state->lod[1].mallocPtr) + 259733396b67724162844ea2785c7495115dc5ee8d8Jason Sams (state->lod[1].stride * state->lod[1].dimY); 260733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 261733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lodCount = 3; 262733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 263733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 264733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimX = state->lod[0].dimX; 265733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].dimY = state->lod[0].dimY / 2; 266733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].stride = state->lod[0].stride; 267733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lod[1].mallocPtr = ((uint8_t *)state->lod[0].mallocPtr) + 268733396b67724162844ea2785c7495115dc5ee8d8Jason Sams (state->lod[0].stride * state->lod[0].dimY); 269733396b67724162844ea2785c7495115dc5ee8d8Jason Sams state->lodCount = 2; 270733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 271733396b67724162844ea2785c7495115dc5ee8d8Jason Sams default: 272733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(0); 273733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 274733396b67724162844ea2785c7495115dc5ee8d8Jason Sams} 275733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 276733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 277463bfced38d97605dd8403a5e9435d9ad3394e35Jason Samsstatic size_t AllocationBuildPointerTable(const Context *rsc, const Allocation *alloc, 278463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams const Type *type, uint8_t *ptr) { 279709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].dimX = type->getDimX(); 280709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].dimY = type->getDimY(); 281f2b611e26db1c83ad5e0e0cdebcfa639b03fba75Jason Sams alloc->mHal.drvState.lod[0].dimZ = type->getDimZ(); 282709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = 0; 28394999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines // Stride needs to be 16-byte aligned too! 28494999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines size_t stride = alloc->mHal.drvState.lod[0].dimX * type->getElementSizeBytes(); 28594999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines alloc->mHal.drvState.lod[0].stride = rsRound(stride, 16); 286709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lodCount = type->getLODCount(); 287709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.faceCount = type->getDimFaces(); 288807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 289807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams size_t offsets[Allocation::MAX_LOD]; 290807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams memset(offsets, 0, sizeof(offsets)); 291807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 292709a0978ae141198018ca9769f8d96292a8928e6Jason Sams size_t o = alloc->mHal.drvState.lod[0].stride * rsMax(alloc->mHal.drvState.lod[0].dimY, 1u) * 293709a0978ae141198018ca9769f8d96292a8928e6Jason Sams rsMax(alloc->mHal.drvState.lod[0].dimZ, 1u); 294709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if(alloc->mHal.drvState.lodCount > 1) { 295709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t tx = alloc->mHal.drvState.lod[0].dimX; 296709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t ty = alloc->mHal.drvState.lod[0].dimY; 297709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t tz = alloc->mHal.drvState.lod[0].dimZ; 298709a0978ae141198018ca9769f8d96292a8928e6Jason Sams for (uint32_t lod=1; lod < alloc->mHal.drvState.lodCount; lod++) { 299709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].dimX = tx; 300709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].dimY = ty; 301709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].dimZ = tz; 30294999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines alloc->mHal.drvState.lod[lod].stride = 30394999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines rsRound(tx * type->getElementSizeBytes(), 16); 304807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams offsets[lod] = o; 305709a0978ae141198018ca9769f8d96292a8928e6Jason Sams o += alloc->mHal.drvState.lod[lod].stride * rsMax(ty, 1u) * rsMax(tz, 1u); 306807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if (tx > 1) tx >>= 1; 307807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if (ty > 1) ty >>= 1; 308807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if (tz > 1) tz >>= 1; 309807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 310bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } else if (alloc->mHal.state.yuv) { 311733396b67724162844ea2785c7495115dc5ee8d8Jason Sams DeriveYUVLayout(alloc->mHal.state.yuv, &alloc->mHal.drvState); 312733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 313733396b67724162844ea2785c7495115dc5ee8d8Jason Sams for (uint32_t ct = 1; ct < alloc->mHal.drvState.lodCount; ct++) { 314733396b67724162844ea2785c7495115dc5ee8d8Jason Sams offsets[ct] = (size_t)alloc->mHal.drvState.lod[ct].mallocPtr; 315bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 316807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 317bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams 318709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.faceOffset = o; 319807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 320709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = ptr; 321709a0978ae141198018ca9769f8d96292a8928e6Jason Sams for (uint32_t lod=1; lod < alloc->mHal.drvState.lodCount; lod++) { 322709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[lod].mallocPtr = ptr + offsets[lod]; 323463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 324463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 325709a0978ae141198018ca9769f8d96292a8928e6Jason Sams size_t allocSize = alloc->mHal.drvState.faceOffset; 326709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if(alloc->mHal.drvState.faceCount) { 327463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams allocSize *= 6; 328463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 329463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 330463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams return allocSize; 331463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams} 332463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 333c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murraystatic uint8_t* allocAlignedMemory(size_t allocSize, bool forceZero) { 334c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // We align all allocations to a 16-byte boundary. 335c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray uint8_t* ptr = (uint8_t *)memalign(16, allocSize); 336c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (!ptr) { 337c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray return NULL; 338c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 339c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (forceZero) { 340c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray memset(ptr, 0, allocSize); 341c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 342c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray return ptr; 343c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray} 344c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 345463bfced38d97605dd8403a5e9435d9ad3394e35Jason Samsbool rsdAllocationInit(const Context *rsc, Allocation *alloc, bool forceZero) { 346463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams DrvAllocation *drv = (DrvAllocation *)calloc(1, sizeof(DrvAllocation)); 347463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams if (!drv) { 348463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams return false; 349463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 350463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams alloc->mHal.drv = drv; 351463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 352463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Calculate the object size. 353463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t allocSize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), NULL); 354463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams 355807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = NULL; 3567ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT) { 357733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 358733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } else if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_INPUT) { 359733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // Allocation is allocated when the surface is created 360733396b67724162844ea2785c7495115dc5ee8d8Jason Sams // in getSurface 3612e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } else if (alloc->mHal.state.userProvidedPtr != NULL) { 3622e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray // user-provided allocation 3632e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray // limitations: no faces, no LOD, USAGE_SCRIPT only 3649e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray if (alloc->mHal.state.usageFlags != (RS_ALLOCATION_USAGE_SCRIPT | RS_ALLOCATION_USAGE_SHARED)) { 3659e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray ALOGE("Can't use user-allocated buffers if usage is not USAGE_SCRIPT and USAGE_SHARED"); 3662e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray return false; 3672e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } 3682e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray if (alloc->getType()->getDimLOD() || alloc->getType()->getDimFaces()) { 3692e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray ALOGE("User-allocated buffers must not have multiple faces or LODs"); 3702e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray return false; 3712e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } 372c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 373c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // rows must be 16-byte aligned 374c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // validate that here, otherwise fall back to not use the user-backed allocation 375c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (((alloc->getType()->getDimX() * alloc->getType()->getElement()->getSizeBytes()) % 16) != 0) { 376c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ALOGV("User-backed allocation failed stride requirement, falling back to separate allocation"); 377c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray drv->useUserProvidedPtr = false; 378c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 379c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ptr = allocAlignedMemory(allocSize, forceZero); 380c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (!ptr) { 381c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray alloc->mHal.drv = NULL; 382c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray free(drv); 383c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray return false; 384c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 385c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 386c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } else { 387c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray drv->useUserProvidedPtr = true; 388c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ptr = (uint8_t*)alloc->mHal.state.userProvidedPtr; 389c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 3907ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } else { 391c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray ptr = allocAlignedMemory(allocSize, forceZero); 392179e9a457095fea4c9e6d366c269754b882d05ddJason Sams if (!ptr) { 393ed419f37009ff5375293c198268c381460efa0f2You Kim alloc->mHal.drv = NULL; 394179e9a457095fea4c9e6d366c269754b882d05ddJason Sams free(drv); 395179e9a457095fea4c9e6d366c269754b882d05ddJason Sams return false; 396179e9a457095fea4c9e6d366c269754b882d05ddJason Sams } 397eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 398463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Build the pointer tables 399463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t verifySize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), ptr); 400463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams if(allocSize != verifySize) { 401463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams rsAssert(!"Size mismatch"); 402807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 403eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 404eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_NONE; 405eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) { 406eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasFaces) { 407eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_TEXTURE_CUBE_MAP; 408eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 409eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_TEXTURE_2D; 410eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 411eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 412eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) { 413eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->glTarget = GL_ARRAY_BUFFER; 414eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 415eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 416eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 41793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 418a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams drv->glType = rsdTypeToGLType(alloc->mHal.state.type->getElement()->getComponent().getType()); 419a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams drv->glFormat = rsdKindToGLFormat(alloc->mHal.state.type->getElement()->getComponent().getKind()); 42093eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#else 42193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams drv->glType = 0; 42293eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams drv->glFormat = 0; 42393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 424a614ae175bbf97201b5e18984d814a1d3e86faa8Jason Sams 425eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & ~RS_ALLOCATION_USAGE_SCRIPT) { 426eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 427eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 428a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 429b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 430a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO = NULL; 431a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 432c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray // fill out the initial state of the buffer if we couldn't use the user-provided ptr and USAGE_SHARED was accepted 433c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if ((alloc->mHal.state.userProvidedPtr != 0) && (drv->useUserProvidedPtr == false)) { 434c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray rsdAllocationData2D(rsc, alloc, 0, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X, alloc->getType()->getDimX(), alloc->getType()->getDimY(), alloc->mHal.state.userProvidedPtr, allocSize, 0); 435c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray } 436c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray 437eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return true; 438eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 439eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 440eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationDestroy(const Context *rsc, Allocation *alloc) { 441eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 442eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 44393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 444eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (drv->bufferID) { 445eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams // Causes a SW crash.... 4466598201f1c4f409defac9a5af789fb53a7cc00f8Steve Block //ALOGV(" mBufferID %i", mBufferID); 447eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams //glDeleteBuffers(1, &mBufferID); 448eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams //mBufferID = 0; 449eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 450eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (drv->textureID) { 4512382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glDeleteTextures, 1, &drv->textureID); 452eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->textureID = 0; 453eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 454eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (drv->renderTargetID) { 4552382aba4a55c6ae74789c478eead8fbd96593321Jason Sams RSD_CALL_GL(glDeleteRenderbuffers, 1, &drv->renderTargetID); 456eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->renderTargetID = 0; 457eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 45893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 459eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 460709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 4612e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray // don't free user-allocated ptrs 462c2cfe6abfc74befbaa4d2ca09024a27fbfb1f515Tim Murray if (!(drv->useUserProvidedPtr)) { 4632e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray free(alloc->mHal.drvState.lod[0].mallocPtr); 4642e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray } 465709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = NULL; 466eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 46793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams 46893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 469a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (drv->readBackFBO != NULL) { 470a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk delete drv->readBackFBO; 471a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO = NULL; 472a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 47310c9dd709f8b52213c6792961afa9c5de807db5cJason Sams 47410c9dd709f8b52213c6792961afa9c5de807db5cJason Sams if ((alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT) && 47510c9dd709f8b52213c6792961afa9c5de807db5cJason Sams (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT)) { 47610c9dd709f8b52213c6792961afa9c5de807db5cJason Sams 47710c9dd709f8b52213c6792961afa9c5de807db5cJason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 4783a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray ANativeWindow *nw = drv->wndSurface; 4793a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (nw) { 4803a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 4813a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray mapper.unlock(drv->wndBuffer->handle); 4823a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray int32_t r = nw->queueBuffer(nw, drv->wndBuffer, -1); 4833a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 48410c9dd709f8b52213c6792961afa9c5de807db5cJason Sams } 48593eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 48693eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams 487eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams free(drv); 488eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->mHal.drv = NULL; 489eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 490eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 491eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationResize(const Context *rsc, const Allocation *alloc, 492eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const Type *newType, bool zeroNew) { 493a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams const uint32_t oldDimX = alloc->mHal.drvState.lod[0].dimX; 494a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams const uint32_t dimX = newType->getDimX(); 495a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams 4969e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray // can't resize Allocations with user-allocated buffers 4979e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SHARED) { 4989e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray ALOGE("Resize cannot be called on a USAGE_SHARED allocation"); 4999e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray return; 5009e2bda58db9e6427a1640ea302d4df079ffa0252Tim Murray } 501709a0978ae141198018ca9769f8d96292a8928e6Jason Sams void * oldPtr = alloc->mHal.drvState.lod[0].mallocPtr; 502463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Calculate the object size 503463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t s = AllocationBuildPointerTable(rsc, alloc, newType, NULL); 504463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams uint8_t *ptr = (uint8_t *)realloc(oldPtr, s); 505463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams // Build the relative pointer tables. 506463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams size_t verifySize = AllocationBuildPointerTable(rsc, alloc, newType, ptr); 507463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams if(s != verifySize) { 508463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams rsAssert(!"Size mismatch"); 509463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams } 510eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 511eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 512eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (dimX > oldDimX) { 513463bfced38d97605dd8403a5e9435d9ad3394e35Jason Sams uint32_t stride = alloc->mHal.state.elementSizeBytes; 514709a0978ae141198018ca9769f8d96292a8928e6Jason Sams memset(((uint8_t *)alloc->mHal.drvState.lod[0].mallocPtr) + stride * oldDimX, 5152275e9cf534ff601fe42a72ff50580b230c04fe2Jason Sams 0, stride * (dimX - oldDimX)); 516eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 517eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 518eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 519a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchoukstatic void rsdAllocationSyncFromFBO(const Context *rsc, const Allocation *alloc) { 52093eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 521a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (!alloc->getIsScript()) { 522a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk return; // nothing to sync 523a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 524a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 525a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsdHal *dc = (RsdHal *)rsc->mHal.drv; 526a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsdFrameBufferObj *lastFbo = dc->gl.currentFrameBuffer; 527a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 528a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 529a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (!drv->textureID && !drv->renderTargetID) { 530a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk return; // nothing was rendered here yet, so nothing to sync 531a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 532a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (drv->readBackFBO == NULL) { 533a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO = new RsdFrameBufferObj(); 534a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO->setColorTarget(drv, 0); 535a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO->setDimensions(alloc->getType()->getDimX(), 536a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk alloc->getType()->getDimY()); 537a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 538a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 539a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk // Bind the framebuffer object so we can read back from it 540a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk drv->readBackFBO->setActive(rsc); 541a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 542a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk // Do the readback 543709a0978ae141198018ca9769f8d96292a8928e6Jason Sams RSD_CALL_GL(glReadPixels, 0, 0, alloc->mHal.drvState.lod[0].dimX, 544709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].dimY, 545709a0978ae141198018ca9769f8d96292a8928e6Jason Sams drv->glFormat, drv->glType, alloc->mHal.drvState.lod[0].mallocPtr); 546a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 547a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk // Revert framebuffer to its original 548a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk lastFbo->setActive(rsc); 54993eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 550a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk} 551eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 552eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 553eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationSyncAll(const Context *rsc, const Allocation *alloc, 554eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams RsAllocationUsageType src) { 555eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 556eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 557a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (src == RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 558a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if(!alloc->getIsRenderTarget()) { 559a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsc->setError(RS_ERROR_FATAL_DRIVER, 560a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "Attempting to sync allocation from render target, " 561a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "for non-render target allocation"); 562a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } else if (alloc->getType()->getElement()->getKind() != RS_KIND_PIXEL_RGBA) { 563a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsc->setError(RS_ERROR_FATAL_DRIVER, "Cannot only sync from RGBA" 564a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "render target"); 565a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } else { 566a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsdAllocationSyncFromFBO(rsc, alloc); 567a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 568eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return; 569eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 570eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 571eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsAssert(src == RS_ALLOCATION_USAGE_SCRIPT); 572eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 573eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) { 574eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams UploadToTexture(rsc, alloc); 575eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 576b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if ((alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) && 5770dc66936c02f285a242b6a68166d6f03618a0f07Jason Sams !(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT)) { 578eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams AllocateRenderTarget(rsc, alloc); 579eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 580eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 581eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) { 582eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams UploadToBufferObject(rsc, alloc); 583eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 584eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 585eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = false; 586eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 587eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 588eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationMarkDirty(const Context *rsc, const Allocation *alloc) { 589eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 590eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 591eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 592eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 593733396b67724162844ea2785c7495115dc5ee8d8Jason Samsvoid* rsdAllocationGetSurface(const Context *rsc, const Allocation *alloc) { 59493eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 59541e373d91a60043afa0f9abd026218b49cbc1201Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 596733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 597733396b67724162844ea2785c7495115dc5ee8d8Jason Sams drv->cpuConsumer = new CpuConsumer(2); 598733396b67724162844ea2785c7495115dc5ee8d8Jason Sams sp<IGraphicBufferProducer> bp = drv->cpuConsumer->getProducerInterface(); 599733396b67724162844ea2785c7495115dc5ee8d8Jason Sams bp->incStrong(NULL); 600733396b67724162844ea2785c7495115dc5ee8d8Jason Sams return bp.get(); 60193eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#else 602733396b67724162844ea2785c7495115dc5ee8d8Jason Sams return NULL; 60393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 60441e373d91a60043afa0f9abd026218b49cbc1201Jason Sams} 60541e373d91a60043afa0f9abd026218b49cbc1201Jason Sams 60693eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 6077ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsstatic bool IoGetBuffer(const Context *rsc, Allocation *alloc, ANativeWindow *nw) { 6087ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 6097ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 610cd919a177f2b25af1b304dd4d79f0a768fed342fJamie Gennis int32_t r = native_window_dequeue_buffer_and_wait(nw, &drv->wndBuffer); 6117ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 6127ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error getting next IO output buffer."); 6137ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return false; 6147ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6157ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6167ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams // Must lock the whole surface 6177ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 6187ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams Rect bounds(drv->wndBuffer->width, drv->wndBuffer->height); 6197ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6207ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams void *dst = NULL; 6217ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams mapper.lock(drv->wndBuffer->handle, 6227ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN, 6237ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams bounds, &dst); 624709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = dst; 625709a0978ae141198018ca9769f8d96292a8928e6Jason Sams alloc->mHal.drvState.lod[0].stride = drv->wndBuffer->stride * alloc->mHal.state.elementSizeBytes; 62694999c3c7e3dcb6b6c0a9fe5785a0d3216357b0eStephen Hines rsAssert((alloc->mHal.drvState.lod[0].stride & 0xf) == 0); 627b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 6287ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return true; 6297ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 63093eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 6317ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 632733396b67724162844ea2785c7495115dc5ee8d8Jason Samsvoid rsdAllocationSetSurface(const Context *rsc, Allocation *alloc, ANativeWindow *nw) { 63393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 6347ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 6353a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray ANativeWindow *old = drv->wndSurface; 6363a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 6373a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (nw) { 6383a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray nw->incStrong(NULL); 6393a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 6407ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 641b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 642b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams //TODO finish support for render target + script 643b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams drv->wnd = nw; 644b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams return; 645b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 646b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 6477ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams // Cleanup old surface if there is one. 6483a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (drv->wndSurface) { 6493a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray ANativeWindow *old = drv->wndSurface; 6507ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 6517ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams mapper.unlock(drv->wndBuffer->handle); 6523a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray old->cancelBuffer(old, drv->wndBuffer, -1); 6533a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray drv->wndSurface = NULL; 6543a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray old->decStrong(NULL); 6557ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6567ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6577ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (nw != NULL) { 6587ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams int32_t r; 659b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams uint32_t flags = 0; 6603a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray r = native_window_set_buffer_count(nw, 3); 6613a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (r) { 6623a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer count."); 6633a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray goto error; 6643a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 6653a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 666b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 667b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams flags |= GRALLOC_USAGE_SW_READ_RARELY | GRALLOC_USAGE_SW_WRITE_OFTEN; 668b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 669b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 670b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams flags |= GRALLOC_USAGE_HW_RENDER; 671b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 672b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams 673b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams r = native_window_set_usage(nw, flags); 6747ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 6757ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer usage."); 6763a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray goto error; 6777ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6787ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 679a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams r = native_window_set_buffers_dimensions(nw, alloc->mHal.drvState.lod[0].dimX, 680a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams alloc->mHal.drvState.lod[0].dimY); 6817ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams if (r) { 6827ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer dimensions."); 6833a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray goto error; 6847ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 6857ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 686733396b67724162844ea2785c7495115dc5ee8d8Jason Sams int format = 0; 687733396b67724162844ea2785c7495115dc5ee8d8Jason Sams const Element *e = alloc->mHal.state.type->getElement(); 688733396b67724162844ea2785c7495115dc5ee8d8Jason Sams switch(e->getType()) { 689733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case RS_TYPE_UNSIGNED_8: 690733396b67724162844ea2785c7495115dc5ee8d8Jason Sams switch (e->getVectorSize()) { 691733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case 1: 692733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(e->getKind() == RS_KIND_PIXEL_A); 693733396b67724162844ea2785c7495115dc5ee8d8Jason Sams format = PIXEL_FORMAT_A_8; 694733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 695733396b67724162844ea2785c7495115dc5ee8d8Jason Sams case 4: 696733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(e->getKind() == RS_KIND_PIXEL_RGBA); 697733396b67724162844ea2785c7495115dc5ee8d8Jason Sams format = PIXEL_FORMAT_RGBA_8888; 698733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 699733396b67724162844ea2785c7495115dc5ee8d8Jason Sams default: 700733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(0); 701733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 702733396b67724162844ea2785c7495115dc5ee8d8Jason Sams break; 703733396b67724162844ea2785c7495115dc5ee8d8Jason Sams default: 704733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsAssert(0); 705733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 706733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 707733396b67724162844ea2785c7495115dc5ee8d8Jason Sams r = native_window_set_buffers_format(nw, format); 708733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (r) { 709733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsc->setError(RS_ERROR_DRIVER, "Error setting IO output buffer format."); 7103a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray goto error; 7117ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 7127ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7137ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams IoGetBuffer(rsc, alloc, nw); 7143a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray drv->wndSurface = nw; 7153a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 7163a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 7173a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray return; 7183a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 7193a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray error: 7203a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 7213a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (nw) { 7223a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray nw->decStrong(NULL); 7237ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 7243a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 7253a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray 72693eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 7277ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 7287ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7297ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid rsdAllocationIoSend(const Context *rsc, Allocation *alloc) { 73093eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 7317ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 7323a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray ANativeWindow *nw = drv->wndSurface; 733b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 734b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams RsdHal *dc = (RsdHal *)rsc->mHal.drv; 735b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams RSD_CALL_GL(eglSwapBuffers, dc->gl.egl.display, dc->gl.egl.surface); 7367ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams return; 7377ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams } 7383a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (nw) { 7393a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 7403a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray GraphicBufferMapper &mapper = GraphicBufferMapper::get(); 7413a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray mapper.unlock(drv->wndBuffer->handle); 7423a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray int32_t r = nw->queueBuffer(nw, drv->wndBuffer, -1); 7433a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray if (r) { 7443a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray rsc->setError(RS_ERROR_DRIVER, "Error sending IO output buffer."); 7453a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray return; 7463a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } 7477ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7483a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray IoGetBuffer(rsc, alloc, nw); 749b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 7503a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray } else { 7513a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray rsc->setError(RS_ERROR_DRIVER, "Sent IO buffer with no attached surface."); 7523a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray return; 753b322033c13487a174bb9c26466e9684d1ff4de8dJason Sams } 75493eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 7557ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 7567ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7577ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid rsdAllocationIoReceive(const Context *rsc, Allocation *alloc) { 75893eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 7593522f40418fdf877f5a136475dbf75e57a3b7c77Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 760733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 761733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 762733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (drv->lb.data != NULL) { 763733396b67724162844ea2785c7495115dc5ee8d8Jason Sams drv->cpuConsumer->unlockBuffer(drv->lb); 764733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 765733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 766733396b67724162844ea2785c7495115dc5ee8d8Jason Sams status_t ret = drv->cpuConsumer->lockNextBuffer(&drv->lb); 767733396b67724162844ea2785c7495115dc5ee8d8Jason Sams alloc->mHal.drvState.lod[0].mallocPtr = drv->lb.data; 768733396b67724162844ea2785c7495115dc5ee8d8Jason Sams alloc->mHal.drvState.lod[0].stride = drv->lb.stride * alloc->mHal.state.elementSizeBytes; 769733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 770733396b67724162844ea2785c7495115dc5ee8d8Jason Sams if (alloc->mHal.state.yuv) { 771733396b67724162844ea2785c7495115dc5ee8d8Jason Sams DeriveYUVLayout(alloc->mHal.state.yuv, &alloc->mHal.drvState); 772733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 773733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 774733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } else { 7753a25fdd3786c1a08b783d8a83ef94b756347ff5cTim Murray drv->surfaceTexture->updateTexImage(); 776733396b67724162844ea2785c7495115dc5ee8d8Jason Sams } 777733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 778733396b67724162844ea2785c7495115dc5ee8d8Jason Sams 77993eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 7807ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 7817ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 7827ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 783eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationData1D(const Context *rsc, const Allocation *alloc, 784eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t xoff, uint32_t lod, uint32_t count, 785c794cd56e46408e08862c42a022090e323684197Alex Sakhartchouk const void *data, size_t sizeBytes) { 786eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 787eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 788eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes(); 789807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 790eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t size = count * eSize; 791eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 79220c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (ptr != data) { 79320c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 79420c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 79520c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (alloc->mHal.state.hasReferences) { 79620c535f54fb41348a96af98079ad377d7a310c8aStephen Hines alloc->incRefs(data, count); 79720c535f54fb41348a96af98079ad377d7a310c8aStephen Hines alloc->decRefs(ptr, count); 79820c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 79920c535f54fb41348a96af98079ad377d7a310c8aStephen Hines memcpy(ptr, data, size); 800eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 801eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 802eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 803eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 804eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationData2D(const Context *rsc, const Allocation *alloc, 805eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 806358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t w, uint32_t h, const void *data, size_t sizeBytes, size_t stride) { 807eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 808eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 809eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 810eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t lineSize = eSize * w; 811358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray if (!stride) { 812358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray stride = lineSize; 813358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray } 814eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 815709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 816eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const uint8_t *src = static_cast<const uint8_t *>(data); 817807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *dst = GetOffsetPtr(alloc, xoff, yoff, lod, face); 81820c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (dst == src) { 81920c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 82020c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 82120c535f54fb41348a96af98079ad377d7a310c8aStephen Hines drv->uploadDeferred = true; 82220c535f54fb41348a96af98079ad377d7a310c8aStephen Hines return; 82320c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 824eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 825eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams for (uint32_t line=yoff; line < (yoff+h); line++) { 826eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasReferences) { 827eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->incRefs(src, w); 828eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams alloc->decRefs(dst, w); 829eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 830eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memcpy(dst, src, lineSize); 831358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray src += stride; 832709a0978ae141198018ca9769f8d96292a8928e6Jason Sams dst += alloc->mHal.drvState.lod[lod].stride; 833eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 834bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams if (alloc->mHal.state.yuv) { 835bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams int lod = 1; 836bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams while (alloc->mHal.drvState.lod[lod].mallocPtr) { 837bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams uint32_t lineSize = alloc->mHal.drvState.lod[lod].dimX; 838bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams uint8_t *dst = GetOffsetPtr(alloc, xoff, yoff, lod, face); 839bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams 840bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams for (uint32_t line=(yoff >> 1); line < ((yoff+h)>>1); line++) { 841bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams memcpy(dst, src, lineSize); 842bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams src += lineSize; 843bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams dst += alloc->mHal.drvState.lod[lod].stride; 844bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 845bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams lod++; 846bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 847bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams 848bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams } 849eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 850eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } else { 8512382aba4a55c6ae74789c478eead8fbd96593321Jason Sams Update2DTexture(rsc, alloc, data, xoff, yoff, lod, face, w, h); 852eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 853eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 854eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 855eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationData3D(const Context *rsc, const Allocation *alloc, 856eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t xoff, uint32_t yoff, uint32_t zoff, 857eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t lod, RsAllocationCubemapFace face, 858eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t w, uint32_t h, uint32_t d, const void *data, uint32_t sizeBytes) { 859eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 860eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 861eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 862807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationRead1D(const Context *rsc, const Allocation *alloc, 863807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t xoff, uint32_t lod, uint32_t count, 864807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams void *data, size_t sizeBytes) { 865807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes(); 866807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 86720c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (data != ptr) { 86820c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 86920c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 87020c535f54fb41348a96af98079ad377d7a310c8aStephen Hines memcpy(data, ptr, count * eSize); 87120c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 872807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 873807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 874807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationRead2D(const Context *rsc, const Allocation *alloc, 875358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 876358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t w, uint32_t h, void *data, size_t sizeBytes, size_t stride) { 877807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 878807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t lineSize = eSize * w; 879358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray if (!stride) { 880358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray stride = lineSize; 881358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray } 882807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 883709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if (alloc->mHal.drvState.lod[0].mallocPtr) { 884807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *dst = static_cast<uint8_t *>(data); 885807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const uint8_t *src = GetOffsetPtr(alloc, xoff, yoff, lod, face); 88620c535f54fb41348a96af98079ad377d7a310c8aStephen Hines if (dst == src) { 88720c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // Skip the copy if we are the same allocation. This can arise from 88820c535f54fb41348a96af98079ad377d7a310c8aStephen Hines // our Bitmap optimization, where we share the same storage. 88920c535f54fb41348a96af98079ad377d7a310c8aStephen Hines return; 89020c535f54fb41348a96af98079ad377d7a310c8aStephen Hines } 891807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 892807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams for (uint32_t line=yoff; line < (yoff+h); line++) { 893807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams memcpy(dst, src, lineSize); 894358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray dst += stride; 895709a0978ae141198018ca9769f8d96292a8928e6Jason Sams src += alloc->mHal.drvState.lod[lod].stride; 896807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 897807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } else { 898807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams ALOGE("Add code to readback from non-script memory"); 899807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 900807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 901807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 902358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray 903807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationRead3D(const Context *rsc, const Allocation *alloc, 904807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t xoff, uint32_t yoff, uint32_t zoff, 905807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t lod, RsAllocationCubemapFace face, 906807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint32_t w, uint32_t h, uint32_t d, void *data, uint32_t sizeBytes) { 907807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 908807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 909807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 910807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid * rsdAllocationLock1D(const android::renderscript::Context *rsc, 911807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const android::renderscript::Allocation *alloc) { 912709a0978ae141198018ca9769f8d96292a8928e6Jason Sams return alloc->mHal.drvState.lod[0].mallocPtr; 913807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 914807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 915807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsdAllocationUnlock1D(const android::renderscript::Context *rsc, 916807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const android::renderscript::Allocation *alloc) { 917807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 918807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 919807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 92074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsdAllocationData1D_alloc(const android::renderscript::Context *rsc, 92174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 92274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstLod, uint32_t count, 92374a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 924a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t srcXoff, uint32_t srcLod) { 925a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk} 926a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 927a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 928a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchoukvoid rsdAllocationData2D_alloc_script(const android::renderscript::Context *rsc, 929a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 930a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod, 931a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h, 932a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 933a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod, 934a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk RsAllocationCubemapFace srcFace) { 935a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk uint32_t elementSize = dstAlloc->getType()->getElementSizeBytes(); 936a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk for (uint32_t i = 0; i < h; i ++) { 937807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *dstPtr = GetOffsetPtr(dstAlloc, dstXoff, dstYoff + i, dstLod, dstFace); 938807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t *srcPtr = GetOffsetPtr(srcAlloc, srcXoff, srcYoff + i, srcLod, srcFace); 939a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk memcpy(dstPtr, srcPtr, w * elementSize); 940a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk 941af12ac6a08651464f8d823add667c706f993b587Steve Block //ALOGE("COPIED dstXoff(%u), dstYoff(%u), dstLod(%u), dstFace(%u), w(%u), h(%u), srcXoff(%u), srcYoff(%u), srcLod(%u), srcFace(%u)", 9420a44ab45c739f00f457874418e7384492e4df979Stephen Hines // dstXoff, dstYoff, dstLod, dstFace, w, h, srcXoff, srcYoff, srcLod, srcFace); 943a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 94474a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 94574a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 94674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsdAllocationData2D_alloc(const android::renderscript::Context *rsc, 94774a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 94874a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod, 94974a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h, 95074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 95174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod, 95274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk RsAllocationCubemapFace srcFace) { 953a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk if (!dstAlloc->getIsScript() && !srcAlloc->getIsScript()) { 954a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsc->setError(RS_ERROR_FATAL_DRIVER, "Non-script allocation copies not " 955a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk "yet implemented."); 956a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk return; 957a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk } 958a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk rsdAllocationData2D_alloc_script(rsc, dstAlloc, dstXoff, dstYoff, 959a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk dstLod, dstFace, w, h, srcAlloc, 960a94952436aeb251f587c1bccdf94c7f75285dfe2Alex Sakhartchouk srcXoff, srcYoff, srcLod, srcFace); 96174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 96274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 96374a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsdAllocationData3D_alloc(const android::renderscript::Context *rsc, 96474a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *dstAlloc, 96574a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff, 96674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstLod, RsAllocationCubemapFace dstFace, 96774a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t w, uint32_t h, uint32_t d, 96874a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk const android::renderscript::Allocation *srcAlloc, 96974a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, 97074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcLod, RsAllocationCubemapFace srcFace) { 97174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 97274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 973eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationElementData1D(const Context *rsc, const Allocation *alloc, 974eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t x, 975eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const void *data, uint32_t cIdx, uint32_t sizeBytes) { 976eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 977eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 978eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 979807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = GetOffsetPtr(alloc, x, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 980eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 981eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx); 982eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx); 983eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 984eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasReferences) { 985eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->incRefs(data); 986eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->decRefs(ptr); 987eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 988eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 989eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memcpy(ptr, data, sizeBytes); 990eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 991eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 992eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 993eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid rsdAllocationElementData2D(const Context *rsc, const Allocation *alloc, 994eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t x, uint32_t y, 995eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const void *data, uint32_t cIdx, uint32_t sizeBytes) { 996eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 997eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 998eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams uint32_t eSize = alloc->mHal.state.elementSizeBytes; 999807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams uint8_t * ptr = GetOffsetPtr(alloc, x, y, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 1000eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1001eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx); 1002eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx); 1003eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1004eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (alloc->mHal.state.hasReferences) { 1005eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->incRefs(data); 1006eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams e->decRefs(ptr); 1007eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 1008eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1009eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memcpy(ptr, data, sizeBytes); 1010eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams drv->uploadDeferred = true; 1011eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams} 1012eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 101361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsstatic void mip565(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 1014709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t w = alloc->mHal.drvState.lod[lod + 1].dimX; 1015709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t h = alloc->mHal.drvState.lod[lod + 1].dimY; 101661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 101761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t y=0; y < h; y++) { 101861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint16_t *oPtr = (uint16_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face); 101961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint16_t *i1 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2, lod, face); 102061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint16_t *i2 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face); 102161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 102261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t x=0; x < w; x++) { 102361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams *oPtr = rsBoxFilter565(i1[0], i1[1], i2[0], i2[1]); 102461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams oPtr ++; 102561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i1 += 2; 102661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i2 += 2; 102761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 102861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 102961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 103061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 103161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsstatic void mip8888(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 1032709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t w = alloc->mHal.drvState.lod[lod + 1].dimX; 1033709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t h = alloc->mHal.drvState.lod[lod + 1].dimY; 103461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 103561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t y=0; y < h; y++) { 103661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint32_t *oPtr = (uint32_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face); 103761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint32_t *i1 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2, lod, face); 103861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint32_t *i2 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face); 103961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 104061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t x=0; x < w; x++) { 104161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams *oPtr = rsBoxFilter8888(i1[0], i1[1], i2[0], i2[1]); 104261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams oPtr ++; 104361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i1 += 2; 104461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i2 += 2; 104561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 104661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 104761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 104861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 104961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsstatic void mip8(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 1050709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t w = alloc->mHal.drvState.lod[lod + 1].dimX; 1051709a0978ae141198018ca9769f8d96292a8928e6Jason Sams uint32_t h = alloc->mHal.drvState.lod[lod + 1].dimY; 105261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 105361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t y=0; y < h; y++) { 105461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint8_t *oPtr = GetOffsetPtr(alloc, 0, y, lod + 1, face); 105561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint8_t *i1 = GetOffsetPtr(alloc, 0, y*2, lod, face); 105661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint8_t *i2 = GetOffsetPtr(alloc, 0, y*2+1, lod, face); 105761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 105861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t x=0; x < w; x++) { 105961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams *oPtr = (uint8_t)(((uint32_t)i1[0] + i1[1] + i2[0] + i2[1]) * 0.25f); 106061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams oPtr ++; 106161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i1 += 2; 106261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams i2 += 2; 106361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 106461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 106561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 106661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 106761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Samsvoid rsdAllocationGenerateMipmaps(const Context *rsc, const Allocation *alloc) { 1068709a0978ae141198018ca9769f8d96292a8928e6Jason Sams if(!alloc->mHal.drvState.lod[0].mallocPtr) { 106961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams return; 107061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 107161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint32_t numFaces = alloc->getType()->getDimFaces() ? 6 : 1; 107261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t face = 0; face < numFaces; face ++) { 107361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams for (uint32_t lod=0; lod < (alloc->getType()->getLODCount() -1); lod++) { 107461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams switch (alloc->getType()->getElement()->getSizeBits()) { 107561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams case 32: 107661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mip8888(alloc, lod, (RsAllocationCubemapFace)face); 107761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams break; 107861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams case 16: 107961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mip565(alloc, lod, (RsAllocationCubemapFace)face); 108061a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams break; 108161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams case 8: 108261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mip8(alloc, lod, (RsAllocationCubemapFace)face); 108361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams break; 108461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 108561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 108661a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams } 108761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams} 108861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams 1089eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 1090