10f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines/* 20f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * Copyright (C) 2011-2012 The Android Open Source Project 30f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * 40f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * Licensed under the Apache License, Version 2.0 (the "License"); 50f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * you may not use this file except in compliance with the License. 60f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * You may obtain a copy of the License at 70f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * 80f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * http://www.apache.org/licenses/LICENSE-2.0 90f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * 100f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * Unless required by applicable law or agreed to in writing, software 110f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * distributed under the License is distributed on an "AS IS" BASIS, 120f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 130f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * See the License for the specific language governing permissions and 140f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines * limitations under the License. 150f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines */ 160f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 170f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 180f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines#include "rsdCore.h" 190f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines#include "rsdBcc.h" 200f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines#include "rsdRuntime.h" 210f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines#include "rsdAllocation.h" 2233b0a9fe4f0fc7bd26378420af259d24036caa22Stephen Hines//#include "rsdFrameBufferObj.h" 230f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 240f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines#include "rsAllocation.h" 250f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 260f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines#include "system/window.h" 276e127d6c76f02024ef906c9a450a9b2d80657566Stephen Hines/*#include "hardware/gralloc.h" 280f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines#include "ui/Rect.h" 290f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines#include "ui/GraphicBufferMapper.h" 306e127d6c76f02024ef906c9a450a9b2d80657566Stephen Hines#include "gui/SurfaceTexture.h"*/ 310f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3233b0a9fe4f0fc7bd26378420af259d24036caa22Stephen Hines//#include <GLES/gl.h> 3333b0a9fe4f0fc7bd26378420af259d24036caa22Stephen Hines//#include <GLES2/gl2.h> 3433b0a9fe4f0fc7bd26378420af259d24036caa22Stephen Hines//#include <GLES/glext.h> 350f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 360f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesusing namespace android; 370f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesusing namespace android::renderscript; 380f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 390f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 400f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesuint8_t *GetOffsetPtr(const android::renderscript::Allocation *alloc, 410f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t xoff, uint32_t yoff, uint32_t lod, 420f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines RsAllocationCubemapFace face) { 430f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 440f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t *ptr = (uint8_t *)drv->lod[lod].mallocPtr; 450f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines ptr += face * drv->faceOffset; 460f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines ptr += yoff * drv->lod[lod].stride; 470f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines ptr += xoff * alloc->mHal.state.elementSizeBytes; 480f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines return ptr; 490f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 500f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 510f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 520f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesstatic void Update2DTexture(const Context *rsc, const Allocation *alloc, const void *ptr, 530f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t xoff, uint32_t yoff, uint32_t lod, 540f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines RsAllocationCubemapFace face, uint32_t w, uint32_t h) { 550f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 560f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 570f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 580f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesstatic void UploadToTexture(const Context *rsc, const Allocation *alloc) { 590f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 600f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 610f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesstatic void AllocateRenderTarget(const Context *rsc, const Allocation *alloc) { 620f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 630f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 640f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesstatic void UploadToBufferObject(const Context *rsc, const Allocation *alloc) { 650f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 660f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 67ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Samsstatic size_t AllocationBuildPointerTable(const Context *rsc, const Allocation *alloc, 68ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams const Type *type, uint8_t *ptr) { 690f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 70ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 71ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams 72ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->lod[0].dimX = type->getDimX(); 73ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->lod[0].dimY = type->getDimY(); 740f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->lod[0].mallocPtr = 0; 75ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->lod[0].stride = drv->lod[0].dimX * type->getElementSizeBytes(); 76ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->lodCount = type->getLODCount(); 77ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->faceCount = type->getDimFaces(); 780f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 790f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines size_t offsets[Allocation::MAX_LOD]; 800f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memset(offsets, 0, sizeof(offsets)); 810f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 820f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines size_t o = drv->lod[0].stride * rsMax(drv->lod[0].dimY, 1u) * rsMax(drv->lod[0].dimZ, 1u); 830f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if(drv->lodCount > 1) { 840f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t tx = drv->lod[0].dimX; 850f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t ty = drv->lod[0].dimY; 860f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t tz = drv->lod[0].dimZ; 870f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t lod=1; lod < drv->lodCount; lod++) { 880f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->lod[lod].dimX = tx; 890f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->lod[lod].dimY = ty; 900f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->lod[lod].dimZ = tz; 91ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->lod[lod].stride = tx * type->getElementSizeBytes(); 920f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines offsets[lod] = o; 930f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines o += drv->lod[lod].stride * rsMax(ty, 1u) * rsMax(tz, 1u); 940f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (tx > 1) tx >>= 1; 950f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (ty > 1) ty >>= 1; 960f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (tz > 1) tz >>= 1; 970f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 980f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 990f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->faceOffset = o; 1000f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 101ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->lod[0].mallocPtr = ptr; 102ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams for (uint32_t lod=1; lod < drv->lodCount; lod++) { 103ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->lod[lod].mallocPtr = ptr + offsets[lod]; 104ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams } 105ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams alloc->mHal.drvState.strideLOD0 = drv->lod[0].stride; 106ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams alloc->mHal.drvState.mallocPtrLOD0 = ptr; 107ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams 108ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams size_t allocSize = drv->faceOffset; 109ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams if(drv->faceCount) { 110ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams allocSize *= 6; 111ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams } 112ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams 113ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams return allocSize; 114ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams} 115ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams 116ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Samsbool rsdAllocationInit(const Context *rsc, Allocation *alloc, bool forceZero) { 117ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams DrvAllocation *drv = (DrvAllocation *)calloc(1, sizeof(DrvAllocation)); 118ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams if (!drv) { 119ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams return false; 120ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams } 121ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams alloc->mHal.drv = drv; 122ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams 123ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams // Calculate the object size. 124ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams size_t allocSize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), NULL); 125ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams 126ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams ALOGE("alloc usage %i", alloc->mHal.state.usageFlags); 127ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams 1280f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t * ptr = NULL; 1290f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT) { 1300f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } else { 1310f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1320f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines ptr = (uint8_t *)malloc(allocSize); 1330f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (!ptr) { 1340f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines free(drv); 1350f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines return false; 1360f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 1370f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 138ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams // Build the pointer tables 139ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams size_t verifySize = AllocationBuildPointerTable(rsc, alloc, alloc->getType(), ptr); 140ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams if(allocSize != verifySize) { 141ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams rsAssert(!"Size mismatch"); 1420f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 1430f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1440f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->glTarget = GL_NONE; 1450f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) { 1460f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.hasFaces) { 1470f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->glTarget = GL_TEXTURE_CUBE_MAP; 1480f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } else { 1490f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->glTarget = GL_TEXTURE_2D; 1500f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 1510f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } else { 1520f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) { 1530f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->glTarget = GL_ARRAY_BUFFER; 1540f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 1550f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 1560f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 157ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->glType = 0; 158ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams drv->glFormat = 0; 1590f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1600f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (forceZero && ptr) { 1610f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memset(ptr, 0, alloc->mHal.state.type->getSizeBytes()); 1620f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 1630f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1640f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.usageFlags & ~RS_ALLOCATION_USAGE_SCRIPT) { 1650f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->uploadDeferred = true; 1660f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 1670f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1680f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1690f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->readBackFBO = NULL; 1700f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1710f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines return true; 1720f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 1730f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1740f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationDestroy(const Context *rsc, Allocation *alloc) { 1750f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 1760f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1770f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.drvState.mallocPtrLOD0) { 1780f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines free(alloc->mHal.drvState.mallocPtrLOD0); 1790f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines alloc->mHal.drvState.mallocPtrLOD0 = NULL; 1800f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 1810f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines free(drv); 1820f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines alloc->mHal.drv = NULL; 1830f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 1840f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1850f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationResize(const Context *rsc, const Allocation *alloc, 1860f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const Type *newType, bool zeroNew) { 1870f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 1880f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 189ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams void * oldPtr = drv->lod[0].mallocPtr; 190ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams // Calculate the object size 191ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams size_t s = AllocationBuildPointerTable(rsc, alloc, newType, NULL); 192ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams uint8_t *ptr = (uint8_t *)realloc(oldPtr, s); 193ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams // Build the relative pointer tables. 194ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams size_t verifySize = AllocationBuildPointerTable(rsc, alloc, newType, ptr); 195ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams if(s != verifySize) { 196ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams rsAssert(!"Size mismatch"); 197ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams } 1980f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 1990f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint32_t oldDimX = alloc->mHal.state.dimensionX; 2000f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint32_t dimX = newType->getDimX(); 2010f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2020f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (dimX > oldDimX) { 203ca29b8caf56fa4866752f9cea4ec02b2a271dceeJason Sams uint32_t stride = alloc->mHal.state.elementSizeBytes; 2040f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memset(((uint8_t *)alloc->mHal.drvState.mallocPtrLOD0) + stride * oldDimX, 2050f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 0, stride * (dimX - oldDimX)); 2060f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 2070f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 2080f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2090f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesstatic void rsdAllocationSyncFromFBO(const Context *rsc, const Allocation *alloc) { 2100f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 2110f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2120f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2130f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationSyncAll(const Context *rsc, const Allocation *alloc, 2140f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines RsAllocationUsageType src) { 2150f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 2160f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2170f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (src == RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) { 2180f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if(!alloc->getIsRenderTarget()) { 2190f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines rsc->setError(RS_ERROR_FATAL_DRIVER, 2200f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines "Attempting to sync allocation from render target, " 2210f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines "for non-render target allocation"); 2220f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } else if (alloc->getType()->getElement()->getKind() != RS_KIND_PIXEL_RGBA) { 2230f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines rsc->setError(RS_ERROR_FATAL_DRIVER, "Cannot only sync from RGBA" 2240f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines "render target"); 2250f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } else { 2260f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines rsdAllocationSyncFromFBO(rsc, alloc); 2270f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 2280f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines return; 2290f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 2300f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2310f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines rsAssert(src == RS_ALLOCATION_USAGE_SCRIPT); 2320f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2330f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_TEXTURE) { 2340f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines UploadToTexture(rsc, alloc); 2350f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } else { 2360f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if ((alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_RENDER_TARGET) && 2370f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines !(alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_IO_OUTPUT)) { 2380f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines AllocateRenderTarget(rsc, alloc); 2390f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 2400f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 2410f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.usageFlags & RS_ALLOCATION_USAGE_GRAPHICS_VERTEX) { 2420f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines UploadToBufferObject(rsc, alloc); 2430f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 2440f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2450f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->uploadDeferred = false; 2460f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 2470f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2480f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationMarkDirty(const Context *rsc, const Allocation *alloc) { 2490f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 2500f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->uploadDeferred = true; 2510f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 2520f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2530f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesint32_t rsdAllocationInitSurfaceTexture(const Context *rsc, const Allocation *alloc) { 2546e127d6c76f02024ef906c9a450a9b2d80657566Stephen Hines return 0; 2550f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 2560f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2570f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationSetSurfaceTexture(const Context *rsc, Allocation *alloc, ANativeWindow *nw) { 2580f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 2590f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2600f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationIoSend(const Context *rsc, Allocation *alloc) { 2610f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 2620f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2630f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationIoReceive(const Context *rsc, Allocation *alloc) { 2640f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 2650f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2660f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2670f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationData1D(const Context *rsc, const Allocation *alloc, 2680f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t xoff, uint32_t lod, uint32_t count, 2690f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const void *data, size_t sizeBytes) { 2700f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 2710f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2720f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes(); 2730f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 2740f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t size = count * eSize; 2750f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2760f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.hasReferences) { 2770f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines alloc->incRefs(data, count); 2780f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines alloc->decRefs(ptr, count); 2790f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 2800f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2810f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memcpy(ptr, data, size); 2820f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->uploadDeferred = true; 2830f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 2840f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2850f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationData2D(const Context *rsc, const Allocation *alloc, 2860f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 2870f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t w, uint32_t h, const void *data, size_t sizeBytes) { 2880f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 2890f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2900f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t eSize = alloc->mHal.state.elementSizeBytes; 2910f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t lineSize = eSize * w; 2920f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2930f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (drv->lod[0].mallocPtr) { 2940f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint8_t *src = static_cast<const uint8_t *>(data); 2950f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t *dst = GetOffsetPtr(alloc, xoff, yoff, lod, face); 2960f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 2970f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t line=yoff; line < (yoff+h); line++) { 2980f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.hasReferences) { 2990f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines alloc->incRefs(src, w); 3000f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines alloc->decRefs(dst, w); 3010f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 3020f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memcpy(dst, src, lineSize); 3030f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines src += lineSize; 3040f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines dst += drv->lod[lod].stride; 3050f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 3060f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->uploadDeferred = true; 3070f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } else { 3080f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines Update2DTexture(rsc, alloc, data, xoff, yoff, lod, face, w, h); 3090f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 3100f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 3110f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3120f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationData3D(const Context *rsc, const Allocation *alloc, 3130f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t xoff, uint32_t yoff, uint32_t zoff, 3140f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t lod, RsAllocationCubemapFace face, 3150f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t w, uint32_t h, uint32_t d, const void *data, uint32_t sizeBytes) { 3160f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3170f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 3180f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3190f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationRead1D(const Context *rsc, const Allocation *alloc, 3200f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t xoff, uint32_t lod, uint32_t count, 3210f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines void *data, size_t sizeBytes) { 3220f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 3230f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3240f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint32_t eSize = alloc->mHal.state.type->getElementSizeBytes(); 3250f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint8_t * ptr = GetOffsetPtr(alloc, xoff, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 3260f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memcpy(data, ptr, count * eSize); 3270f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 3280f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3290f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationRead2D(const Context *rsc, const Allocation *alloc, 3300f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 3310f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t w, uint32_t h, void *data, size_t sizeBytes) { 3320f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 3330f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3340f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t eSize = alloc->mHal.state.elementSizeBytes; 3350f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t lineSize = eSize * w; 3360f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3370f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (drv->lod[0].mallocPtr) { 3380f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t *dst = static_cast<uint8_t *>(data); 3390f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint8_t *src = GetOffsetPtr(alloc, xoff, yoff, lod, face); 3400f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3410f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t line=yoff; line < (yoff+h); line++) { 3420f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memcpy(dst, src, lineSize); 3430f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines dst += lineSize; 3440f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines src += drv->lod[lod].stride; 3450f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 3460f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } else { 3470f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines ALOGE("Add code to readback from non-script memory"); 3480f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 3490f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 3500f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3510f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationRead3D(const Context *rsc, const Allocation *alloc, 3520f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t xoff, uint32_t yoff, uint32_t zoff, 3530f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t lod, RsAllocationCubemapFace face, 3540f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t w, uint32_t h, uint32_t d, void *data, uint32_t sizeBytes) { 3550f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3560f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 3570f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3580f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid * rsdAllocationLock1D(const android::renderscript::Context *rsc, 3590f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *alloc) { 3600f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 3610f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines return drv->lod[0].mallocPtr; 3620f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 3630f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3640f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationUnlock1D(const android::renderscript::Context *rsc, 3650f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *alloc) { 3660f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3670f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 3680f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3690f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationData1D_alloc(const android::renderscript::Context *rsc, 3700f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *dstAlloc, 3710f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t dstXoff, uint32_t dstLod, uint32_t count, 3720f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *srcAlloc, 3730f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t srcXoff, uint32_t srcLod) { 3740f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 3750f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3760f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3770f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationData2D_alloc_script(const android::renderscript::Context *rsc, 3780f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *dstAlloc, 3790f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod, 3800f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h, 3810f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *srcAlloc, 3820f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod, 3830f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines RsAllocationCubemapFace srcFace) { 3840f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t elementSize = dstAlloc->getType()->getElementSizeBytes(); 3850f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t i = 0; i < h; i ++) { 3860f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t *dstPtr = GetOffsetPtr(dstAlloc, dstXoff, dstYoff + i, dstLod, dstFace); 3870f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t *srcPtr = GetOffsetPtr(srcAlloc, srcXoff, srcYoff + i, srcLod, srcFace); 3880f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memcpy(dstPtr, srcPtr, w * elementSize); 3890f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3900f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines //ALOGE("COPIED dstXoff(%u), dstYoff(%u), dstLod(%u), dstFace(%u), w(%u), h(%u), srcXoff(%u), srcYoff(%u), srcLod(%u), srcFace(%u)", 3910f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines // dstXoff, dstYoff, dstLod, dstFace, w, h, srcXoff, srcYoff, srcLod, srcFace); 3920f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 3930f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 3940f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 3950f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationData2D_alloc(const android::renderscript::Context *rsc, 3960f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *dstAlloc, 3970f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t dstXoff, uint32_t dstYoff, uint32_t dstLod, 3980f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines RsAllocationCubemapFace dstFace, uint32_t w, uint32_t h, 3990f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *srcAlloc, 4000f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t srcXoff, uint32_t srcYoff, uint32_t srcLod, 4010f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines RsAllocationCubemapFace srcFace) { 4020f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (!dstAlloc->getIsScript() && !srcAlloc->getIsScript()) { 4030f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines rsc->setError(RS_ERROR_FATAL_DRIVER, "Non-script allocation copies not " 4040f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines "yet implemented."); 4050f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines return; 4060f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 4070f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines rsdAllocationData2D_alloc_script(rsc, dstAlloc, dstXoff, dstYoff, 4080f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines dstLod, dstFace, w, h, srcAlloc, 4090f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines srcXoff, srcYoff, srcLod, srcFace); 4100f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 4110f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4120f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationData3D_alloc(const android::renderscript::Context *rsc, 4130f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *dstAlloc, 4140f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff, 4150f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t dstLod, RsAllocationCubemapFace dstFace, 4160f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t w, uint32_t h, uint32_t d, 4170f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const android::renderscript::Allocation *srcAlloc, 4180f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, 4190f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t srcLod, RsAllocationCubemapFace srcFace) { 4200f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 4210f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4220f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationElementData1D(const Context *rsc, const Allocation *alloc, 4230f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t x, 4240f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const void *data, uint32_t cIdx, uint32_t sizeBytes) { 4250f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 4260f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4270f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t eSize = alloc->mHal.state.elementSizeBytes; 4280f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t * ptr = GetOffsetPtr(alloc, x, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 4290f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4300f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx); 4310f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx); 4320f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4330f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.hasReferences) { 4340f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines e->incRefs(data); 4350f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines e->decRefs(ptr); 4360f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 4370f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4380f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memcpy(ptr, data, sizeBytes); 4390f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->uploadDeferred = true; 4400f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 4410f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4420f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationElementData2D(const Context *rsc, const Allocation *alloc, 4430f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t x, uint32_t y, 4440f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const void *data, uint32_t cIdx, uint32_t sizeBytes) { 4450f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 4460f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4470f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t eSize = alloc->mHal.state.elementSizeBytes; 4480f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t * ptr = GetOffsetPtr(alloc, x, y, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X); 4490f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4500f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const Element * e = alloc->mHal.state.type->getElement()->getField(cIdx); 4510f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines ptr += alloc->mHal.state.type->getElement()->getFieldOffsetBytes(cIdx); 4520f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4530f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if (alloc->mHal.state.hasReferences) { 4540f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines e->incRefs(data); 4550f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines e->decRefs(ptr); 4560f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 4570f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4580f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines memcpy(ptr, data, sizeBytes); 4590f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines drv->uploadDeferred = true; 4600f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 4610f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4620f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesstatic void mip565(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 4630f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 4640f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t w = drv->lod[lod + 1].dimX; 4650f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t h = drv->lod[lod + 1].dimY; 4660f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4670f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t y=0; y < h; y++) { 4680f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint16_t *oPtr = (uint16_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face); 4690f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint16_t *i1 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2, lod, face); 4700f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint16_t *i2 = (uint16_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face); 4710f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4720f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t x=0; x < w; x++) { 4730f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines *oPtr = rsBoxFilter565(i1[0], i1[1], i2[0], i2[1]); 4740f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines oPtr ++; 4750f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines i1 += 2; 4760f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines i2 += 2; 4770f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 4780f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 4790f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 4800f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4810f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesstatic void mip8888(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 4820f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 4830f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t w = drv->lod[lod + 1].dimX; 4840f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t h = drv->lod[lod + 1].dimY; 4850f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4860f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t y=0; y < h; y++) { 4870f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t *oPtr = (uint32_t *)GetOffsetPtr(alloc, 0, y, lod + 1, face); 4880f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint32_t *i1 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2, lod, face); 4890f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint32_t *i2 = (uint32_t *)GetOffsetPtr(alloc, 0, y*2+1, lod, face); 4900f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 4910f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t x=0; x < w; x++) { 4920f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines *oPtr = rsBoxFilter8888(i1[0], i1[1], i2[0], i2[1]); 4930f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines oPtr ++; 4940f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines i1 += 2; 4950f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines i2 += 2; 4960f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 4970f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 4980f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 4990f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 5000f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesstatic void mip8(const Allocation *alloc, int lod, RsAllocationCubemapFace face) { 5010f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 5020f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t w = drv->lod[lod + 1].dimX; 5030f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t h = drv->lod[lod + 1].dimY; 5040f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 5050f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t y=0; y < h; y++) { 5060f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint8_t *oPtr = GetOffsetPtr(alloc, 0, y, lod + 1, face); 5070f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint8_t *i1 = GetOffsetPtr(alloc, 0, y*2, lod, face); 5080f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines const uint8_t *i2 = GetOffsetPtr(alloc, 0, y*2+1, lod, face); 5090f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 5100f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t x=0; x < w; x++) { 5110f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines *oPtr = (uint8_t)(((uint32_t)i1[0] + i1[1] + i2[0] + i2[1]) * 0.25f); 5120f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines oPtr ++; 5130f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines i1 += 2; 5140f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines i2 += 2; 5150f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 5160f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 5170f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 5180f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 5190f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hinesvoid rsdAllocationGenerateMipmaps(const Context *rsc, const Allocation *alloc) { 5200f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines DrvAllocation *drv = (DrvAllocation *)alloc->mHal.drv; 5210f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines if(!drv->lod[0].mallocPtr) { 5220f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines return; 5230f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 5240f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines uint32_t numFaces = alloc->getType()->getDimFaces() ? 6 : 1; 5250f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t face = 0; face < numFaces; face ++) { 5260f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines for (uint32_t lod=0; lod < (alloc->getType()->getLODCount() -1); lod++) { 5270f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines switch (alloc->getType()->getElement()->getSizeBits()) { 5280f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines case 32: 5290f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines mip8888(alloc, lod, (RsAllocationCubemapFace)face); 5300f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines break; 5310f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines case 16: 5320f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines mip565(alloc, lod, (RsAllocationCubemapFace)face); 5330f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines break; 5340f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines case 8: 5350f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines mip8(alloc, lod, (RsAllocationCubemapFace)face); 5360f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines break; 5370f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 5380f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 5390f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines } 5400f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines} 5410f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 5420f6f72e19db852cc253fd2fc05459abdf8d5c3afStephen Hines 543