RenderScript HIDL client-side implementation
- Client-side implementation converts RenderScript HAL (top level)
from C/C++ to HIDL
- Fallback to default CPU implementation if it could not find a
matching RS driver through HIDL.
- HIDL adaptation and Graphics fallback are handled by two
corresponding singleton classes.
- Remove HOST_STATIC version of libRS from the makefile. The host
version of libRS is not used at all, and generating build errors with
HIDL.
- Always use fallback path for RS graphics API.
- Removed reference to Device from rsContext.cpp. In our current
implementation, Device is equivalent to HIDL IDevice class.
Thus, our HIDL HAL no longer provides DeviceCreate and DeviceDestroy,
making Device no longer useful to Context.
- Wait for the debugger to attach if RS_CONTEXT_WAIT_FOR_ATTACH flag
is set. The waiting part is now moved out of the context class.
Bug: 34396220
Test: mm, all CTS tests pass on bullhead, LiveWallpaper apps using RS
graphics APIs run well.
Merged-In: I86493b11328d5d8c904cebafa99243e92dfdf6a7
Change-Id: I86493b11328d5d8c904cebafa99243e92dfdf6a7
diff --git a/rsApiStubs.cpp b/rsApiStubs.cpp
new file mode 100644
index 0000000..bc08d7a
--- /dev/null
+++ b/rsApiStubs.cpp
@@ -0,0 +1,788 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "rsApiStubs.h"
+#include "rsHidlAdaptation.h"
+#include "rsFallbackAdaptation.h"
+#include "cpp/rsDispatch.h"
+
+// TODO: Figure out how to use different declared types for the two interfaces
+// to avoid the confusion. Currently, RsContext is used as the API type for
+// both the client interface and the dispatch table interface, but at the
+// client interface it's really RsContextWrapper* instead.
+// TODO: Figure out how to better design class hierarchy for all these Contexts.
+// RsContextWrapper wraps the RsContext and corresponding dispatchTable pointer.
+// The wrapper object is created during ContextCreate, and the address of the
+// object is returned to Java / C++, instead of the RsContext handle.
+// The wrapper object is destroyed during ContextDestroy to release the memory.
+struct RsContextWrapper {
+ RsContext context;
+ const dispatchTable* dispatch;
+};
+
+#define RS_DISPATCH(opaqueWrapper, func, ...) \
+ [&]() { \
+ const RsContextWrapper *wrapper = reinterpret_cast<RsContextWrapper *>(opaqueWrapper); \
+ RsContext context = wrapper->context; \
+ return wrapper->dispatch->func(context, ##__VA_ARGS__); \
+ }()
+
+// Device
+// These API stubs are kept here to maintain backward compatibility,
+// but they are not actually doing anything.
+
+extern "C" RsDevice rsDeviceCreate()
+{
+ return (void *) 1;
+}
+extern "C" void rsDeviceDestroy(RsDevice dev)
+{
+}
+extern "C" void rsDeviceSetConfig(RsDevice dev, RsDeviceParam p, int32_t value)
+{
+}
+
+/*
+ * This global will be found by the debugger and will have its value flipped.
+ * It's independent of the Context class to allow the debugger to do the above
+ * without knowing the type makeup. This allows the debugger to be attached at
+ * an earlier stage.
+ */
+extern "C" int gDebuggerPresent = 0;
+
+// Context
+
+extern "C" RsContext rsContextCreate(RsDevice vdev, uint32_t version, uint32_t sdkVersion,
+ RsContextType ct, uint32_t flags)
+{
+ RsHidlAdaptation& instance = RsHidlAdaptation::GetInstance();
+ RsContext context = instance.GetEntryFuncs()->ContextCreate(vdev, version, sdkVersion, ct, flags);
+ // Wait for debugger to attach if RS_CONTEXT_WAIT_FOR_ATTACH flag set.
+ if (flags & RS_CONTEXT_WAIT_FOR_ATTACH) {
+ while (!gDebuggerPresent) {
+ sleep(0);
+ }
+ }
+
+ RsContextWrapper *ctxWrapper = new RsContextWrapper{context, instance.GetEntryFuncs()};
+ return (RsContext) ctxWrapper;
+}
+
+extern "C" void rsContextDestroy (RsContext ctxWrapper)
+{
+ RS_DISPATCH(ctxWrapper, ContextDestroy);
+
+ delete (RsContextWrapper *)ctxWrapper;
+}
+
+extern "C" void rsContextFinish (RsContext ctxWrapper)
+{
+ RS_DISPATCH(ctxWrapper, ContextFinish);
+}
+
+extern "C" void rsContextDump (RsContext ctxWrapper, int32_t bits)
+{
+ RS_DISPATCH(ctxWrapper, ContextDump, bits);
+}
+
+extern "C" void rsContextSetPriority (RsContext ctxWrapper, int32_t priority)
+{
+ RS_DISPATCH(ctxWrapper, ContextSetPriority, priority);
+}
+
+extern "C" void rsContextDestroyWorker (RsContext ctxWrapper)
+{
+}
+
+extern "C" RsMessageToClientType rsContextGetMessage (RsContext ctxWrapper, void * data, size_t data_length,
+ size_t * receiveLen, size_t receiveLen_length,
+ uint32_t * usrID, size_t usrID_length)
+{
+ return RS_DISPATCH(ctxWrapper, ContextGetMessage, data, data_length,
+ receiveLen, receiveLen_length,
+ usrID, usrID_length);
+}
+
+extern "C" RsMessageToClientType rsContextPeekMessage (RsContext ctxWrapper,
+ size_t * receiveLen, size_t receiveLen_length,
+ uint32_t * usrID, size_t usrID_length)
+{
+ return RS_DISPATCH(ctxWrapper, ContextPeekMessage,
+ receiveLen, receiveLen_length,
+ usrID, usrID_length);
+}
+
+extern "C" void rsContextSendMessage (RsContext ctxWrapper, uint32_t id, const uint8_t * data, size_t data_length)
+{
+ RS_DISPATCH(ctxWrapper, ContextSendMessage, id, data, data_length);
+}
+
+extern "C" void rsContextInitToClient (RsContext ctxWrapper)
+{
+ RS_DISPATCH(ctxWrapper, ContextInitToClient);
+}
+
+extern "C" void rsContextDeinitToClient (RsContext ctxWrapper)
+{
+ RS_DISPATCH(ctxWrapper, ContextDeinitToClient);
+}
+
+extern "C" void rsContextSetCacheDir (RsContext ctxWrapper, const char * cacheDir, size_t cacheDir_length)
+{
+ RS_DISPATCH(ctxWrapper, ContextSetCacheDir, cacheDir, cacheDir_length);
+}
+
+extern "C" void rsaContextSetNativeLibDir(RsContext ctxWrapper, char *libDir, size_t length)
+{
+}
+
+// BaseObject
+
+extern "C" void rsAssignName (RsContext ctxWrapper, RsObjectBase obj, const char * name, size_t name_length)
+{
+ RS_DISPATCH(ctxWrapper, AssignName, obj, name, name_length);
+}
+
+extern "C" void rsaGetName(RsContext ctxWrapper, void * obj, const char **name)
+{
+ RS_DISPATCH(ctxWrapper, GetName, obj, name);
+}
+
+extern "C" void rsObjDestroy (RsContext ctxWrapper, RsAsyncVoidPtr objPtr)
+{
+ RS_DISPATCH(ctxWrapper, ObjDestroy, objPtr);
+}
+
+// Element
+
+extern "C" RsElement rsElementCreate (RsContext ctxWrapper, RsDataType mType, RsDataKind mKind,
+ bool mNormalized, uint32_t mVectorSize)
+{
+ return RS_DISPATCH(ctxWrapper, ElementCreate, mType, mKind, mNormalized, mVectorSize);
+}
+
+extern "C" RsElement rsElementCreate2 (RsContext ctxWrapper, const RsElement * elements, size_t elements_length,
+ const char ** names, size_t names_length_length, const size_t * names_length,
+ const uint32_t * arraySize, size_t arraySize_length)
+{
+ return RS_DISPATCH(ctxWrapper, ElementCreate2,
+ elements, elements_length,
+ names, names_length_length, names_length,
+ arraySize, arraySize_length);
+}
+
+extern "C" void rsaElementGetNativeData(RsContext ctxWrapper, RsElement elem, uint32_t *elemData, uint32_t elemDataSize)
+{
+ RS_DISPATCH(ctxWrapper, ElementGetNativeData, elem, elemData, elemDataSize);
+}
+
+extern "C" void rsaElementGetSubElements(RsContext ctxWrapper, RsElement elem, uintptr_t *ids, const char **names,
+ size_t *arraySizes, uint32_t dataSize)
+{
+ RS_DISPATCH(ctxWrapper, ElementGetSubElements, elem, ids, names, arraySizes, dataSize);
+}
+
+// Type
+
+extern "C" RsType rsTypeCreate (RsContext ctxWrapper, RsElement e, uint32_t dimX, uint32_t dimY, uint32_t dimZ,
+ bool mipmaps, bool faces, uint32_t yuv)
+{
+ return RS_DISPATCH(ctxWrapper, TypeCreate, e, dimX, dimY, dimZ, mipmaps, faces, yuv);
+}
+
+extern "C" RsType rsTypeCreate2 (RsContext ctxWrapper, const RsTypeCreateParams * dat, size_t dat_length)
+{
+ return nullptr;
+}
+
+extern "C" void rsaTypeGetNativeData(RsContext ctxWrapper, RsType type, uintptr_t *typeData, uint32_t typeDataSize)
+{
+ RS_DISPATCH(ctxWrapper, TypeGetNativeData, type, typeData, typeDataSize);
+}
+
+
+// Allocation
+
+extern "C" RsAllocation rsAllocationCreateTyped (RsContext ctxWrapper, RsType vtype, RsAllocationMipmapControl mipmaps,
+ uint32_t usages, uintptr_t ptr)
+{
+ return RS_DISPATCH(ctxWrapper, AllocationCreateTyped, vtype, mipmaps, usages, ptr);
+}
+
+extern "C" RsAllocation rsAllocationCreateFromBitmap (RsContext ctxWrapper, RsType vtype, RsAllocationMipmapControl mipmaps,
+ const void * data, size_t data_length, uint32_t usages)
+{
+ return RS_DISPATCH(ctxWrapper, AllocationCreateFromBitmap, vtype, mipmaps, data, data_length, usages);
+}
+
+extern "C" RsAllocation rsAllocationCubeCreateFromBitmap (RsContext ctxWrapper, RsType vtype, RsAllocationMipmapControl mipmaps,
+ const void * data, size_t data_length, uint32_t usages)
+{
+ return RS_DISPATCH(ctxWrapper, AllocationCubeCreateFromBitmap, vtype, mipmaps, data, data_length, usages);
+}
+
+extern "C" RsAllocation rsAllocationAdapterCreate (RsContext ctxWrapper, RsType vtype, RsAllocation baseAlloc)
+{
+ return RS_DISPATCH(ctxWrapper, AllocationAdapterCreate, vtype, baseAlloc);
+}
+
+extern "C" const void * rsaAllocationGetType(RsContext ctxWrapper, RsAllocation va)
+{
+ return RS_DISPATCH(ctxWrapper, AllocationGetType, va);
+}
+
+extern "C" RsNativeWindow rsAllocationGetSurface (RsContext ctxWrapper, RsAllocation alloc)
+{
+ return RS_DISPATCH(ctxWrapper, AllocationGetSurface, alloc);
+}
+
+extern "C" void rsAllocationSetupBufferQueue (RsContext ctxWrapper, RsAllocation alloc, uint32_t numAlloc)
+{
+ RS_DISPATCH(ctxWrapper, AllocationSetupBufferQueue, alloc, numAlloc);
+}
+
+extern "C" void rsAllocationShareBufferQueue (RsContext ctxWrapper, RsAllocation alloc1, RsAllocation alloc2)
+{
+ RS_DISPATCH(ctxWrapper, AllocationShareBufferQueue, alloc1, alloc2);
+}
+
+extern "C" void rsAllocationSetSurface (RsContext ctxWrapper, RsAllocation alloc, RsNativeWindow sur)
+{
+ RS_DISPATCH(ctxWrapper, AllocationSetSurface, alloc, sur);
+}
+
+extern "C" void rsAllocationAdapterOffset (RsContext ctxWrapper, RsAllocation alloc,
+ const uint32_t * offsets, size_t offsets_length)
+{
+ RS_DISPATCH(ctxWrapper, AllocationAdapterOffset, alloc, offsets, offsets_length);
+}
+
+extern "C" void rsAllocationCopyToBitmap (RsContext ctxWrapper, RsAllocation alloc, void * data, size_t data_length)
+{
+ RS_DISPATCH(ctxWrapper, AllocationCopyToBitmap, alloc, data, data_length);
+}
+
+extern "C" void * rsAllocationGetPointer (RsContext ctxWrapper, RsAllocation va, uint32_t lod, RsAllocationCubemapFace face,
+ uint32_t z, uint32_t array, size_t * stride, size_t stride_length)
+{
+ return RS_DISPATCH(ctxWrapper, AllocationGetPointer, va, lod, face, z, array, stride, stride_length);
+}
+
+extern "C" void rsAllocation1DData (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t lod, uint32_t count,
+ const void * data, size_t data_length)
+{
+ RS_DISPATCH(ctxWrapper, Allocation1DData, va, xoff, lod, count, data, data_length);
+}
+
+extern "C" void rsAllocation1DElementData (RsContext ctxWrapper, RsAllocation va, uint32_t x, uint32_t lod,
+ const void * data, size_t data_length, size_t comp_offset)
+{
+ RS_DISPATCH(ctxWrapper, Allocation1DElementData, va, x, lod, data, data_length, comp_offset);
+}
+
+extern "C" void rsAllocationElementData (RsContext ctxWrapper, RsAllocation va, uint32_t x, uint32_t y, uint32_t z,
+ uint32_t lod, const void * data, size_t data_length, size_t comp_offset)
+{
+ RS_DISPATCH(ctxWrapper, AllocationElementData, va, x, y, z, lod, data, data_length, comp_offset);
+}
+
+extern "C" void rsAllocation2DData (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t lod,
+ RsAllocationCubemapFace face, uint32_t w, uint32_t h,
+ const void * data, size_t data_length, size_t stride)
+{
+ RS_DISPATCH(ctxWrapper, Allocation2DData, va, xoff, yoff, lod, face, w, h, data, data_length, stride);
+}
+
+extern "C" void rsAllocation3DData (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t zoff,
+ uint32_t lod, uint32_t w, uint32_t h, uint32_t d,
+ const void * data, size_t data_length, size_t stride)
+{
+ RS_DISPATCH(ctxWrapper, Allocation3DData, va, xoff, yoff, zoff, lod, w, h, d, data, data_length, stride);
+}
+
+extern "C" void rsAllocationGenerateMipmaps (RsContext ctxWrapper, RsAllocation va)
+{
+ RS_DISPATCH(ctxWrapper, AllocationGenerateMipmaps, va);
+}
+
+extern "C" void rsAllocationRead (RsContext ctxWrapper, RsAllocation va, void * data, size_t data_length)
+{
+ RS_DISPATCH(ctxWrapper, AllocationRead, va, data, data_length);
+}
+
+extern "C" void rsAllocation1DRead (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t lod, uint32_t count,
+ void * data, size_t data_length)
+{
+ RS_DISPATCH(ctxWrapper, Allocation1DRead, va, xoff, lod, count, data, data_length);
+}
+
+extern "C" void rsAllocationElementRead (RsContext ctxWrapper, RsAllocation va, uint32_t x, uint32_t y, uint32_t z,
+ uint32_t lod, void * data, size_t data_length, size_t comp_offset)
+{
+ RS_DISPATCH(ctxWrapper, AllocationElementRead, va, x, y, z, lod, data, data_length, comp_offset);
+}
+
+extern "C" void rsAllocation2DRead (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t lod,
+ RsAllocationCubemapFace face, uint32_t w, uint32_t h,
+ void * data, size_t data_length, size_t stride)
+{
+ RS_DISPATCH(ctxWrapper, Allocation2DRead, va, xoff, yoff, lod, face, w, h, data, data_length, stride);
+}
+
+extern "C" void rsAllocation3DRead (RsContext ctxWrapper, RsAllocation va, uint32_t xoff, uint32_t yoff, uint32_t zoff,
+ uint32_t lod, uint32_t w, uint32_t h, uint32_t d,
+ void * data, size_t data_length, size_t stride)
+{
+ RS_DISPATCH(ctxWrapper, Allocation3DRead, va, xoff, yoff, zoff, lod, w, h, d, data, data_length, stride);
+}
+
+extern "C" void rsAllocationSyncAll (RsContext ctxWrapper, RsAllocation va, RsAllocationUsageType src)
+{
+ RS_DISPATCH(ctxWrapper, AllocationSyncAll, va, src);
+}
+
+extern "C" void rsAllocationResize1D (RsContext ctxWrapper, RsAllocation va, uint32_t dimX)
+{
+ RS_DISPATCH(ctxWrapper, AllocationResize1D, va, dimX);
+}
+
+extern "C" void rsAllocationCopy2DRange (RsContext ctxWrapper,
+ RsAllocation dest,
+ uint32_t destXoff, uint32_t destYoff,
+ uint32_t destMip, uint32_t destFace,
+ uint32_t width, uint32_t height,
+ RsAllocation src,
+ uint32_t srcXoff, uint32_t srcYoff,
+ uint32_t srcMip, uint32_t srcFace)
+{
+ RS_DISPATCH(ctxWrapper, AllocationCopy2DRange, dest, destXoff, destYoff, destMip, destFace,
+ width, height, src, srcXoff, srcYoff, srcMip, srcFace);
+}
+
+extern "C" void rsAllocationCopy3DRange (RsContext ctxWrapper,
+ RsAllocation dest,
+ uint32_t destXoff, uint32_t destYoff, uint32_t destZoff,
+ uint32_t destMip,
+ uint32_t width, uint32_t height, uint32_t depth,
+ RsAllocation src,
+ uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff,
+ uint32_t srcMip)
+{
+ RS_DISPATCH(ctxWrapper, AllocationCopy3DRange,
+ dest, destXoff, destYoff, destZoff, destMip,
+ width, height, depth, src, srcXoff, srcYoff, srcZoff, srcMip);
+}
+
+extern "C" void rsAllocationIoSend (RsContext ctxWrapper, RsAllocation alloc)
+{
+ RS_DISPATCH(ctxWrapper, AllocationIoSend, alloc);
+}
+
+extern "C" int64_t rsAllocationIoReceive (RsContext ctxWrapper, RsAllocation alloc)
+{
+ return RS_DISPATCH(ctxWrapper, AllocationIoReceive, alloc);
+}
+
+// ScriptGroup
+
+extern "C" void rsScriptGroupExecute (RsContext ctxWrapper, RsScriptGroup group)
+{
+ RS_DISPATCH(ctxWrapper, ScriptGroupExecute, group);
+}
+
+extern "C" RsScriptGroup2 rsScriptGroup2Create (RsContext ctxWrapper, const char * name, size_t name_length,
+ const char * cacheDir, size_t cacheDir_length,
+ RsClosure * closures, size_t closures_length)
+{
+ return RS_DISPATCH(ctxWrapper, ScriptGroup2Create,
+ name, name_length,
+ cacheDir, cacheDir_length,
+ closures, closures_length);
+}
+
+extern "C" RsClosure rsClosureCreate (RsContext ctxWrapper, RsScriptKernelID kernelID, RsAllocation returnValue,
+ RsScriptFieldID * fieldIDs, size_t fieldIDs_length,
+ const int64_t * values, size_t values_length,
+ const int * sizes, size_t sizes_length,
+ RsClosure * depClosures, size_t depClosures_length,
+ RsScriptFieldID * depFieldIDs, size_t depFieldIDs_length)
+{
+ return RS_DISPATCH(ctxWrapper, ClosureCreate, kernelID, returnValue, fieldIDs, fieldIDs_length,
+ const_cast<int64_t *>(values), values_length,
+ const_cast<int *>(sizes), sizes_length,
+ depClosures, depClosures_length, depFieldIDs, depFieldIDs_length);
+}
+
+extern "C" RsClosure rsInvokeClosureCreate (RsContext ctxWrapper, RsScriptInvokeID invokeID,
+ const void * params, size_t params_length,
+ const RsScriptFieldID * fieldIDs, size_t fieldIDs_length,
+ const int64_t * values, size_t values_length,
+ const int * sizes, size_t sizes_length)
+{
+ return RS_DISPATCH(ctxWrapper, InvokeClosureCreate, invokeID,
+ params, params_length,
+ fieldIDs, fieldIDs_length,
+ values, values_length,
+ sizes, sizes_length);
+}
+
+extern "C" void rsClosureSetArg (RsContext ctxWrapper, RsClosure closureID, uint32_t index,
+ uintptr_t value, int valueSize)
+{
+ RS_DISPATCH(ctxWrapper, ClosureSetArg, closureID, index, value, valueSize);
+}
+
+extern "C" void rsClosureSetGlobal (RsContext ctxWrapper, RsClosure closureID, RsScriptFieldID fieldID,
+ int64_t value, int valueSize)
+{
+ RS_DISPATCH(ctxWrapper, ClosureSetGlobal, closureID, fieldID, value, valueSize);
+}
+
+extern "C" RsScriptKernelID rsScriptKernelIDCreate (RsContext ctxWrapper, RsScript sid, int slot, int sig)
+{
+ return RS_DISPATCH(ctxWrapper, ScriptKernelIDCreate, sid, slot, sig);
+}
+
+extern "C" RsScriptFieldID rsScriptFieldIDCreate (RsContext ctxWrapper, RsScript sid, int slot)
+{
+ return RS_DISPATCH(ctxWrapper, ScriptFieldIDCreate, sid, slot);
+}
+
+extern "C" RsScriptGroup rsScriptGroupCreate (RsContext ctxWrapper, RsScriptKernelID * kernels, size_t kernels_length,
+ RsScriptKernelID * src, size_t src_length,
+ RsScriptKernelID * dstK, size_t dstK_length,
+ RsScriptFieldID * dstF, size_t dstF_length,
+ const RsType * type, size_t type_length)
+{
+ return RS_DISPATCH(ctxWrapper, ScriptGroupCreate,
+ kernels, kernels_length,
+ src, src_length, dstK, dstK_length,
+ dstF, dstF_length, type, type_length);
+}
+
+extern "C" void rsScriptGroupSetOutput (RsContext ctxWrapper, RsScriptGroup group,
+ RsScriptKernelID kernel, RsAllocation alloc)
+{
+ RS_DISPATCH(ctxWrapper, ScriptGroupSetOutput, group, kernel, alloc);
+}
+
+extern "C" void rsScriptGroupSetInput (RsContext ctxWrapper, RsScriptGroup group,
+ RsScriptKernelID kernel, RsAllocation alloc)
+{
+ RS_DISPATCH(ctxWrapper, ScriptGroupSetInput, group, kernel, alloc);
+}
+
+
+// Sampler
+extern "C" RsSampler rsSamplerCreate (RsContext ctxWrapper, RsSamplerValue magFilter, RsSamplerValue minFilter,
+ RsSamplerValue wrapS, RsSamplerValue wrapT, RsSamplerValue wrapR,
+ float mAniso)
+{
+ return RS_DISPATCH(ctxWrapper, SamplerCreate, magFilter, minFilter, wrapS, wrapT, wrapR, mAniso);
+}
+
+// Script
+
+extern "C" RsScript rsScriptCCreate (RsContext ctxWrapper, const char * resName, size_t resName_length,
+ const char * cacheDir, size_t cacheDir_length,
+ const char * text, size_t text_length)
+{
+ return RS_DISPATCH(ctxWrapper, ScriptCCreate, resName, resName_length, cacheDir, cacheDir_length, text, text_length);
+}
+
+extern "C" RsScript rsScriptIntrinsicCreate (RsContext ctxWrapper, uint32_t id, RsElement eid)
+{
+ return RS_DISPATCH(ctxWrapper, ScriptIntrinsicCreate, id, eid);
+}
+
+extern "C" void rsScriptBindAllocation (RsContext ctxWrapper, RsScript vtm, RsAllocation va, uint32_t slot)
+{
+ RS_DISPATCH(ctxWrapper, ScriptBindAllocation, vtm, va, slot);
+}
+
+extern "C" void rsScriptSetTimeZone (RsContext ctxWrapper, RsScript s, const char * timeZone, size_t timeZone_length)
+{
+ RS_DISPATCH(ctxWrapper, ScriptSetTimeZone, s, timeZone, timeZone_length);
+}
+
+extern "C" RsScriptInvokeID rsScriptInvokeIDCreate (RsContext ctxWrapper, RsScript s, uint32_t slot)
+{
+ return RS_DISPATCH(ctxWrapper, ScriptInvokeIDCreate, s, slot);
+}
+
+extern "C" void rsScriptInvoke (RsContext ctxWrapper, RsScript s, uint32_t slot)
+{
+ RS_DISPATCH(ctxWrapper, ScriptInvoke, s, slot);
+}
+
+extern "C" void rsScriptInvokeV (RsContext ctxWrapper, RsScript s, uint32_t slot, const void * data, size_t data_length)
+{
+ RS_DISPATCH(ctxWrapper, ScriptInvokeV, s, slot, data, data_length);
+}
+
+extern "C" void rsScriptForEach (RsContext ctxWrapper, RsScript s, uint32_t slot,
+ RsAllocation ain, RsAllocation aout,
+ const void * usr, size_t usr_length,
+ const RsScriptCall * sc, size_t sc_length)
+{
+ RS_DISPATCH(ctxWrapper, ScriptForEach, s, slot, ain, aout, usr, usr_length, sc, sc_length);
+}
+
+extern "C" void rsScriptForEachMulti (RsContext ctxWrapper, RsScript s, uint32_t slot,
+ RsAllocation * ains, size_t ains_length, RsAllocation aout,
+ const void * usr, size_t usr_length,
+ const RsScriptCall * sc, size_t sc_length)
+{
+ RS_DISPATCH(ctxWrapper, ScriptForEachMulti, s, slot, ains, ains_length, aout, usr, usr_length, sc, sc_length);
+}
+
+extern "C" void rsScriptReduce (RsContext ctxWrapper, RsScript s, uint32_t slot,
+ RsAllocation * ains, size_t ains_length, RsAllocation aout,
+ const RsScriptCall * sc, size_t sc_length)
+{
+ RS_DISPATCH(ctxWrapper, ScriptReduce, s, slot, ains, ains_length, aout, sc, sc_length);
+}
+
+extern "C" void rsScriptSetVarI (RsContext ctxWrapper, RsScript s, uint32_t slot, int value)
+{
+ RS_DISPATCH(ctxWrapper, ScriptSetVarI, s, slot, value);
+}
+
+extern "C" void rsScriptSetVarObj (RsContext ctxWrapper, RsScript s, uint32_t slot, RsObjectBase value)
+{
+ RS_DISPATCH(ctxWrapper, ScriptSetVarObj, s, slot, value);
+}
+
+extern "C" void rsScriptSetVarJ (RsContext ctxWrapper, RsScript s, uint32_t slot, int64_t value)
+{
+ RS_DISPATCH(ctxWrapper, ScriptSetVarJ, s, slot, value);
+}
+
+extern "C" void rsScriptSetVarF (RsContext ctxWrapper, RsScript s, uint32_t slot, float value)
+{
+ RS_DISPATCH(ctxWrapper, ScriptSetVarF, s, slot, value);
+}
+
+extern "C" void rsScriptSetVarD (RsContext ctxWrapper, RsScript s, uint32_t slot, double value)
+{
+ RS_DISPATCH(ctxWrapper, ScriptSetVarD, s, slot, value);
+}
+
+extern "C" void rsScriptSetVarV (RsContext ctxWrapper, RsScript s, uint32_t slot,
+ const void * data, size_t data_length)
+{
+ RS_DISPATCH(ctxWrapper, ScriptSetVarV, s, slot, data, data_length);
+}
+
+extern "C" void rsScriptGetVarV (RsContext ctxWrapper, RsScript s, uint32_t slot,
+ void * data, size_t data_length)
+{
+ RS_DISPATCH(ctxWrapper, ScriptGetVarV, s, slot, data, data_length);
+}
+
+extern "C" void rsScriptSetVarVE (RsContext ctxWrapper, RsScript s, uint32_t slot,
+ const void * data, size_t data_length,
+ RsElement e, const uint32_t * dims, size_t dims_length)
+{
+ RS_DISPATCH(ctxWrapper, ScriptSetVarVE, s, slot, data, data_length, e, dims, dims_length);
+}
+
+
+// Graphics
+/* The following API are deprecated. */
+
+RsContext rsContextCreateGL(RsDevice vdev, uint32_t version, uint32_t sdkVersion,
+ RsSurfaceConfig sc, uint32_t dpi)
+{
+ RsFallbackAdaptation& instance = RsFallbackAdaptation::GetInstance();
+ RsContext context = instance.GetEntryFuncs()->ContextCreateGL(vdev, version, sdkVersion, sc, dpi);
+
+ RsContextWrapper *ctxWrapper = new RsContextWrapper{context, instance.GetEntryFuncs()};
+ return (RsContext) ctxWrapper;
+}
+
+extern "C" void rsContextBindProgramStore (RsContext ctxWrapper, RsProgramStore pgm)
+{
+ RS_DISPATCH(ctxWrapper, ContextBindProgramStore, pgm);
+}
+
+extern "C" void rsContextBindProgramFragment (RsContext ctxWrapper, RsProgramFragment pgm)
+{
+ RS_DISPATCH(ctxWrapper, ContextBindProgramFragment, pgm);
+}
+
+extern "C" void rsContextBindProgramVertex (RsContext ctxWrapper, RsProgramVertex pgm)
+{
+ RS_DISPATCH(ctxWrapper, ContextBindProgramVertex, pgm);
+}
+
+extern "C" void rsContextBindProgramRaster (RsContext ctxWrapper, RsProgramRaster pgm)
+{
+ RS_DISPATCH(ctxWrapper, ContextBindProgramRaster, pgm);
+}
+
+extern "C" void rsContextBindFont (RsContext ctxWrapper, RsFont pgm)
+{
+ RS_DISPATCH(ctxWrapper, ContextBindFont, pgm);
+}
+
+extern "C" void rsContextSetSurface (RsContext ctxWrapper, uint32_t width, uint32_t height,
+ RsNativeWindow sur)
+{
+ RS_DISPATCH(ctxWrapper, ContextSetSurface, width, height, sur);
+}
+
+extern "C" void rsContextBindRootScript (RsContext ctxWrapper, RsScript sampler)
+{
+ RS_DISPATCH(ctxWrapper, ContextBindRootScript, sampler);
+}
+
+extern "C" void rsContextPause (RsContext ctxWrapper)
+{
+ RS_DISPATCH(ctxWrapper, ContextPause);
+}
+
+extern "C" void rsContextResume (RsContext ctxWrapper)
+{
+ RS_DISPATCH(ctxWrapper, ContextResume);
+}
+
+extern "C" RsProgramStore rsProgramStoreCreate (RsContext ctxWrapper,
+ bool colorMaskR, bool colorMaskG,
+ bool colorMaskB, bool colorMaskA,
+ bool depthMask, bool ditherEnable,
+ RsBlendSrcFunc srcFunc,
+ RsBlendDstFunc destFunc,
+ RsDepthFunc depthFunc)
+{
+ return RS_DISPATCH(ctxWrapper, ProgramStoreCreate,
+ colorMaskR, colorMaskG, colorMaskB, colorMaskA,
+ depthMask, ditherEnable, srcFunc, destFunc, depthFunc);
+}
+
+extern "C" RsProgramRaster rsProgramRasterCreate (RsContext ctxWrapper, bool pointSprite, RsCullMode cull)
+{
+ return RS_DISPATCH(ctxWrapper, ProgramRasterCreate, pointSprite, cull);
+}
+
+extern "C" RsProgramFragment rsProgramFragmentCreate (RsContext ctxWrapper,
+ const char * shaderText, size_t shaderText_length,
+ const char ** textureNames, size_t textureNames_length_length,
+ const size_t * textureNames_length,
+ const uintptr_t * params, size_t params_length)
+{
+ return RS_DISPATCH(ctxWrapper, ProgramFragmentCreate,
+ shaderText, shaderText_length,
+ textureNames, textureNames_length_length, textureNames_length,
+ params, params_length);
+}
+
+extern "C" RsProgramVertex rsProgramVertexCreate (RsContext ctxWrapper,
+ const char * shaderText, size_t shaderText_length,
+ const char ** textureNames, size_t textureNames_length_length,
+ const size_t * textureNames_length,
+ const uintptr_t * params, size_t params_length)
+{
+ return RS_DISPATCH(ctxWrapper, ProgramVertexCreate,
+ shaderText, shaderText_length,
+ textureNames, textureNames_length_length, textureNames_length,
+ params, params_length);
+}
+
+extern "C" RsFont rsFontCreateFromFile (RsContext ctxWrapper, const char * name, size_t name_length,
+ float fontSize, uint32_t dpi)
+{
+ return RS_DISPATCH(ctxWrapper, FontCreateFromFile, name, name_length, fontSize, dpi);
+}
+
+extern "C" RsFont rsFontCreateFromMemory (RsContext ctxWrapper, const char * name, size_t name_length,
+ float fontSize, uint32_t dpi,
+ const void * data, size_t data_length)
+{
+ return RS_DISPATCH(ctxWrapper, FontCreateFromMemory, name, name_length, fontSize, dpi, data, data_length);
+}
+
+extern "C" RsMesh rsMeshCreate (RsContext ctxWrapper, RsAllocation * vtx, size_t vtx_length,
+ RsAllocation * idx, size_t idx_length,
+ uint32_t * primType, size_t primType_length)
+{
+ return RS_DISPATCH(ctxWrapper, MeshCreate, vtx, vtx_length, idx, idx_length, primType, primType_length);
+}
+
+extern "C" void rsProgramBindConstants (RsContext ctxWrapper, RsProgram vp, uint32_t slot, RsAllocation constants)
+{
+ RS_DISPATCH(ctxWrapper, ProgramBindConstants, vp, slot, constants);
+}
+
+extern "C" void rsProgramBindTexture (RsContext ctxWrapper, RsProgramFragment pf, uint32_t slot, RsAllocation a)
+{
+ RS_DISPATCH(ctxWrapper, ProgramBindTexture, pf, slot,a);
+}
+
+extern "C" void rsProgramBindSampler (RsContext ctxWrapper, RsProgramFragment pf, uint32_t slot, RsSampler s)
+{
+ RS_DISPATCH(ctxWrapper, ProgramBindSampler, pf, slot, s);
+}
+
+RsObjectBase rsaFileA3DGetEntryByIndex(RsContext ctxWrapper, uint32_t index, RsFile file)
+{
+ return RS_DISPATCH(ctxWrapper, FileA3DGetEntryByIndex, index, file);
+}
+
+RsFile rsaFileA3DCreateFromMemory(RsContext ctxWrapper, const void *data, uint32_t len)
+{
+ return RS_DISPATCH(ctxWrapper, FileA3DCreateFromMemory, data, len);
+}
+
+RsFile rsaFileA3DCreateFromAsset(RsContext ctxWrapper, void *_asset)
+{
+ return RS_DISPATCH(ctxWrapper, FileA3DCreateFromAsset, _asset);
+}
+
+RsFile rsaFileA3DCreateFromFile(RsContext ctxWrapper, const char *path)
+{
+ return RS_DISPATCH(ctxWrapper, FileA3DCreateFromFile, path);
+}
+
+void rsaFileA3DGetNumIndexEntries(RsContext ctxWrapper, int32_t *numEntries, RsFile file)
+{
+ RS_DISPATCH(ctxWrapper, FileA3DGetNumIndexEntries, numEntries, file);
+}
+
+void rsaFileA3DGetIndexEntries(RsContext ctxWrapper, RsFileIndexEntry *fileEntries, uint32_t numEntries, RsFile file)
+{
+ RS_DISPATCH(ctxWrapper, FileA3DGetIndexEntries, fileEntries, numEntries, file);
+}
+
+void rsaMeshGetVertexBufferCount(RsContext ctxWrapper, RsMesh mv, int32_t *numVtx)
+{
+ RS_DISPATCH(ctxWrapper, MeshGetVertexBufferCount, mv, numVtx);
+}
+
+void rsaMeshGetIndexCount(RsContext ctxWrapper, RsMesh mv, int32_t *numIdx)
+{
+ RS_DISPATCH(ctxWrapper, MeshGetIndexCount, mv, numIdx);
+}
+
+void rsaMeshGetVertices(RsContext ctxWrapper, RsMesh mv, RsAllocation *vtxData, uint32_t vtxDataCount)
+{
+ RS_DISPATCH(ctxWrapper, MeshGetVertices, mv, vtxData, vtxDataCount);
+}
+
+void rsaMeshGetIndices(RsContext ctxWrapper, RsMesh mv, RsAllocation *va, uint32_t *primType, uint32_t idxDataCount)
+{
+ RS_DISPATCH(ctxWrapper, MeshGetIndices, mv, va, primType, idxDataCount);
+}
\ No newline at end of file
