1326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams/* 2bc0ca6ba4e31239bf77060578d0bdf1a10e04168Jason Sams * Copyright (C) 2013 The Android Open Source Project 3326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * 4326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * Licensed under the Apache License, Version 2.0 (the "License"); 5326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * you may not use this file except in compliance with the License. 6326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * You may obtain a copy of the License at 7326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * 8326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * http://www.apache.org/licenses/LICENSE-2.0 9326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * 10326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * Unless required by applicable law or agreed to in writing, software 11326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * distributed under the License is distributed on an "AS IS" BASIS, 12326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * See the License for the specific language governing permissions and 14326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams * limitations under the License. 15326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams */ 16326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 1777d9f4bd05b2d2a161f30c12a2248f9c97eaac42Alex Sakhartchouk#include "rsContext.h" 184edf030cbb7c6ac08dc563335c2af73c20f6e2e5Alex Sakhartchouk#include "rsAllocation.h" 194edf030cbb7c6ac08dc563335c2af73c20f6e2e5Alex Sakhartchouk#include "rsAdapter.h" 20eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams#include "rs_hal.h" 21eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams 22b0934b67b95cc27e2358c2aa4db5f7c1067c8f9bStephen Hines#if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB) 237ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams#include "system/window.h" 2458fd6a5f10480551786739280d56dfa620c80b39Andy McFadden#include "gui/GLConsumer.h" 250b575de8ed0b628d84d256f5846500b0385979bdTim Murray#endif 2639f2ef6fed00a99c5c389e12c4597884027d4858Alex Sakhartchouk 27326e0ddf89e8df2837752fbfd7a014814b32082cJason Samsusing namespace android; 28326e0ddf89e8df2837752fbfd7a014814b32082cJason Samsusing namespace android::renderscript; 29326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 30a2aab8be7a980791fc9d4e6c4d050d703b20bcf6Alex SakhartchoukAllocation::Allocation(Context *rsc, const Type *type, uint32_t usages, 31179e9a457095fea4c9e6d366c269754b882d05ddJason Sams RsAllocationMipmapControl mc, void * ptr) 32a2aab8be7a980791fc9d4e6c4d050d703b20bcf6Alex Sakhartchouk : ObjectBase(rsc) { 33fa84da2cbc271f855b3b1ec75bb688abdf1d1d01Jason Sams 34eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams memset(&mHal, 0, sizeof(mHal)); 35eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams mHal.state.mipmapControl = RS_ALLOCATION_MIPMAP_NONE; 36bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams mHal.state.usageFlags = usages; 37bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams mHal.state.mipmapControl = mc; 382e1a94df812f0caa42ff24eaefeba8f90fbdf1acTim Murray mHal.state.userProvidedPtr = ptr; 39366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams 40064aa7ed76db9564b041afcd4b75da5b3d12fabaAlex Sakhartchouk setType(type); 41eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams updateCache(); 42fa84da2cbc271f855b3b1ec75bb688abdf1d1d01Jason Sams} 43fa84da2cbc271f855b3b1ec75bb688abdf1d1d01Jason Sams 44cfea6c13075aa255712e5a09a54eccbc84b0b122Jason SamsAllocation::Allocation(Context *rsc, const Allocation *alloc, const Type *type) 45cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams : ObjectBase(rsc) { 46cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 47cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams memset(&mHal, 0, sizeof(mHal)); 48cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams mHal.state.baseAlloc = alloc; 49cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams mHal.state.usageFlags = alloc->mHal.state.usageFlags; 50cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams mHal.state.mipmapControl = RS_ALLOCATION_MIPMAP_NONE; 51cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 52cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams setType(type); 53cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams updateCache(); 54cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams} 55cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 5634689388556747b52c3c2f1c894929fb44580898Tim Murrayvoid Allocation::operator delete(void* ptr) { 5734689388556747b52c3c2f1c894929fb44580898Tim Murray if (ptr) { 5834689388556747b52c3c2f1c894929fb44580898Tim Murray Allocation *a = (Allocation*) ptr; 5934689388556747b52c3c2f1c894929fb44580898Tim Murray a->getContext()->mHal.funcs.freeRuntimeMem(ptr); 6034689388556747b52c3c2f1c894929fb44580898Tim Murray } 6134689388556747b52c3c2f1c894929fb44580898Tim Murray} 6234689388556747b52c3c2f1c894929fb44580898Tim Murray 63eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason SamsAllocation * Allocation::createAllocation(Context *rsc, const Type *type, uint32_t usages, 64179e9a457095fea4c9e6d366c269754b882d05ddJason Sams RsAllocationMipmapControl mc, void * ptr) { 6534689388556747b52c3c2f1c894929fb44580898Tim Murray // Allocation objects must use allocator specified by the driver 6634689388556747b52c3c2f1c894929fb44580898Tim Murray void* allocMem = rsc->mHal.funcs.allocRuntimeMem(sizeof(Allocation), 0); 6734689388556747b52c3c2f1c894929fb44580898Tim Murray 6834689388556747b52c3c2f1c894929fb44580898Tim Murray if (!allocMem) { 6934689388556747b52c3c2f1c894929fb44580898Tim Murray rsc->setError(RS_ERROR_FATAL_DRIVER, "Couldn't allocate memory for Allocation"); 7044bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 7134689388556747b52c3c2f1c894929fb44580898Tim Murray } 7234689388556747b52c3c2f1c894929fb44580898Tim Murray 73cc169dee42a552746f8896c293143dfaab326263Jason Sams bool success = false; 74cc169dee42a552746f8896c293143dfaab326263Jason Sams Allocation *a = nullptr; 75cc169dee42a552746f8896c293143dfaab326263Jason Sams if (usages & RS_ALLOCATION_USAGE_OEM) { 76cc169dee42a552746f8896c293143dfaab326263Jason Sams if (rsc->mHal.funcs.allocation.initOem != nullptr) { 77cc169dee42a552746f8896c293143dfaab326263Jason Sams a = new (allocMem) Allocation(rsc, type, usages, mc, nullptr); 78cc169dee42a552746f8896c293143dfaab326263Jason Sams success = rsc->mHal.funcs.allocation.initOem(rsc, a, type->getElement()->getHasReferences(), ptr); 79cc169dee42a552746f8896c293143dfaab326263Jason Sams } else { 80cc169dee42a552746f8896c293143dfaab326263Jason Sams rsc->setError(RS_ERROR_FATAL_DRIVER, "Allocation Init called with USAGE_OEM but driver does not support it"); 81cc169dee42a552746f8896c293143dfaab326263Jason Sams return nullptr; 82cc169dee42a552746f8896c293143dfaab326263Jason Sams } 83cc169dee42a552746f8896c293143dfaab326263Jason Sams } else { 84cc169dee42a552746f8896c293143dfaab326263Jason Sams a = new (allocMem) Allocation(rsc, type, usages, mc, ptr); 85cc169dee42a552746f8896c293143dfaab326263Jason Sams success = rsc->mHal.funcs.allocation.init(rsc, a, type->getElement()->getHasReferences()); 86cc169dee42a552746f8896c293143dfaab326263Jason Sams } 87fa84da2cbc271f855b3b1ec75bb688abdf1d1d01Jason Sams 88cc169dee42a552746f8896c293143dfaab326263Jason Sams if (!success) { 89eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsc->setError(RS_ERROR_FATAL_DRIVER, "Allocation::Allocation, alloc failure"); 90eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams delete a; 9144bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 92eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 937ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 94eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams return a; 95bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams} 96fa84da2cbc271f855b3b1ec75bb688abdf1d1d01Jason Sams 97cfea6c13075aa255712e5a09a54eccbc84b0b122Jason SamsAllocation * Allocation::createAdapter(Context *rsc, const Allocation *alloc, const Type *type) { 98cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams // Allocation objects must use allocator specified by the driver 99cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams void* allocMem = rsc->mHal.funcs.allocRuntimeMem(sizeof(Allocation), 0); 100cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 101cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams if (!allocMem) { 102cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams rsc->setError(RS_ERROR_FATAL_DRIVER, "Couldn't allocate memory for Allocation"); 103cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams return nullptr; 104cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams } 105cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 106cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams Allocation *a = new (allocMem) Allocation(rsc, alloc, type); 107cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 108cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams if (!rsc->mHal.funcs.allocation.initAdapter(rsc, a)) { 109cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams rsc->setError(RS_ERROR_FATAL_DRIVER, "Allocation::Allocation, alloc failure"); 110cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams delete a; 111cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams return nullptr; 112cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams } 113cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 114cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams return a; 115cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams} 116cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 117442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Samsvoid Allocation::adapterOffset(Context *rsc, const uint32_t *offsets, size_t len) { 118442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams if (len >= sizeof(uint32_t) * 9) { 119442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams mHal.state.originX = offsets[0]; 120442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams mHal.state.originY = offsets[1]; 121442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams mHal.state.originZ = offsets[2]; 122442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams mHal.state.originLOD = offsets[3]; 123442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams mHal.state.originFace = offsets[4]; 124442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams mHal.state.originArray[0] = offsets[5]; 125442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams mHal.state.originArray[1] = offsets[6]; 126442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams mHal.state.originArray[2] = offsets[7]; 127442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams mHal.state.originArray[3] = offsets[8]; 128442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams } 129442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams 130442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams rsc->mHal.funcs.allocation.adapterOffset(rsc, this); 131442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams} 132442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams 133442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams 134cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 135bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Samsvoid Allocation::updateCache() { 136064aa7ed76db9564b041afcd4b75da5b3d12fabaAlex Sakhartchouk const Type *type = mHal.state.type; 137a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams mHal.state.yuv = type->getDimYuv(); 138bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams mHal.state.hasFaces = type->getDimFaces(); 139bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams mHal.state.hasMipmaps = type->getDimLOD(); 140bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams mHal.state.elementSizeBytes = type->getElementSizeBytes(); 141bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams mHal.state.hasReferences = mHal.state.type->getElement()->getHasReferences(); 142326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams} 143326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 144afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex SakhartchoukAllocation::~Allocation() { 145ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams#if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB) 146ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams if (mGrallocConsumer.get()) { 147ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams mGrallocConsumer->unlockBuffer(); 14844bef6fba6244292b751387f3d6c31cca96c28adChris Wailes mGrallocConsumer = nullptr; 149ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams } 150ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams#endif 151ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams 152c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams freeChildrenUnlocked(); 153eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams mRSC->mHal.funcs.allocation.destroy(mRSC, this); 154326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams} 155326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 156366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Samsvoid Allocation::syncAll(Context *rsc, RsAllocationUsageType src) { 157eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsc->mHal.funcs.allocation.syncAll(rsc, this, src); 158cf4c7c9b2f513be77a5b9853319ca82ac2b128edJason Sams} 159cf4c7c9b2f513be77a5b9853319ca82ac2b128edJason Sams 160b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Samsvoid * Allocation::getPointer(const Context *rsc, uint32_t lod, RsAllocationCubemapFace face, 161b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams uint32_t z, uint32_t array, size_t *stride) { 162b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams 163b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams if ((lod >= mHal.drvState.lodCount) || 164b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams (z && (z >= mHal.drvState.lod[lod].dimZ)) || 165b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams ((face != RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X) && !mHal.state.hasFaces) || 166b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams (array != 0)) { 16744bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 168b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams } 169b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams 170fa578a3a3404bafaae1ac23164a563a70e00fd44Jason Sams if (mRSC->mHal.funcs.allocation.getPointer != nullptr) { 171fa578a3a3404bafaae1ac23164a563a70e00fd44Jason Sams // Notify the driver, if present that the user is mapping the buffer 172fa578a3a3404bafaae1ac23164a563a70e00fd44Jason Sams mRSC->mHal.funcs.allocation.getPointer(rsc, this, lod, face, z, array); 173fa578a3a3404bafaae1ac23164a563a70e00fd44Jason Sams } 174fa578a3a3404bafaae1ac23164a563a70e00fd44Jason Sams 175b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams size_t s = 0; 17644bef6fba6244292b751387f3d6c31cca96c28adChris Wailes if ((stride != nullptr) && mHal.drvState.lod[0].dimY) { 177b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams *stride = mHal.drvState.lod[lod].stride; 178b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams } 179b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams return mHal.drvState.lod[lod].mallocPtr; 180b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams} 181b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams 1824b45b8998e0d7038efaea80c70d23c086640b4e3Jason Samsvoid Allocation::data(Context *rsc, uint32_t xoff, uint32_t lod, 1836ae039baf797915d46f3b3901d1b7f5cc83feaceStephen Hines uint32_t count, const void *data, size_t sizeBytes) { 1846ae039baf797915d46f3b3901d1b7f5cc83feaceStephen Hines const size_t eSize = mHal.state.type->getElementSizeBytes(); 1859397e30ce5fe3f6af9212a93b490836b04fdfffaJason Sams 186eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if ((count * eSize) != sizeBytes) { 187a273793e0958b0bde10f83725fbe778f3b92374fJason Sams char buf[1024]; 188a273793e0958b0bde10f83725fbe778f3b92374fJason Sams sprintf(buf, "Allocation::subData called with mismatched size expected %zu, got %zu", 189a273793e0958b0bde10f83725fbe778f3b92374fJason Sams (count * eSize), sizeBytes); 190a273793e0958b0bde10f83725fbe778f3b92374fJason Sams rsc->setError(RS_ERROR_BAD_VALUE, buf); 191bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams mHal.state.type->dumpLOGV("type info"); 1929397e30ce5fe3f6af9212a93b490836b04fdfffaJason Sams return; 1939397e30ce5fe3f6af9212a93b490836b04fdfffaJason Sams } 194e3929c9bc6f3897e132304faf1b40c3cf1f47474Jason Sams 195eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams rsc->mHal.funcs.allocation.data1D(rsc, this, xoff, lod, count, data, sizeBytes); 196eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams sendDirty(rsc); 197326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams} 198326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 1994b45b8998e0d7038efaea80c70d23c086640b4e3Jason Samsvoid Allocation::data(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 200358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t w, uint32_t h, const void *data, size_t sizeBytes, size_t stride) { 201358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray rsc->mHal.funcs.allocation.data2D(rsc, this, xoff, yoff, lod, face, w, h, data, sizeBytes, stride); 202eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams sendDirty(rsc); 203326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams} 204326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 205236385b73f21ae65e756b9cb5738f1514d95ea3eJason Samsvoid Allocation::data(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t zoff, 2063bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t lod, 2073bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t w, uint32_t h, uint32_t d, const void *data, size_t sizeBytes, size_t stride) { 2083bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams rsc->mHal.funcs.allocation.data3D(rsc, this, xoff, yoff, zoff, lod, w, h, d, data, sizeBytes, stride); 2093bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams sendDirty(rsc); 210326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams} 211326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 212807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid Allocation::read(Context *rsc, uint32_t xoff, uint32_t lod, 213358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t count, void *data, size_t sizeBytes) { 214807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const size_t eSize = mHal.state.type->getElementSizeBytes(); 215807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 216807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams if ((count * eSize) != sizeBytes) { 217a273793e0958b0bde10f83725fbe778f3b92374fJason Sams char buf[1024]; 218a273793e0958b0bde10f83725fbe778f3b92374fJason Sams sprintf(buf, "Allocation::read called with mismatched size expected %zu, got %zu", 219a273793e0958b0bde10f83725fbe778f3b92374fJason Sams (count * eSize), sizeBytes); 220a273793e0958b0bde10f83725fbe778f3b92374fJason Sams rsc->setError(RS_ERROR_BAD_VALUE, buf); 221807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams mHal.state.type->dumpLOGV("type info"); 222807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams return; 223807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 224807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 225807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams rsc->mHal.funcs.allocation.read1D(rsc, this, xoff, lod, count, data, sizeBytes); 226807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 227807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 228807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid Allocation::read(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 2293bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t w, uint32_t h, void *data, size_t sizeBytes, size_t stride) { 230807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const size_t eSize = mHal.state.elementSizeBytes; 231807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const size_t lineSize = eSize * w; 2323bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams if (!stride) { 2333bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams stride = lineSize; 2343bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams } else { 2353bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams if ((lineSize * h) != sizeBytes) { 236a273793e0958b0bde10f83725fbe778f3b92374fJason Sams char buf[1024]; 237a273793e0958b0bde10f83725fbe778f3b92374fJason Sams sprintf(buf, "Allocation size mismatch, expected %zu, got %zu", (lineSize * h), sizeBytes); 238a273793e0958b0bde10f83725fbe778f3b92374fJason Sams rsc->setError(RS_ERROR_BAD_VALUE, buf); 2393bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams return; 2403bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams } 241807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 242807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 2433bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams rsc->mHal.funcs.allocation.read2D(rsc, this, xoff, yoff, lod, face, w, h, data, sizeBytes, stride); 244358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray} 245358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray 2463bbc0fd40264ddae1592706d9023865b7b3e3195Jason Samsvoid Allocation::read(Context *rsc, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, 2473bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t w, uint32_t h, uint32_t d, void *data, size_t sizeBytes, size_t stride) { 248358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray const size_t eSize = mHal.state.elementSizeBytes; 249358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray const size_t lineSize = eSize * w; 250358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray if (!stride) { 251358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray stride = lineSize; 252358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray } 253358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray 2543bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams rsc->mHal.funcs.allocation.read3D(rsc, this, xoff, yoff, zoff, lod, w, h, d, data, sizeBytes, stride); 255807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 256807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams} 257807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 258cc8cea7477352898921044483a6c803e25d02665Miao Wangvoid Allocation::elementData(Context *rsc, uint32_t x, uint32_t y, uint32_t z, 259cc8cea7477352898921044483a6c803e25d02665Miao Wang const void *data, uint32_t cIdx, size_t sizeBytes) { 2606ae039baf797915d46f3b3901d1b7f5cc83feaceStephen Hines size_t eSize = mHal.state.elementSizeBytes; 2615f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 262cc8cea7477352898921044483a6c803e25d02665Miao Wang if (x >= mHal.drvState.lod[0].dimX) { 263cc8cea7477352898921044483a6c803e25d02665Miao Wang rsc->setError(RS_ERROR_BAD_VALUE, "subElementData X offset out of range."); 2645f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams return; 2655f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams } 2665f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 267cc8cea7477352898921044483a6c803e25d02665Miao Wang if (y > 0 && y >= mHal.drvState.lod[0].dimY) { 268cc8cea7477352898921044483a6c803e25d02665Miao Wang rsc->setError(RS_ERROR_BAD_VALUE, "subElementData Y offset out of range."); 269cc8cea7477352898921044483a6c803e25d02665Miao Wang return; 270cc8cea7477352898921044483a6c803e25d02665Miao Wang } 271cc8cea7477352898921044483a6c803e25d02665Miao Wang 272cc8cea7477352898921044483a6c803e25d02665Miao Wang if (z > 0 && z >= mHal.drvState.lod[0].dimZ) { 273cc8cea7477352898921044483a6c803e25d02665Miao Wang rsc->setError(RS_ERROR_BAD_VALUE, "subElementData Z offset out of range."); 274cc8cea7477352898921044483a6c803e25d02665Miao Wang return; 275cc8cea7477352898921044483a6c803e25d02665Miao Wang } 276cc8cea7477352898921044483a6c803e25d02665Miao Wang 277cc8cea7477352898921044483a6c803e25d02665Miao Wang if (cIdx >= mHal.state.type->getElement()->getFieldCount()) { 278cc8cea7477352898921044483a6c803e25d02665Miao Wang rsc->setError(RS_ERROR_BAD_VALUE, "subElementData component out of range."); 2795f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams return; 2805f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams } 2815f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 282bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams const Element * e = mHal.state.type->getElement()->getField(cIdx); 283769463262d655087ed39d9b823673e776a8af946Alex Sakhartchouk uint32_t elemArraySize = mHal.state.type->getElement()->getFieldArraySize(cIdx); 284769463262d655087ed39d9b823673e776a8af946Alex Sakhartchouk if (sizeBytes != e->getSizeBytes() * elemArraySize) { 2855f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams rsc->setError(RS_ERROR_BAD_VALUE, "subElementData bad size."); 2865f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams return; 2875f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams } 2885f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 289cc8cea7477352898921044483a6c803e25d02665Miao Wang rsc->mHal.funcs.allocation.elementData(rsc, this, x, y, z, data, cIdx, sizeBytes); 290eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams sendDirty(rsc); 2915f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams} 2925f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 293cc8cea7477352898921044483a6c803e25d02665Miao Wangvoid Allocation::elementRead(Context *rsc, uint32_t x, uint32_t y, uint32_t z, 294cc8cea7477352898921044483a6c803e25d02665Miao Wang void *data, uint32_t cIdx, size_t sizeBytes) { 2956ae039baf797915d46f3b3901d1b7f5cc83feaceStephen Hines size_t eSize = mHal.state.elementSizeBytes; 2965f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 297a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams if (x >= mHal.drvState.lod[0].dimX) { 2985f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams rsc->setError(RS_ERROR_BAD_VALUE, "subElementData X offset out of range."); 2995f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams return; 3005f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams } 3015f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 302cc8cea7477352898921044483a6c803e25d02665Miao Wang if (y > 0 && y >= mHal.drvState.lod[0].dimY) { 303cc8cea7477352898921044483a6c803e25d02665Miao Wang rsc->setError(RS_ERROR_BAD_VALUE, "subElementData Y offset out of range."); 304cc8cea7477352898921044483a6c803e25d02665Miao Wang return; 305cc8cea7477352898921044483a6c803e25d02665Miao Wang } 306cc8cea7477352898921044483a6c803e25d02665Miao Wang 307cc8cea7477352898921044483a6c803e25d02665Miao Wang if (z > 0 && z >= mHal.drvState.lod[0].dimZ) { 308cc8cea7477352898921044483a6c803e25d02665Miao Wang rsc->setError(RS_ERROR_BAD_VALUE, "subElementData Z offset out of range."); 3095f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams return; 3105f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams } 3115f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 312bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams if (cIdx >= mHal.state.type->getElement()->getFieldCount()) { 313b8353c5943f4038fd7f08db3d958390ce9418798Yang Ni rsc->setError(RS_ERROR_BAD_VALUE, "subElementData component out of range."); 3145f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams return; 3155f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams } 3165f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 317bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams const Element * e = mHal.state.type->getElement()->getField(cIdx); 318b8353c5943f4038fd7f08db3d958390ce9418798Yang Ni uint32_t elemArraySize = mHal.state.type->getElement()->getFieldArraySize(cIdx); 319769463262d655087ed39d9b823673e776a8af946Alex Sakhartchouk if (sizeBytes != e->getSizeBytes() * elemArraySize) { 3205f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams rsc->setError(RS_ERROR_BAD_VALUE, "subElementData bad size."); 3215f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams return; 3225f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams } 3235f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 324cc8cea7477352898921044483a6c803e25d02665Miao Wang rsc->mHal.funcs.allocation.elementRead(rsc, this, x, y, z, data, cIdx, sizeBytes); 3255f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams} 3265f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 327afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid Allocation::addProgramToDirty(const Program *p) { 328b8353c5943f4038fd7f08db3d958390ce9418798Yang Ni mToDirtyList.push(p); 3295c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams} 3305c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams 331afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid Allocation::removeProgramToDirty(const Program *p) { 332b8353c5943f4038fd7f08db3d958390ce9418798Yang Ni for (size_t ct=0; ct < mToDirtyList.size(); ct++) { 333b8353c5943f4038fd7f08db3d958390ce9418798Yang Ni if (mToDirtyList[ct] == p) { 334b8353c5943f4038fd7f08db3d958390ce9418798Yang Ni mToDirtyList.removeAt(ct); 3355c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams return; 3365c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams } 3375c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams } 3385c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams rsAssert(0); 3395c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams} 340326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 341afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid Allocation::dumpLOGV(const char *prefix) const { 342c21cf40f6ae69091bf24f87b5eeabc95e73dd271Jason Sams ObjectBase::dumpLOGV(prefix); 34348ecf6a5e85a9a832f41393ed2802385bb8b5db8Jason Sams char buf[1024]; 344c21cf40f6ae69091bf24f87b5eeabc95e73dd271Jason Sams 34548ecf6a5e85a9a832f41393ed2802385bb8b5db8Jason Sams if ((strlen(prefix) + 10) < sizeof(buf)) { 34648ecf6a5e85a9a832f41393ed2802385bb8b5db8Jason Sams sprintf(buf, "%s type ", prefix); 34748ecf6a5e85a9a832f41393ed2802385bb8b5db8Jason Sams if (mHal.state.type) { 34848ecf6a5e85a9a832f41393ed2802385bb8b5db8Jason Sams mHal.state.type->dumpLOGV(buf); 34948ecf6a5e85a9a832f41393ed2802385bb8b5db8Jason Sams } 350c21cf40f6ae69091bf24f87b5eeabc95e73dd271Jason Sams } 3516598201f1c4f409defac9a5af789fb53a7cc00f8Steve Block ALOGV("%s allocation ptr=%p mUsageFlags=0x04%x, mMipmapControl=0x%04x", 352b8353c5943f4038fd7f08db3d958390ce9418798Yang Ni prefix, mHal.drvState.lod[0].mallocPtr, mHal.state.usageFlags, mHal.state.mipmapControl); 353c21cf40f6ae69091bf24f87b5eeabc95e73dd271Jason Sams} 354326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 3552d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchoukuint32_t Allocation::getPackedSize() const { 35661656a7c6fc13421679d0a1cdf8b5b861e286892Jason Sams uint32_t numItems = mHal.state.type->getCellCount(); 3572d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk return numItems * mHal.state.type->getElement()->getSizeBytesUnpadded(); 3582d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk} 3592d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 360e3150cfb3edb028407669e4a65e087eae77e718cJason Samsvoid Allocation::writePackedData(Context *rsc, const Type *type, 3612d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint8_t *dst, const uint8_t *src, bool dstPadded) { 3622d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk const Element *elem = type->getElement(); 3632d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t unpaddedBytes = elem->getSizeBytesUnpadded(); 3642d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t paddedBytes = elem->getSizeBytes(); 36561656a7c6fc13421679d0a1cdf8b5b861e286892Jason Sams uint32_t numItems = type->getPackedSizeBytes() / paddedBytes; 3662d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 3672d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t srcInc = !dstPadded ? paddedBytes : unpaddedBytes; 3682d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t dstInc = dstPadded ? paddedBytes : unpaddedBytes; 3692d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 3702d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk // no sub-elements 3712d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t fieldCount = elem->getFieldCount(); 3722d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk if (fieldCount == 0) { 3732d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk for (uint32_t i = 0; i < numItems; i ++) { 3742d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk memcpy(dst, src, unpaddedBytes); 3752d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk src += srcInc; 3762d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk dst += dstInc; 3772d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk } 3782d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk return; 3792d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk } 3802d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 3812d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk // Cache offsets 3822d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t *offsetsPadded = new uint32_t[fieldCount]; 3832d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t *offsetsUnpadded = new uint32_t[fieldCount]; 3842d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t *sizeUnpadded = new uint32_t[fieldCount]; 3852d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 3862d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk for (uint32_t i = 0; i < fieldCount; i++) { 3872d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk offsetsPadded[i] = elem->getFieldOffsetBytes(i); 3882d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk offsetsUnpadded[i] = elem->getFieldOffsetBytesUnpadded(i); 3892d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk sizeUnpadded[i] = elem->getField(i)->getSizeBytesUnpadded(); 3902d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk } 3912d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 3922d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t *srcOffsets = !dstPadded ? offsetsPadded : offsetsUnpadded; 3932d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t *dstOffsets = dstPadded ? offsetsPadded : offsetsUnpadded; 3942d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 3952d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk // complex elements, need to copy subelem after subelem 3962d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk for (uint32_t i = 0; i < numItems; i ++) { 3972d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk for (uint32_t fI = 0; fI < fieldCount; fI++) { 3982d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk memcpy(dst + dstOffsets[fI], src + srcOffsets[fI], sizeUnpadded[fI]); 3992d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk } 4002d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk src += srcInc; 4012d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk dst += dstInc; 4022d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk } 4032d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 4042d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk delete[] offsetsPadded; 4052d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk delete[] offsetsUnpadded; 4062d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk delete[] sizeUnpadded; 4072d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk} 4082d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 409e3150cfb3edb028407669e4a65e087eae77e718cJason Samsvoid Allocation::unpackVec3Allocation(Context *rsc, const void *data, size_t dataSize) { 4102d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk const uint8_t *src = (const uint8_t*)data; 41161a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams uint8_t *dst = (uint8_t *)rsc->mHal.funcs.allocation.lock1D(rsc, this); 4122d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 413e3150cfb3edb028407669e4a65e087eae77e718cJason Sams writePackedData(rsc, getType(), dst, src, true); 41461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams rsc->mHal.funcs.allocation.unlock1D(rsc, this); 4152d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk} 4162d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 417e3150cfb3edb028407669e4a65e087eae77e718cJason Samsvoid Allocation::packVec3Allocation(Context *rsc, OStream *stream) const { 4182d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t paddedBytes = getType()->getElement()->getSizeBytes(); 4192d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t unpaddedBytes = getType()->getElement()->getSizeBytesUnpadded(); 42061656a7c6fc13421679d0a1cdf8b5b861e286892Jason Sams uint32_t numItems = mHal.state.type->getCellCount(); 4212d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 42261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams const uint8_t *src = (const uint8_t*)rsc->mHal.funcs.allocation.lock1D(rsc, this); 4232d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint8_t *dst = new uint8_t[numItems * unpaddedBytes]; 4242d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 425e3150cfb3edb028407669e4a65e087eae77e718cJason Sams writePackedData(rsc, getType(), dst, src, false); 4262d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk stream->addByteArray(dst, getPackedSize()); 4272d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 4282d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk delete[] dst; 42961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams rsc->mHal.funcs.allocation.unlock1D(rsc, this); 4302d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk} 4312d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 432e3150cfb3edb028407669e4a65e087eae77e718cJason Samsvoid Allocation::serialize(Context *rsc, OStream *stream) const { 433fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk // Need to identify ourselves 434fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk stream->addU32((uint32_t)getClassId()); 43548ecf6a5e85a9a832f41393ed2802385bb8b5db8Jason Sams stream->addString(getName()); 436fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk 437fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk // First thing we need to serialize is the type object since it will be needed 438fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk // to initialize the class 439e3150cfb3edb028407669e4a65e087eae77e718cJason Sams mHal.state.type->serialize(rsc, stream); 440fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk 44161656a7c6fc13421679d0a1cdf8b5b861e286892Jason Sams uint32_t dataSize = mHal.state.type->getPackedSizeBytes(); 4422d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk // 3 element vectors are padded to 4 in memory, but padding isn't serialized 4432d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t packedSize = getPackedSize(); 444fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk // Write how much data we are storing 4452d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk stream->addU32(packedSize); 4462d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk if (dataSize == packedSize) { 4472d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk // Now write the data 44861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams stream->addByteArray(rsc->mHal.funcs.allocation.lock1D(rsc, this), dataSize); 44961a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams rsc->mHal.funcs.allocation.unlock1D(rsc, this); 4502d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk } else { 4512d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk // Now write the data 452e3150cfb3edb028407669e4a65e087eae77e718cJason Sams packVec3Allocation(rsc, stream); 4532d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk } 454fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk} 455fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk 456afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex SakhartchoukAllocation *Allocation::createFromStream(Context *rsc, IStream *stream) { 457fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk // First make sure we are reading the correct object 458b825f67adb5d1e1751fe108e6dbf9c6f2555c283Alex Sakhartchouk RsA3DClassID classID = (RsA3DClassID)stream->loadU32(); 459afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk if (classID != RS_A3D_CLASS_ID_ALLOCATION) { 460a273793e0958b0bde10f83725fbe778f3b92374fJason Sams rsc->setError(RS_ERROR_FATAL_DRIVER, 461a273793e0958b0bde10f83725fbe778f3b92374fJason Sams "allocation loading failed due to corrupt file. (invalid id)\n"); 46244bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 463fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk } 464fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk 46548ecf6a5e85a9a832f41393ed2802385bb8b5db8Jason Sams const char *name = stream->loadString(); 466fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk 467fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk Type *type = Type::createFromStream(rsc, stream); 468afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchouk if (!type) { 46944bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 470fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk } 471fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk type->compute(); 472fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk 4732d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk Allocation *alloc = Allocation::createAllocation(rsc, type, RS_ALLOCATION_USAGE_SCRIPT); 4742d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk type->decUserRef(); 4752d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk 476fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk // Number of bytes we wrote out for this allocation 477fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk uint32_t dataSize = stream->loadU32(); 4782d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk // 3 element vectors are padded to 4 in memory, but padding isn't serialized 4792d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t packedSize = alloc->getPackedSize(); 48061656a7c6fc13421679d0a1cdf8b5b861e286892Jason Sams if (dataSize != type->getPackedSizeBytes() && 4812d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk dataSize != packedSize) { 482a273793e0958b0bde10f83725fbe778f3b92374fJason Sams rsc->setError(RS_ERROR_FATAL_DRIVER, 483a273793e0958b0bde10f83725fbe778f3b92374fJason Sams "allocation loading failed due to corrupt file. (invalid size)\n"); 4842d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk ObjectBase::checkDelete(alloc); 485225afd317e101a7be5fe02c0a86361146ea89f05Jason Sams ObjectBase::checkDelete(type); 48644bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 487fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk } 488fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk 48948ecf6a5e85a9a832f41393ed2802385bb8b5db8Jason Sams alloc->assignName(name); 49061656a7c6fc13421679d0a1cdf8b5b861e286892Jason Sams if (dataSize == type->getPackedSizeBytes()) { 4912d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk uint32_t count = dataSize / type->getElementSizeBytes(); 4922d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk // Read in all of our allocation data 4932d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk alloc->data(rsc, 0, 0, count, stream->getPtr() + stream->getPos(), dataSize); 4942d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk } else { 495e3150cfb3edb028407669e4a65e087eae77e718cJason Sams alloc->unpackVec3Allocation(rsc, stream->getPtr() + stream->getPos(), dataSize); 4962d1220c27ae91f0b307f283fe66cb767b63dfe38Alex Sakhartchouk } 497e6d9fbc31bef01219cc812e819c505ff01673c6fAlex Sakhartchouk stream->reset(stream->getPos() + dataSize); 498fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk 499fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk return alloc; 500fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk} 501fb6b614bcea88a587a7ea4530be45ff0ffa0210eAlex Sakhartchouk 502eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Samsvoid Allocation::sendDirty(const Context *rsc) const { 50393eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#ifndef RS_COMPATIBILITY_LIB 5045c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams for (size_t ct=0; ct < mToDirtyList.size(); ct++) { 5055c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams mToDirtyList[ct]->forceDirty(); 5065c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams } 50793eacc7ce0aad4314b4cb41a281f59ce54bb3286Jason Sams#endif 508eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams mRSC->mHal.funcs.allocation.markDirty(rsc, this); 5095c3e3bc8af6de6be5e6bd68e1d5168496f99e6cfJason Sams} 510326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 511afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid Allocation::incRefs(const void *ptr, size_t ct, size_t startOff) const { 5129f70a4e63825afe9f786483722e1669b3625f5e9Stephen Hines mHal.state.type->incRefs(ptr, ct, startOff); 513e3929c9bc6f3897e132304faf1b40c3cf1f47474Jason Sams} 514e3929c9bc6f3897e132304faf1b40c3cf1f47474Jason Sams 515afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid Allocation::decRefs(const void *ptr, size_t ct, size_t startOff) const { 5165c4369a3a1b19eaeabb044af2cdeef05474f9069Alex Sakhartchouk if (!mHal.state.hasReferences || !getIsScript()) { 5175c4369a3a1b19eaeabb044af2cdeef05474f9069Alex Sakhartchouk return; 5185c4369a3a1b19eaeabb044af2cdeef05474f9069Alex Sakhartchouk } 5199f70a4e63825afe9f786483722e1669b3625f5e9Stephen Hines mHal.state.type->decRefs(ptr, ct, startOff); 520e3929c9bc6f3897e132304faf1b40c3cf1f47474Jason Sams} 521e3929c9bc6f3897e132304faf1b40c3cf1f47474Jason Sams 522a36c50a6ab87f4c9049318d4c6c8ec7b0a1e6e12Jason Samsvoid Allocation::callUpdateCacheObject(const Context *rsc, void *dstObj) const { 52344bef6fba6244292b751387f3d6c31cca96c28adChris Wailes if (rsc->mHal.funcs.allocation.updateCachedObject != nullptr) { 524a36c50a6ab87f4c9049318d4c6c8ec7b0a1e6e12Jason Sams rsc->mHal.funcs.allocation.updateCachedObject(rsc, this, (rs_allocation *)dstObj); 525a36c50a6ab87f4c9049318d4c6c8ec7b0a1e6e12Jason Sams } else { 526a36c50a6ab87f4c9049318d4c6c8ec7b0a1e6e12Jason Sams *((const void **)dstObj) = this; 527a36c50a6ab87f4c9049318d4c6c8ec7b0a1e6e12Jason Sams } 528a36c50a6ab87f4c9049318d4c6c8ec7b0a1e6e12Jason Sams} 529a36c50a6ab87f4c9049318d4c6c8ec7b0a1e6e12Jason Sams 530a36c50a6ab87f4c9049318d4c6c8ec7b0a1e6e12Jason Sams 531c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Samsvoid Allocation::freeChildrenUnlocked () { 53261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams void *ptr = mRSC->mHal.funcs.allocation.lock1D(mRSC, this); 53361656a7c6fc13421679d0a1cdf8b5b861e286892Jason Sams decRefs(ptr, mHal.state.type->getCellCount(), 0); 53461a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams mRSC->mHal.funcs.allocation.unlock1D(mRSC, this); 535c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams} 536c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams 537c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Samsbool Allocation::freeChildren() { 538c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams if (mHal.state.hasReferences) { 539c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams incSysRef(); 540c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams freeChildrenUnlocked(); 541c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams return decSysRef(); 542c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams } 543c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams return false; 544c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams} 545c7cec1e3577cc77a5a73d5bd5a82733b1b9936a1Jason Sams 546afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid Allocation::copyRange1D(Context *rsc, const Allocation *src, int32_t srcOff, int32_t destOff, int32_t len) { 54796abf819e50b59ba8cf886c13f894633eb0a24baJason Sams} 54896abf819e50b59ba8cf886c13f894633eb0a24baJason Sams 549afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid Allocation::resize1D(Context *rsc, uint32_t dimX) { 550a572aca4eb4ddb32c10baa1f529431cfefd756b8Jason Sams uint32_t oldDimX = mHal.drvState.lod[0].dimX; 55196abf819e50b59ba8cf886c13f894633eb0a24baJason Sams if (dimX == oldDimX) { 55296abf819e50b59ba8cf886c13f894633eb0a24baJason Sams return; 55396abf819e50b59ba8cf886c13f894633eb0a24baJason Sams } 55496abf819e50b59ba8cf886c13f894633eb0a24baJason Sams 555c700e649ca44d0dcff8b271e42d949ea72fe3c63Alex Sakhartchouk ObjectBaseRef<Type> t = mHal.state.type->cloneAndResize1D(rsc, dimX); 55696abf819e50b59ba8cf886c13f894633eb0a24baJason Sams if (dimX < oldDimX) { 55761a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams decRefs(rsc->mHal.funcs.allocation.lock1D(rsc, this), oldDimX - dimX, dimX); 55861a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams rsc->mHal.funcs.allocation.unlock1D(rsc, this); 55996abf819e50b59ba8cf886c13f894633eb0a24baJason Sams } 560c700e649ca44d0dcff8b271e42d949ea72fe3c63Alex Sakhartchouk rsc->mHal.funcs.allocation.resize(rsc, this, t.get(), mHal.state.hasReferences); 561064aa7ed76db9564b041afcd4b75da5b3d12fabaAlex Sakhartchouk setType(t.get()); 562bad807405b2b9764372af1ad24bcfd4fb1f33d8eJason Sams updateCache(); 56396abf819e50b59ba8cf886c13f894633eb0a24baJason Sams} 56496abf819e50b59ba8cf886c13f894633eb0a24baJason Sams 565afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid Allocation::resize2D(Context *rsc, uint32_t dimX, uint32_t dimY) { 566a273793e0958b0bde10f83725fbe778f3b92374fJason Sams rsc->setError(RS_ERROR_FATAL_DRIVER, "resize2d not implemented"); 56796abf819e50b59ba8cf886c13f894633eb0a24baJason Sams} 56896abf819e50b59ba8cf886c13f894633eb0a24baJason Sams 569ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams#ifndef RS_COMPATIBILITY_LIB 570f0d7aa28bd4620030d9c54d983f607e3b0051df0Dan Stozavoid Allocation::NewBufferListener::onFrameAvailable(const BufferItem& /* item */) { 571ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams intptr_t ip = (intptr_t)alloc; 572e4ed0873cda11a0442176027f9c599d9e41538e1Tim Murray rsc->sendMessageToClient(&ip, RS_MESSAGE_TO_CLIENT_NEW_BUFFER, 0, sizeof(ip), true); 573ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams} 574ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams#endif 575ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams 576733396b67724162844ea2785c7495115dc5ee8d8Jason Samsvoid * Allocation::getSurface(const Context *rsc) { 577ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams#ifndef RS_COMPATIBILITY_LIB 578ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams // Configure GrallocConsumer to be in asynchronous mode 57903c155b6d20e99ee5c7abaae69a10c694106a83eDan Stoza sp<IGraphicBufferProducer> bp; 58003c155b6d20e99ee5c7abaae69a10c694106a83eDan Stoza sp<IGraphicBufferConsumer> bc; 58103c155b6d20e99ee5c7abaae69a10c694106a83eDan Stoza BufferQueue::createBufferQueue(&bp, &bc); 582e49da13c33086cf23fb750568348d114c4a10ff8Jason Sams mGrallocConsumer = new GrallocConsumer(this, bc, mHal.drvState.grallocFlags); 58344bef6fba6244292b751387f3d6c31cca96c28adChris Wailes bp->incStrong(nullptr); 584ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams 585ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams mBufferListener = new NewBufferListener(); 586ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams mBufferListener->rsc = rsc; 587ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams mBufferListener->alloc = this; 588ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams 589ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams mGrallocConsumer->setFrameAvailableListener(mBufferListener); 590ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams return bp.get(); 591ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams#else 59244bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 593ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams#endif 594ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams //return rsc->mHal.funcs.allocation.getSurface(rsc, this); 59541e373d91a60043afa0f9abd026218b49cbc1201Jason Sams} 59641e373d91a60043afa0f9abd026218b49cbc1201Jason Sams 5977ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid Allocation::setSurface(const Context *rsc, RsNativeWindow sur) { 5987ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams ANativeWindow *nw = (ANativeWindow *)sur; 599733396b67724162844ea2785c7495115dc5ee8d8Jason Sams rsc->mHal.funcs.allocation.setSurface(rsc, this, nw); 6007ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 6017ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6027ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid Allocation::ioSend(const Context *rsc) { 6037ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams rsc->mHal.funcs.allocation.ioSend(rsc, this); 6047ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 6057ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6067ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid Allocation::ioReceive(const Context *rsc) { 60744bef6fba6244292b751387f3d6c31cca96c28adChris Wailes void *ptr = nullptr; 608ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams size_t stride = 0; 609ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams#ifndef RS_COMPATIBILITY_LIB 610ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams if (mHal.state.usageFlags & RS_ALLOCATION_USAGE_SCRIPT) { 611ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams status_t ret = mGrallocConsumer->lockNextBuffer(); 612ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams 613ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams if (ret == OK) { 614ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams rsc->mHal.funcs.allocation.ioReceive(rsc, this); 615ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams } else if (ret == BAD_VALUE) { 616ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams // No new frame, don't do anything 617ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams } else { 618ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams rsc->setError(RS_ERROR_DRIVER, "Error receiving IO input buffer."); 619ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams } 620ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams 621ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams } 622ddceab9a001f07a3395226c5e06e3b420720af0fJason Sams#endif 6237ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 6247ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 6254b3c34e6833e39bc89c2128002806b654b8e623dChris Wailesbool Allocation::hasSameDims(const Allocation *other) const { 6264b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes const Type *type0 = this->getType(), 6274b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes *type1 = other->getType(); 6284b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes 6294b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes return (type0->getCellCount() == type1->getCellCount()) && 6304b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes (type0->getDimLOD() == type1->getDimLOD()) && 6314b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes (type0->getDimFaces() == type1->getDimFaces()) && 6324b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes (type0->getDimYuv() == type1->getDimYuv()) && 6334b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes (type0->getDimX() == type1->getDimX()) && 6344b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes (type0->getDimY() == type1->getDimY()) && 6354b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes (type0->getDimZ() == type1->getDimZ()); 6364b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes} 6374b3c34e6833e39bc89c2128002806b654b8e623dChris Wailes 6387ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 639326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams///////////////// 640565ac36ee479f9d7b83e2030ac9646a09cb886a1Jason Sams// 6416a121811e5d2e56e94747b36d15c7613ab2aedd4Stephen Hines 642326e0ddf89e8df2837752fbfd7a014814b32082cJason Samsnamespace android { 643326e0ddf89e8df2837752fbfd7a014814b32082cJason Samsnamespace renderscript { 644326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 645366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Samsvoid rsi_AllocationSyncAll(Context *rsc, RsAllocation va, RsAllocationUsageType src) { 646366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams Allocation *a = static_cast<Allocation *>(va); 647eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams a->sendDirty(rsc); 648366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams a->syncAll(rsc, src); 649366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams} 650366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams 651a23715148f7bda74e904fc553b70c9a49fd52a6eJason Samsvoid rsi_AllocationGenerateMipmaps(Context *rsc, RsAllocation va) { 65261a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams Allocation *alloc = static_cast<Allocation *>(va); 65361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams rsc->mHal.funcs.allocation.generateMipmaps(rsc, alloc); 65439f2ef6fed00a99c5c389e12c4597884027d4858Alex Sakhartchouk} 65539f2ef6fed00a99c5c389e12c4597884027d4858Alex Sakhartchouk 656807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsi_AllocationCopyToBitmap(Context *rsc, RsAllocation va, void *data, size_t sizeBytes) { 657807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams Allocation *a = static_cast<Allocation *>(va); 658807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const Type * t = a->getType(); 659807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams a->read(rsc, 0, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X, 6603bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams t->getDimX(), t->getDimY(), data, sizeBytes, 0); 661837e388700a48084489ba59d1d8cc5ece68b1535Jason Sams} 662837e388700a48084489ba59d1d8cc5ece68b1535Jason Sams 6634b45b8998e0d7038efaea80c70d23c086640b4e3Jason Samsvoid rsi_Allocation1DData(Context *rsc, RsAllocation va, uint32_t xoff, uint32_t lod, 664b81a0eb8180791e4eaab1253b59fa8bd562b046bAlex Sakhartchouk uint32_t count, const void *data, size_t sizeBytes) { 665326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams Allocation *a = static_cast<Allocation *>(va); 6664b45b8998e0d7038efaea80c70d23c086640b4e3Jason Sams a->data(rsc, xoff, lod, count, data, sizeBytes); 6675f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams} 6685f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 669cc8cea7477352898921044483a6c803e25d02665Miao Wangvoid rsi_Allocation1DElementData(Context *rsc, RsAllocation va, uint32_t x, 670cc8cea7477352898921044483a6c803e25d02665Miao Wang uint32_t lod, const void *data, size_t sizeBytes, size_t eoff) { 6715f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams Allocation *a = static_cast<Allocation *>(va); 672cc8cea7477352898921044483a6c803e25d02665Miao Wang a->elementData(rsc, x, 0, 0, data, eoff, sizeBytes); 6735f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams} 6745f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams 675cc8cea7477352898921044483a6c803e25d02665Miao Wangvoid rsi_AllocationElementData(Context *rsc, RsAllocation va, uint32_t x, uint32_t y, uint32_t z, 676cc8cea7477352898921044483a6c803e25d02665Miao Wang uint32_t lod, const void *data, size_t sizeBytes, size_t eoff) { 6775f0c84cf464dda719cef65fdc9b4d0980e86b98fJason Sams Allocation *a = static_cast<Allocation *>(va); 678cc8cea7477352898921044483a6c803e25d02665Miao Wang a->elementData(rsc, x, y, z, data, eoff, sizeBytes); 679326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams} 680326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 6814b45b8998e0d7038efaea80c70d23c086640b4e3Jason Samsvoid rsi_Allocation2DData(Context *rsc, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t lod, RsAllocationCubemapFace face, 682358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t w, uint32_t h, const void *data, size_t sizeBytes, size_t stride) { 683326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams Allocation *a = static_cast<Allocation *>(va); 684358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray a->data(rsc, xoff, yoff, lod, face, w, h, data, sizeBytes, stride); 685326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams} 686326e0ddf89e8df2837752fbfd7a014814b32082cJason Sams 6873bbc0fd40264ddae1592706d9023865b7b3e3195Jason Samsvoid rsi_Allocation3DData(Context *rsc, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, 6883bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t w, uint32_t h, uint32_t d, const void *data, size_t sizeBytes, size_t stride) { 6893bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams Allocation *a = static_cast<Allocation *>(va); 6903bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams a->data(rsc, xoff, yoff, zoff, lod, w, h, d, data, sizeBytes, stride); 6913bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams} 6923bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams 6933bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams 694807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Samsvoid rsi_AllocationRead(Context *rsc, RsAllocation va, void *data, size_t sizeBytes) { 695e579df42e85d9e00f53c42ef1b78dbd209dba989Jason Sams Allocation *a = static_cast<Allocation *>(va); 696807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const Type * t = a->getType(); 697cc8cea7477352898921044483a6c803e25d02665Miao Wang if(t->getDimZ()) { 698cc8cea7477352898921044483a6c803e25d02665Miao Wang a->read(rsc, 0, 0, 0, 0, t->getDimX(), t->getDimY(), t->getDimZ(), 699cc8cea7477352898921044483a6c803e25d02665Miao Wang data, sizeBytes, 0); 700cc8cea7477352898921044483a6c803e25d02665Miao Wang } else if(t->getDimY()) { 701807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams a->read(rsc, 0, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X, 7023bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams t->getDimX(), t->getDimY(), data, sizeBytes, 0); 703807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } else { 704807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams a->read(rsc, 0, 0, t->getDimX(), data, sizeBytes); 705807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams } 706807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams 707e579df42e85d9e00f53c42ef1b78dbd209dba989Jason Sams} 708e579df42e85d9e00f53c42ef1b78dbd209dba989Jason Sams 709afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid rsi_AllocationResize1D(Context *rsc, RsAllocation va, uint32_t dimX) { 71096abf819e50b59ba8cf886c13f894633eb0a24baJason Sams Allocation *a = static_cast<Allocation *>(va); 71196abf819e50b59ba8cf886c13f894633eb0a24baJason Sams a->resize1D(rsc, dimX); 71296abf819e50b59ba8cf886c13f894633eb0a24baJason Sams} 71396abf819e50b59ba8cf886c13f894633eb0a24baJason Sams 714afb743aca56c18beb7ab924e75cb6e070ef3e55aAlex Sakhartchoukvoid rsi_AllocationResize2D(Context *rsc, RsAllocation va, uint32_t dimX, uint32_t dimY) { 71596abf819e50b59ba8cf886c13f894633eb0a24baJason Sams Allocation *a = static_cast<Allocation *>(va); 71696abf819e50b59ba8cf886c13f894633eb0a24baJason Sams a->resize2D(rsc, dimX, dimY); 71796abf819e50b59ba8cf886c13f894633eb0a24baJason Sams} 71896abf819e50b59ba8cf886c13f894633eb0a24baJason Sams 719c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason SamsRsAllocation rsi_AllocationCreateTyped(Context *rsc, RsType vtype, 7208f615d682f9e7e2cd4de2e4478e0e76fc359922cStephen Hines RsAllocationMipmapControl mipmaps, 721099bc262f862cdeb547cf8a78fe9e0e92560f437Tim Murray uint32_t usages, uintptr_t ptr) { 7228f615d682f9e7e2cd4de2e4478e0e76fc359922cStephen Hines Allocation * alloc = Allocation::createAllocation(rsc, static_cast<Type *>(vtype), usages, mipmaps, (void*)ptr); 723eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams if (!alloc) { 72444bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 725eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams } 726f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams alloc->incUserRef(); 727f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams return alloc; 728f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams} 729f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams 730c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason SamsRsAllocation rsi_AllocationCreateFromBitmap(Context *rsc, RsType vtype, 7318f615d682f9e7e2cd4de2e4478e0e76fc359922cStephen Hines RsAllocationMipmapControl mipmaps, 732807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const void *data, size_t sizeBytes, uint32_t usages) { 733366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams Type *t = static_cast<Type *>(vtype); 734f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams 7358f615d682f9e7e2cd4de2e4478e0e76fc359922cStephen Hines RsAllocation vTexAlloc = rsi_AllocationCreateTyped(rsc, vtype, mipmaps, usages, 0); 736f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams Allocation *texAlloc = static_cast<Allocation *>(vTexAlloc); 73744bef6fba6244292b751387f3d6c31cca96c28adChris Wailes if (texAlloc == nullptr) { 738af12ac6a08651464f8d823add667c706f993b587Steve Block ALOGE("Memory allocation failure"); 73944bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 740f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams } 741f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams 742807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams texAlloc->data(rsc, 0, 0, 0, RS_ALLOCATION_CUBEMAP_FACE_POSITIVE_X, 74360c2796d821d9296003d4e5db025f8734d971a71Tim Murray t->getDimX(), t->getDimY(), data, sizeBytes, 0); 7448f615d682f9e7e2cd4de2e4478e0e76fc359922cStephen Hines if (mipmaps == RS_ALLOCATION_MIPMAP_FULL) { 74561a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams rsc->mHal.funcs.allocation.generateMipmaps(rsc, texAlloc); 746f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams } 747f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams 748eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams texAlloc->sendDirty(rsc); 749f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams return texAlloc; 750f0c1df480304a72ce41e7d4b088319cbd7f0938aJason Sams} 75184e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk 752c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason SamsRsAllocation rsi_AllocationCubeCreateFromBitmap(Context *rsc, RsType vtype, 7538f615d682f9e7e2cd4de2e4478e0e76fc359922cStephen Hines RsAllocationMipmapControl mipmaps, 754807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams const void *data, size_t sizeBytes, uint32_t usages) { 755366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams Type *t = static_cast<Type *>(vtype); 75684e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk 75784e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk // Cubemap allocation's faces should be Width by Width each. 75884e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk // Source data should have 6 * Width by Width pixels 75984e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk // Error checking is done in the java layer 7608f615d682f9e7e2cd4de2e4478e0e76fc359922cStephen Hines RsAllocation vTexAlloc = rsi_AllocationCreateTyped(rsc, vtype, mipmaps, usages, 0); 76184e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk Allocation *texAlloc = static_cast<Allocation *>(vTexAlloc); 76244bef6fba6244292b751387f3d6c31cca96c28adChris Wailes if (texAlloc == nullptr) { 763af12ac6a08651464f8d823add667c706f993b587Steve Block ALOGE("Memory allocation failure"); 76444bef6fba6244292b751387f3d6c31cca96c28adChris Wailes return nullptr; 76584e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk } 76684e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk 7679f8bc4fb7e9e48088dc6b0496afb35b34fc4c5afAlex Sakhartchouk uint32_t faceSize = t->getDimX(); 7689f8bc4fb7e9e48088dc6b0496afb35b34fc4c5afAlex Sakhartchouk uint32_t strideBytes = faceSize * 6 * t->getElementSizeBytes(); 7699f8bc4fb7e9e48088dc6b0496afb35b34fc4c5afAlex Sakhartchouk uint32_t copySize = faceSize * t->getElementSizeBytes(); 7709f8bc4fb7e9e48088dc6b0496afb35b34fc4c5afAlex Sakhartchouk 77184e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk uint8_t *sourcePtr = (uint8_t*)data; 772366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams for (uint32_t face = 0; face < 6; face ++) { 7739f8bc4fb7e9e48088dc6b0496afb35b34fc4c5afAlex Sakhartchouk for (uint32_t dI = 0; dI < faceSize; dI ++) { 774807fdc4b6f3fb893015ee136565d6151bb2332d3Jason Sams texAlloc->data(rsc, 0, dI, 0, (RsAllocationCubemapFace)face, 77560c2796d821d9296003d4e5db025f8734d971a71Tim Murray t->getDimX(), 1, sourcePtr + strideBytes * dI, copySize, 0); 7769f8bc4fb7e9e48088dc6b0496afb35b34fc4c5afAlex Sakhartchouk } 777366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams 778366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams // Move the data pointer to the next cube face 7799f8bc4fb7e9e48088dc6b0496afb35b34fc4c5afAlex Sakhartchouk sourcePtr += copySize; 780f8aafcfad92fcf37d4b55c749601de22441ac9bfAlex Sakhartchouk } 781366c9c85196675437a8dd74c1cf6b63ddbde3d6aJason Sams 7828f615d682f9e7e2cd4de2e4478e0e76fc359922cStephen Hines if (mipmaps == RS_ALLOCATION_MIPMAP_FULL) { 78361a4bb734b91ced09fbfee4214c6f253cb66e5f0Jason Sams rsc->mHal.funcs.allocation.generateMipmaps(rsc, texAlloc); 78484e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk } 78584e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk 786eb4fe18dd88634330f9566cbb9e785d8c7ec5813Jason Sams texAlloc->sendDirty(rsc); 78784e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk return texAlloc; 78884e4027f83b20af59f5b1fc52be6e45f159d3970Alex Sakhartchouk} 789099d7d33e55afeb3399f6e8cf8d665223ca94939Alex Sakhartchouk 79074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchoukvoid rsi_AllocationCopy2DRange(Context *rsc, 79174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk RsAllocation dstAlloc, 79274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstXoff, uint32_t dstYoff, 79374a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t dstMip, uint32_t dstFace, 79474a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t width, uint32_t height, 79574a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk RsAllocation srcAlloc, 79674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcXoff, uint32_t srcYoff, 79774a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk uint32_t srcMip, uint32_t srcFace) { 79874a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk Allocation *dst = static_cast<Allocation *>(dstAlloc); 79974a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk Allocation *src= static_cast<Allocation *>(srcAlloc); 80074a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk rsc->mHal.funcs.allocation.allocData2D(rsc, dst, dstXoff, dstYoff, dstMip, 80174a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk (RsAllocationCubemapFace)dstFace, 80274a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk width, height, 80374a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk src, srcXoff, srcYoff,srcMip, 80474a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk (RsAllocationCubemapFace)srcFace); 80574a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk} 80674a827988567a9d65954bb0d825a3ba4a97e2947Alex Sakhartchouk 8073bbc0fd40264ddae1592706d9023865b7b3e3195Jason Samsvoid rsi_AllocationCopy3DRange(Context *rsc, 8083bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams RsAllocation dstAlloc, 8093bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff, 8103bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t dstMip, 8113bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t width, uint32_t height, uint32_t depth, 8123bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams RsAllocation srcAlloc, 8133bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, 8143bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams uint32_t srcMip) { 8153bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams Allocation *dst = static_cast<Allocation *>(dstAlloc); 8163bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams Allocation *src= static_cast<Allocation *>(srcAlloc); 8173bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams rsc->mHal.funcs.allocation.allocData3D(rsc, dst, dstXoff, dstYoff, dstZoff, dstMip, 8183bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams width, height, depth, 8193bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams src, srcXoff, srcYoff, srcZoff, srcMip); 8203bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams} 8213bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams 8223bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams 823733396b67724162844ea2785c7495115dc5ee8d8Jason Samsvoid * rsi_AllocationGetSurface(Context *rsc, RsAllocation valloc) { 82441e373d91a60043afa0f9abd026218b49cbc1201Jason Sams Allocation *alloc = static_cast<Allocation *>(valloc); 825733396b67724162844ea2785c7495115dc5ee8d8Jason Sams void *s = alloc->getSurface(rsc); 826733396b67724162844ea2785c7495115dc5ee8d8Jason Sams return s; 8273522f40418fdf877f5a136475dbf75e57a3b7c77Jason Sams} 8283522f40418fdf877f5a136475dbf75e57a3b7c77Jason Sams 8297ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid rsi_AllocationSetSurface(Context *rsc, RsAllocation valloc, RsNativeWindow sur) { 8307ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams Allocation *alloc = static_cast<Allocation *>(valloc); 8317ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams alloc->setSurface(rsc, sur); 8327ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 8337ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 8347ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid rsi_AllocationIoSend(Context *rsc, RsAllocation valloc) { 8357ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams Allocation *alloc = static_cast<Allocation *>(valloc); 8367ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams alloc->ioSend(rsc); 8377ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 8387ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 8397ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Samsvoid rsi_AllocationIoReceive(Context *rsc, RsAllocation valloc) { 8407ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams Allocation *alloc = static_cast<Allocation *>(valloc); 8417ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams alloc->ioReceive(rsc); 8427ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams} 8437ac2a4dda4d20ca1f1b714e129a3a08f63178c18Jason Sams 844af7373fe53edba115746430553e8edfddd03ae9eStephen Hinesvoid *rsi_AllocationGetPointer(Context *rsc, RsAllocation valloc, 845b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams uint32_t lod, RsAllocationCubemapFace face, 846b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams uint32_t z, uint32_t array, size_t *stride, size_t strideLen) { 847b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams Allocation *alloc = static_cast<Allocation *>(valloc); 8480e61af91ecd0d1276ddfc1c43bd61f6587e7026bTim Murray rsAssert(strideLen == sizeof(size_t)); 849b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams 850af7373fe53edba115746430553e8edfddd03ae9eStephen Hines return alloc->getPointer(rsc, lod, face, z, array, stride); 851b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams} 852b8a94e26c0a5e8f58d5b6ed04e46b411e95b77a4Jason Sams 853509ea5c832a865bc9083d53f1f058377a689bab3Tim Murrayvoid rsi_Allocation1DRead(Context *rsc, RsAllocation va, uint32_t xoff, uint32_t lod, 854509ea5c832a865bc9083d53f1f058377a689bab3Tim Murray uint32_t count, void *data, size_t sizeBytes) { 855509ea5c832a865bc9083d53f1f058377a689bab3Tim Murray Allocation *a = static_cast<Allocation *>(va); 8563bbc0fd40264ddae1592706d9023865b7b3e3195Jason Sams rsc->mHal.funcs.allocation.read1D(rsc, a, xoff, lod, count, data, sizeBytes); 857509ea5c832a865bc9083d53f1f058377a689bab3Tim Murray} 858509ea5c832a865bc9083d53f1f058377a689bab3Tim Murray 859cc8cea7477352898921044483a6c803e25d02665Miao Wangvoid rsi_AllocationElementRead(Context *rsc, RsAllocation va, uint32_t x, uint32_t y, uint32_t z, 860cc8cea7477352898921044483a6c803e25d02665Miao Wang uint32_t lod, void *data, size_t sizeBytes, size_t eoff) { 861cc8cea7477352898921044483a6c803e25d02665Miao Wang Allocation *a = static_cast<Allocation *>(va); 862cc8cea7477352898921044483a6c803e25d02665Miao Wang a->elementRead(rsc, x, y, z, data, eoff, sizeBytes); 863cc8cea7477352898921044483a6c803e25d02665Miao Wang} 864cc8cea7477352898921044483a6c803e25d02665Miao Wang 8657b3e3093f745134345dadf89498ad16e1f9c0e71Tim Murrayvoid rsi_Allocation2DRead(Context *rsc, RsAllocation va, uint32_t xoff, uint32_t yoff, 8667b3e3093f745134345dadf89498ad16e1f9c0e71Tim Murray uint32_t lod, RsAllocationCubemapFace face, uint32_t w, 867358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray uint32_t h, void *data, size_t sizeBytes, size_t stride) { 8687b3e3093f745134345dadf89498ad16e1f9c0e71Tim Murray Allocation *a = static_cast<Allocation *>(va); 869358747a3118301c5faeee73c98dd5f839bbfb54aTim Murray a->read(rsc, xoff, yoff, lod, face, w, h, data, sizeBytes, stride); 8707b3e3093f745134345dadf89498ad16e1f9c0e71Tim Murray} 8717b3e3093f745134345dadf89498ad16e1f9c0e71Tim Murray 872cc8cea7477352898921044483a6c803e25d02665Miao Wangvoid rsi_Allocation3DRead(Context *rsc, RsAllocation va, 873cc8cea7477352898921044483a6c803e25d02665Miao Wang uint32_t xoff, uint32_t yoff, uint32_t zoff, 874cc8cea7477352898921044483a6c803e25d02665Miao Wang uint32_t lod, uint32_t w, uint32_t h, uint32_t d, 875cc8cea7477352898921044483a6c803e25d02665Miao Wang void *data, size_t sizeBytes, size_t stride) { 876cc8cea7477352898921044483a6c803e25d02665Miao Wang Allocation *a = static_cast<Allocation *>(va); 877cc8cea7477352898921044483a6c803e25d02665Miao Wang a->read(rsc, xoff, yoff, zoff, lod, w, h, d, data, sizeBytes, stride); 878cc8cea7477352898921044483a6c803e25d02665Miao Wang} 879cc8cea7477352898921044483a6c803e25d02665Miao Wang 880cfea6c13075aa255712e5a09a54eccbc84b0b122Jason SamsRsAllocation rsi_AllocationAdapterCreate(Context *rsc, RsType vwindow, RsAllocation vbase) { 881cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 882cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 883cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams Allocation * alloc = Allocation::createAdapter(rsc, 884cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams static_cast<Allocation *>(vbase), static_cast<Type *>(vwindow)); 885cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams if (!alloc) { 886cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams return nullptr; 887cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams } 888cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams alloc->incUserRef(); 889cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams return alloc; 890cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams} 891cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 892cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Samsvoid rsi_AllocationAdapterOffset(Context *rsc, RsAllocation va, const uint32_t *offsets, size_t len) { 893442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams Allocation *a = static_cast<Allocation *>(va); 894442b7ff3ca1dffd1555d34e0afc1bdbb6387e8e2Jason Sams a->adapterOffset(rsc, offsets, len); 895cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams} 896cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 897cfea6c13075aa255712e5a09a54eccbc84b0b122Jason Sams 898c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams} 899c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams} 900c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams 901c2ce707a3d1a8eae79bcf1c749afc6d6e7969ad9Tim Murrayextern "C" const void * rsaAllocationGetType(RsContext con, RsAllocation va) { 902c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams Allocation *a = static_cast<Allocation *>(va); 903c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams a->getType()->incUserRef(); 904c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams 905c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams return a->getType(); 906c975cf4a71b63ccbd20f1f3b3341c5f2e6025b45Jason Sams} 907