Home | History | Annotate | Download | only in default
      1 #define LOG_TAG "android.hardware.renderscript (at) 1.0-impl"
      2 
      3 #include "Context.h"
      4 #include "Device.h"
      5 
      6 namespace android {
      7 namespace hardware {
      8 namespace renderscript {
      9 namespace V1_0 {
     10 namespace implementation {
     11 
     12 
     13 Context::Context(uint32_t sdkVersion, ContextType ct, int32_t flags) {
     14     RsDevice _dev = nullptr;
     15     uint32_t _version = 0;
     16     uint32_t _sdkVersion = sdkVersion;
     17     RsContextType _ct = static_cast<RsContextType>(ct);
     18     int32_t _flags = flags;
     19     const char* driverName = nullptr;
     20 
     21 #ifdef OVERRIDE_RS_DRIVER
     22 #define XSTR(S) #S
     23 #define STR(S) XSTR(S)
     24 #define OVERRIDE_RS_DRIVER_STRING STR(OVERRIDE_RS_DRIVER)
     25     static std::string driverString(OVERRIDE_RS_DRIVER_STRING);
     26     driverName = driverString.c_str();
     27 #undef XSTR
     28 #undef STR
     29 #endif  // OVERRIDE_RS_DRIVER
     30     mContext = Device::getHal().ContextCreateVendor(_dev, _version, _sdkVersion,
     31                                                     _ct, _flags, driverName);
     32 }
     33 
     34 
     35 // Helper functions
     36 template<typename ReturnType>
     37 static ReturnType hidl_to_rs(OpaqueHandle src) {
     38     return reinterpret_cast<ReturnType>(static_cast<uintptr_t>(src));
     39 }
     40 
     41 template<typename ReturnType, typename SourceType>
     42 static ReturnType hidl_to_rs(SourceType* src) {
     43     return reinterpret_cast<ReturnType>(src);
     44 }
     45 
     46 template<typename RsType, typename HidlType, typename Operation>
     47 static std::vector<RsType> hidl_to_rs(const hidl_vec<HidlType>& src, Operation operation) {
     48     std::vector<RsType> dst(src.size());
     49     std::transform(src.begin(), src.end(), dst.begin(), operation);
     50     return dst;
     51 }
     52 
     53 template<typename ReturnType, typename SourceType>
     54 static ReturnType rs_to_hidl(SourceType* src) {
     55     return static_cast<ReturnType>(reinterpret_cast<uintptr_t>(src));
     56 }
     57 
     58 template<typename HidlType, typename RsType, typename Operation>
     59 static hidl_vec<HidlType> rs_to_hidl(const std::vector<RsType>& src, Operation operation) {
     60     std::vector<HidlType> dst(src.size());
     61     std::transform(src.begin(), src.end(), dst.begin(), operation);
     62     return dst;
     63 }
     64 
     65 
     66 // Methods from ::android::hardware::renderscript::V1_0::IContext follow.
     67 
     68 Return<Allocation> Context::allocationAdapterCreate(Type type, Allocation baseAlloc) {
     69     RsType _type = hidl_to_rs<RsType>(type);
     70     RsAllocation _baseAlloc = hidl_to_rs<RsAllocation>(baseAlloc);
     71     RsAllocation _subAlloc = Device::getHal().AllocationAdapterCreate(mContext, _type, _baseAlloc);
     72     return rs_to_hidl<Allocation>(_subAlloc);
     73 }
     74 
     75 Return<void> Context::allocationAdapterOffset(Allocation alloc, const hidl_vec<uint32_t>& offsets) {
     76     RsAllocation _alloc = hidl_to_rs<RsAllocation>(alloc);
     77     const hidl_vec<uint32_t>& _offsets = offsets;
     78     Device::getHal().AllocationAdapterOffset(mContext, _alloc, _offsets.data(), _offsets.size() * sizeof(uint32_t));
     79     return Void();
     80 }
     81 
     82 Return<Type> Context::allocationGetType(Allocation allocation) {
     83     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
     84     const void* _type = Device::getHal().AllocationGetType(mContext, _allocation);
     85     return rs_to_hidl<Type>(_type);
     86 }
     87 
     88 Return<Allocation> Context::allocationCreateTyped(Type type, AllocationMipmapControl amips, int32_t usage, Ptr ptr) {
     89     RsType _type = hidl_to_rs<RsType>(type);
     90     RsAllocationMipmapControl _amips = static_cast<RsAllocationMipmapControl>(amips);
     91     uint32_t _usage = usage;
     92     uintptr_t _ptr = hidl_to_rs<uintptr_t>(ptr);
     93     RsAllocation _allocation = Device::getHal().AllocationCreateTyped(mContext, _type, _amips, _usage, _ptr);
     94     return rs_to_hidl<Allocation>(_allocation);
     95 }
     96 
     97 Return<Allocation> Context::allocationCreateFromBitmap(Type type, AllocationMipmapControl amips, const hidl_vec<uint8_t>& bitmap, int32_t usage) {
     98     RsType _type = hidl_to_rs<RsType>(type);
     99     RsAllocationMipmapControl _amips = static_cast<RsAllocationMipmapControl>(amips);
    100     const hidl_vec<uint8_t>& _bitmap = bitmap;
    101     uint32_t _usage = usage;
    102     RsAllocation _allocation = Device::getHal().AllocationCreateFromBitmap(mContext, _type, _amips, _bitmap.data(), _bitmap.size(), _usage);
    103     return rs_to_hidl<Allocation>(_allocation);
    104 }
    105 
    106 Return<Allocation> Context::allocationCubeCreateFromBitmap(Type type, AllocationMipmapControl amips, const hidl_vec<uint8_t>& bitmap, int32_t usage) {
    107     RsType _type = hidl_to_rs<RsType>(type);
    108     RsAllocationMipmapControl _amips = static_cast<RsAllocationMipmapControl>(amips);
    109     const hidl_vec<uint8_t>& _bitmap = bitmap;
    110     uint32_t _usage = usage;
    111     RsAllocation _allocation = Device::getHal().AllocationCubeCreateFromBitmap(mContext, _type, _amips, _bitmap.data(), _bitmap.size(), _usage);
    112     return rs_to_hidl<Allocation>(_allocation);
    113 }
    114 
    115 Return<NativeWindow> Context::allocationGetNativeWindow(Allocation allocation) {
    116     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    117     RsNativeWindow _nativeWindow = Device::getHal().AllocationGetSurface(mContext, _allocation);
    118     return rs_to_hidl<NativeWindow>(_nativeWindow);
    119 }
    120 
    121 Return<void> Context::allocationSetNativeWindow(Allocation allocation, NativeWindow nativewindow) {
    122     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    123     RsNativeWindow _nativewindow = hidl_to_rs<RsNativeWindow>(nativewindow);
    124     Device::getHal().AllocationSetSurface(mContext, _allocation, _nativewindow);
    125     return Void();
    126 }
    127 
    128 Return<void> Context::allocationSetupBufferQueue(Allocation alloc, uint32_t numBuffer) {
    129     RsAllocation _alloc = hidl_to_rs<RsAllocation>(alloc);
    130     uint32_t _numBuffer = numBuffer;
    131     Device::getHal().AllocationSetupBufferQueue(mContext, _alloc, _numBuffer);
    132     return Void();
    133 }
    134 
    135 Return<void> Context::allocationShareBufferQueue(Allocation baseAlloc, Allocation subAlloc) {
    136     RsAllocation _baseAlloc = hidl_to_rs<RsAllocation>(baseAlloc);
    137     RsAllocation _subAlloc = hidl_to_rs<RsAllocation>(subAlloc);
    138     Device::getHal().AllocationShareBufferQueue(mContext, _baseAlloc, _subAlloc);
    139     return Void();
    140 }
    141 
    142 Return<void> Context::allocationCopyToBitmap(Allocation allocation, Ptr data, Size sizeBytes) {
    143     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    144     void* _data = hidl_to_rs<void*>(data);
    145     size_t _sizeBytes = static_cast<size_t>(sizeBytes);
    146     Device::getHal().AllocationCopyToBitmap(mContext, _allocation, _data, _sizeBytes);
    147     return Void();
    148 }
    149 
    150 Return<void> Context::allocation1DWrite(Allocation allocation, uint32_t offset, uint32_t lod, uint32_t count, const hidl_vec<uint8_t>& data) {
    151     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    152     uint32_t _offset = offset;
    153     uint32_t _lod = lod;
    154     uint32_t _count = count;
    155     const void* _dataPtr = hidl_to_rs<const void*>(data.data());
    156     size_t _sizeBytes = data.size();
    157     Device::getHal().Allocation1DData(mContext, _allocation, _offset, _lod, _count, _dataPtr, _sizeBytes);
    158     return Void();
    159 }
    160 
    161 Return<void> Context::allocationElementWrite(Allocation allocation, uint32_t x, uint32_t y, uint32_t z, uint32_t lod, const hidl_vec<uint8_t>& data, Size compIdx) {
    162     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    163     uint32_t _x = x;
    164     uint32_t _y = y;
    165     uint32_t _z = z;
    166     uint32_t _lod = lod;
    167     const void* _dataPtr = hidl_to_rs<const void*>(data.data());
    168     size_t _sizeBytes = data.size();
    169     size_t _compIdx = static_cast<size_t>(compIdx);
    170     Device::getHal().AllocationElementData(mContext, _allocation, _x, _y, _z, _lod, _dataPtr, _sizeBytes, _compIdx);
    171     return Void();
    172 }
    173 
    174 Return<void> Context::allocation2DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t lod, AllocationCubemapFace face, uint32_t w, uint32_t h, const hidl_vec<uint8_t>& data, Size stride) {
    175     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    176     uint32_t _xoff = xoff;
    177     uint32_t _yoff = yoff;
    178     uint32_t _lod = lod;
    179     RsAllocationCubemapFace _face = static_cast<RsAllocationCubemapFace>(face);
    180     uint32_t _w = w;
    181     uint32_t _h = h;
    182     const void* _dataPtr = hidl_to_rs<const void*>(data.data());
    183     size_t _sizeBytes = data.size();
    184     size_t _stride = static_cast<size_t>(stride);
    185     Device::getHal().Allocation2DData(mContext, _allocation, _xoff, _yoff, _lod, _face, _w, _h, _dataPtr, _sizeBytes, _stride);
    186     return Void();
    187 }
    188 
    189 Return<void> Context::allocation3DWrite(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h, uint32_t d, const hidl_vec<uint8_t>& data, Size stride) {
    190     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    191     uint32_t _xoff = xoff;
    192     uint32_t _yoff = yoff;
    193     uint32_t _zoff = zoff;
    194     uint32_t _lod = lod;
    195     uint32_t _w = w;
    196     uint32_t _h = h;
    197     uint32_t _d = d;
    198     const void* _dataPtr = hidl_to_rs<const void*>(data.data());
    199     size_t _sizeBytes = data.size();
    200     size_t _stride = static_cast<size_t>(stride);
    201     Device::getHal().Allocation3DData(mContext, _allocation, _xoff, _yoff, _zoff, _lod, _w, _h, _d, _dataPtr, _sizeBytes, _stride);
    202     return Void();
    203 }
    204 
    205 Return<void> Context::allocationGenerateMipmaps(Allocation allocation) {
    206     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    207     Device::getHal().AllocationGenerateMipmaps(mContext, _allocation);
    208     return Void();
    209 }
    210 
    211 Return<void> Context::allocationRead(Allocation allocation, Ptr data, Size sizeBytes) {
    212     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    213     void* _data = hidl_to_rs<void*>(data);
    214     size_t _sizeBytes = static_cast<size_t>(sizeBytes);
    215     Device::getHal().AllocationRead(mContext, _allocation, _data, _sizeBytes);
    216     return Void();
    217 }
    218 
    219 Return<void> Context::allocation1DRead(Allocation allocation, uint32_t xoff, uint32_t lod, uint32_t count, Ptr data, Size sizeBytes) {
    220     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    221     uint32_t _xoff = xoff;
    222     uint32_t _lod = lod;
    223     uint32_t _count = count;
    224     void* _data = hidl_to_rs<void*>(data);
    225     size_t _sizeBytes = static_cast<size_t>(sizeBytes);
    226     Device::getHal().Allocation1DRead(mContext, _allocation, _xoff, _lod, _count, _data, _sizeBytes);
    227     return Void();
    228 }
    229 
    230 Return<void> Context::allocationElementRead(Allocation allocation, uint32_t x, uint32_t y, uint32_t z, uint32_t lod, Ptr data, Size sizeBytes, Size compIdx) {
    231     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    232     uint32_t _x = x;
    233     uint32_t _y = y;
    234     uint32_t _z = z;
    235     uint32_t _lod = lod;
    236     void* _data = hidl_to_rs<void*>(data);
    237     size_t _sizeBytes = static_cast<size_t>(sizeBytes);
    238     size_t _compIdx = static_cast<size_t>(compIdx);
    239     Device::getHal().AllocationElementRead(mContext, _allocation, _x, _y, _z, _lod, _data, _sizeBytes, _compIdx);
    240     return Void();
    241 }
    242 
    243 Return<void> Context::allocation2DRead(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t lod, AllocationCubemapFace face, uint32_t w, uint32_t h, Ptr data, Size sizeBytes, Size stride) {
    244     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    245     uint32_t _xoff = xoff;
    246     uint32_t _yoff = yoff;
    247     uint32_t _lod = lod;
    248     RsAllocationCubemapFace _face = static_cast<RsAllocationCubemapFace>(face);
    249     uint32_t _w = w;
    250     uint32_t _h = h;
    251     void* _data = hidl_to_rs<void*>(data);
    252     size_t _sizeBytes = static_cast<size_t>(sizeBytes);
    253     size_t _stride = static_cast<size_t>(stride);
    254     Device::getHal().Allocation2DRead(mContext, _allocation, _xoff, _yoff, _lod, _face, _w, _h, _data, _sizeBytes, _stride);
    255     return Void();
    256 }
    257 
    258 Return<void> Context::allocation3DRead(Allocation allocation, uint32_t xoff, uint32_t yoff, uint32_t zoff, uint32_t lod, uint32_t w, uint32_t h, uint32_t d, Ptr data, Size sizeBytes, Size stride) {
    259     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    260     uint32_t _xoff = xoff;
    261     uint32_t _yoff = yoff;
    262     uint32_t _zoff = zoff;
    263     uint32_t _lod = lod;
    264     uint32_t _w = w;
    265     uint32_t _h = h;
    266     uint32_t _d = d;
    267     void* _dataPtr = hidl_to_rs<void*>(data);
    268     size_t _sizeBytes = static_cast<size_t>(sizeBytes);
    269     size_t _stride = static_cast<size_t>(stride);
    270     Device::getHal().Allocation3DRead(mContext, _allocation, _xoff, _yoff, _zoff, _lod, _w, _h, _d, _dataPtr, _sizeBytes, _stride);
    271     return Void();
    272 }
    273 
    274 Return<void> Context::allocationSyncAll(Allocation allocation, AllocationUsageType usageType) {
    275     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    276     RsAllocationUsageType _usageType = static_cast<RsAllocationUsageType>(usageType);
    277     Device::getHal().AllocationSyncAll(mContext, _allocation, _usageType);
    278     return Void();
    279 }
    280 
    281 Return<void> Context::allocationResize1D(Allocation allocation, uint32_t dimX) {
    282     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    283     uint32_t _dimX = dimX;
    284     Device::getHal().AllocationResize1D(mContext, _allocation, _dimX);
    285     return Void();
    286 }
    287 
    288 Return<void> Context::allocationCopy2DRange(Allocation dstAlloc, uint32_t dstXoff, uint32_t dstYoff, uint32_t dstMip, AllocationCubemapFace dstFace, uint32_t width, uint32_t height, Allocation srcAlloc, uint32_t srcXoff, uint32_t srcYoff, uint32_t srcMip, AllocationCubemapFace srcFace) {
    289     RsAllocation _dstAlloc = hidl_to_rs<RsAllocation>(dstAlloc);
    290     uint32_t _dstXoff = dstXoff;
    291     uint32_t _dstYoff = dstYoff;
    292     uint32_t _dstMip = dstMip;
    293     RsAllocationCubemapFace _dstFace = static_cast<RsAllocationCubemapFace>(dstFace);
    294     uint32_t _width = width;
    295     uint32_t _height = height;
    296     RsAllocation _srcAlloc = hidl_to_rs<RsAllocation>(srcAlloc);
    297     uint32_t _srcXoff = srcXoff;
    298     uint32_t _srcYoff = srcYoff;
    299     uint32_t _srcMip = srcMip;
    300     RsAllocationCubemapFace _srcFace = static_cast<RsAllocationCubemapFace>(srcFace);
    301     Device::getHal().AllocationCopy2DRange(mContext, _dstAlloc, _dstXoff, _dstYoff, _dstMip, _dstFace, _width, _height, _srcAlloc, _srcXoff, _srcYoff, _srcMip, _srcFace);
    302     return Void();
    303 }
    304 
    305 Return<void> Context::allocationCopy3DRange(Allocation dstAlloc, uint32_t dstXoff, uint32_t dstYoff, uint32_t dstZoff, uint32_t dstMip, uint32_t width, uint32_t height, uint32_t depth, Allocation srcAlloc, uint32_t srcXoff, uint32_t srcYoff, uint32_t srcZoff, uint32_t srcMip) {
    306     RsAllocation _dstAlloc = hidl_to_rs<RsAllocation>(dstAlloc);
    307     uint32_t _dstXoff = dstXoff;
    308     uint32_t _dstYoff = dstYoff;
    309     uint32_t _dstZoff = dstZoff;
    310     uint32_t _dstMip = dstMip;
    311     uint32_t _width = width;
    312     uint32_t _height = height;
    313     uint32_t _depth = depth;
    314     RsAllocation _srcAlloc = hidl_to_rs<RsAllocation>(srcAlloc);
    315     uint32_t _srcXoff = srcXoff;
    316     uint32_t _srcYoff = srcYoff;
    317     uint32_t _srcZoff = srcZoff;
    318     uint32_t _srcMip = srcMip;
    319     Device::getHal().AllocationCopy3DRange(mContext, _dstAlloc, _dstXoff, _dstYoff, _dstZoff, _dstMip, _width, _height, _depth, _srcAlloc, _srcXoff, _srcYoff, _srcZoff, _srcMip);
    320     return Void();
    321 }
    322 
    323 Return<void> Context::allocationIoSend(Allocation allocation) {
    324     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    325     Device::getHal().AllocationIoSend(mContext, _allocation);
    326     return Void();
    327 }
    328 
    329 Return<void> Context::allocationIoReceive(Allocation allocation) {
    330     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    331     Device::getHal().AllocationIoReceive(mContext, _allocation);
    332     return Void();
    333 }
    334 
    335 Return<void> Context::allocationGetPointer(Allocation allocation, uint32_t lod, AllocationCubemapFace face, uint32_t z, allocationGetPointer_cb _hidl_cb) {
    336     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    337     uint32_t _lod = lod;
    338     RsAllocationCubemapFace _face = static_cast<RsAllocationCubemapFace>(face);
    339     uint32_t _z = z;
    340     uint32_t _array = 0;
    341     size_t _stride = 0;
    342     void* _dataPtr = Device::getHal().AllocationGetPointer(mContext, _allocation, _lod, _face, _z, _array, &_stride, sizeof(size_t));
    343     Ptr dataPtr = reinterpret_cast<Ptr>(_dataPtr);
    344     Size stride = static_cast<Size>(_stride);
    345     _hidl_cb(dataPtr, stride);
    346     return Void();
    347 }
    348 
    349 Return<void> Context::elementGetNativeMetadata(Element element, elementGetNativeMetadata_cb _hidl_cb) {
    350     RsElement _element = hidl_to_rs<RsElement>(element);
    351     std::vector<uint32_t> _elemData(5);
    352     Device::getHal().ElementGetNativeData(mContext, _element, _elemData.data(), _elemData.size());
    353     hidl_vec<uint32_t> elemData = _elemData;
    354     _hidl_cb(elemData);
    355     return Void();
    356 }
    357 
    358 Return<void> Context::elementGetSubElements(Element element, Size numSubElem, elementGetSubElements_cb _hidl_cb) {
    359     RsElement _element = hidl_to_rs<RsElement>(element);
    360     uint32_t _numSubElem = static_cast<uint32_t>(numSubElem);
    361     std::vector<uintptr_t> _ids(_numSubElem);
    362     std::vector<const char*> _names(_numSubElem);
    363     std::vector<size_t> _arraySizes(_numSubElem);
    364     Device::getHal().ElementGetSubElements(mContext, _element, _ids.data(), _names.data(), _arraySizes.data(), _numSubElem);
    365     hidl_vec<Element>     ids        = rs_to_hidl<Element>(_ids,       [](uintptr_t val) { return static_cast<Element>(val); });
    366     hidl_vec<hidl_string> names      = rs_to_hidl<hidl_string>(_names, [](const char* val) { return val; });
    367     hidl_vec<Size>        arraySizes = rs_to_hidl<Size>(_arraySizes,   [](size_t val) { return static_cast<Size>(val); });
    368     _hidl_cb(ids, names, arraySizes);
    369     return Void();
    370 }
    371 
    372 Return<Element> Context::elementCreate(DataType dt, DataKind dk, bool norm, uint32_t size) {
    373     RsDataType _dt = static_cast<RsDataType>(dt);
    374     RsDataKind _dk = static_cast<RsDataKind>(dk);
    375     bool _norm = norm;
    376     uint32_t _size = size;
    377     RsElement _element = Device::getHal().ElementCreate(mContext, _dt, _dk, _norm, _size);
    378     return rs_to_hidl<Element>(_element);
    379 }
    380 
    381 Return<Element> Context::elementComplexCreate(const hidl_vec<Element>& eins, const hidl_vec<hidl_string>& names, const hidl_vec<Size>& arraySizes) {
    382     std::vector<RsElement>   _eins           = hidl_to_rs<RsElement>(eins,      [](Element val) { return hidl_to_rs<RsElement>(val); });
    383     std::vector<const char*> _namesPtr       = hidl_to_rs<const char*>(names,   [](const hidl_string& val) { return val.c_str(); });
    384     std::vector<size_t>      _nameLengthsPtr = hidl_to_rs<size_t>(names,        [](const hidl_string& val) { return val.size(); });
    385     std::vector<uint32_t>    _arraySizes     = hidl_to_rs<uint32_t>(arraySizes, [](Size val) { return static_cast<uint32_t>(val); });
    386     RsElement _element = Device::getHal().ElementCreate2(mContext, _eins.data(), _eins.size(), _namesPtr.data(), _namesPtr.size(), _nameLengthsPtr.data(), _arraySizes.data(), _arraySizes.size());
    387     return rs_to_hidl<Element>(_element);
    388 }
    389 
    390 Return<void> Context::typeGetNativeMetadata(Type type, typeGetNativeMetadata_cb _hidl_cb) {
    391     RsType _type = hidl_to_rs<RsType>(type);
    392     std::vector<uintptr_t> _metadata(6);
    393     Device::getHal().TypeGetNativeData(mContext, _type, _metadata.data(), _metadata.size());
    394     hidl_vec<OpaqueHandle> metadata = rs_to_hidl<OpaqueHandle>(_metadata, [](uintptr_t val) { return static_cast<OpaqueHandle>(val); });
    395     _hidl_cb(metadata);
    396     return Void();
    397 }
    398 
    399 Return<Type> Context::typeCreate(Element element, uint32_t dimX, uint32_t dimY, uint32_t dimZ, bool mipmaps, bool faces, YuvFormat yuv) {
    400     RsElement _element = hidl_to_rs<RsElement>(element);
    401     uint32_t _dimX = dimX;
    402     uint32_t _dimY = dimY;
    403     uint32_t _dimZ = dimZ;
    404     bool _mipmaps = mipmaps;
    405     bool _faces = faces;
    406     RsYuvFormat _yuv = static_cast<RsYuvFormat>(yuv);
    407     RsType _type = Device::getHal().TypeCreate(mContext, _element, _dimX, _dimY, _dimZ, _mipmaps, _faces, _yuv);
    408     return rs_to_hidl<Type>(_type);
    409 }
    410 
    411 Return<void> Context::contextDestroy() {
    412     Device::getHal().ContextDestroy(mContext);
    413     mContext = nullptr;
    414     return Void();
    415 }
    416 
    417 Return<void> Context::contextGetMessage(Ptr data, Size size, contextGetMessage_cb _hidl_cb) {
    418     void* _data = hidl_to_rs<void*>(data);
    419     size_t _size = static_cast<size_t>(size);
    420     size_t _receiveLen = 0;
    421     uint32_t _subID = 0;
    422     RsMessageToClientType _messageType = Device::getHal().ContextGetMessage(mContext, _data, _size, &_receiveLen, sizeof(size_t), &_subID, sizeof(uint32_t));
    423     MessageToClientType messageType = static_cast<MessageToClientType>(_messageType);
    424     Size receiveLen = static_cast<Size>(_receiveLen);
    425     _hidl_cb(messageType, receiveLen);
    426     return Void();
    427 }
    428 
    429 Return<void> Context::contextPeekMessage(contextPeekMessage_cb _hidl_cb) {
    430     size_t _receiveLen = 0;
    431     uint32_t _subID = 0;
    432     RsMessageToClientType _messageType = Device::getHal().ContextPeekMessage(mContext, &_receiveLen, sizeof(size_t), &_subID, sizeof(uint32_t));
    433     MessageToClientType messageType = static_cast<MessageToClientType>(_messageType);
    434     Size receiveLen = static_cast<Size>(_receiveLen);
    435     uint32_t subID = _subID;
    436     _hidl_cb(messageType, receiveLen, subID);
    437     return Void();
    438 }
    439 
    440 Return<void> Context::contextSendMessage(uint32_t id, const hidl_vec<uint8_t>& data) {
    441     uint32_t _id = id;
    442     const uint8_t* _dataPtr = data.data();
    443     size_t _dataSize = data.size();
    444     Device::getHal().ContextSendMessage(mContext, _id, _dataPtr, _dataSize);
    445     return Void();
    446 }
    447 
    448 Return<void> Context::contextInitToClient() {
    449     Device::getHal().ContextInitToClient(mContext);
    450     return Void();
    451 }
    452 
    453 Return<void> Context::contextDeinitToClient() {
    454     Device::getHal().ContextDeinitToClient(mContext);
    455     return Void();
    456 }
    457 
    458 Return<void> Context::contextFinish() {
    459     Device::getHal().ContextFinish(mContext);
    460     return Void();
    461 }
    462 
    463 Return<void> Context::contextLog() {
    464     uint32_t _bits = 0;
    465     Device::getHal().ContextDump(mContext, _bits);
    466     return Void();
    467 }
    468 
    469 Return<void> Context::contextSetPriority(ThreadPriorities priority) {
    470     RsThreadPriorities _priority = static_cast<RsThreadPriorities>(priority);
    471     Device::getHal().ContextSetPriority(mContext, _priority);
    472     return Void();
    473 }
    474 
    475 Return<void> Context::contextSetCacheDir(const hidl_string& cacheDir) {
    476     Device::getHal().ContextSetCacheDir(mContext, cacheDir.c_str(), cacheDir.size());
    477     return Void();
    478 }
    479 
    480 Return<void> Context::assignName(ObjectBase obj, const hidl_string& name) {
    481     RsObjectBase _obj = hidl_to_rs<RsObjectBase>(obj);
    482     const hidl_string& _name = name;
    483     Device::getHal().AssignName(mContext, _obj, _name.c_str(), _name.size());
    484     return Void();
    485 }
    486 
    487 Return<void> Context::getName(ObjectBase obj, getName_cb _hidl_cb) {
    488     void* _obj = hidl_to_rs<void*>(obj);
    489     const char* _name = nullptr;
    490     Device::getHal().GetName(mContext, _obj, &_name);
    491     hidl_string name = _name;
    492     _hidl_cb(name);
    493     return Void();
    494 }
    495 
    496 Return<Closure> Context::closureCreate(ScriptKernelID kernelID, Allocation returnValue, const hidl_vec<ScriptFieldID>& fieldIDS, const hidl_vec<int64_t>& values, const hidl_vec<int32_t>& sizes, const hidl_vec<Closure>& depClosures, const hidl_vec<ScriptFieldID>& depFieldIDS) {
    497     RsScriptKernelID _kernelID = hidl_to_rs<RsScriptKernelID>(kernelID);
    498     RsAllocation _returnValue = hidl_to_rs<RsAllocation>(returnValue);
    499     std::vector<RsScriptFieldID> _fieldIDS = hidl_to_rs<RsScriptFieldID>(fieldIDS, [](ScriptFieldID val) { return hidl_to_rs<RsScriptFieldID>(val); });
    500     int64_t* _valuesPtr = const_cast<int64_t*>(values.data());
    501     size_t _valuesLength = values.size();
    502     std::vector<int>             _sizes       = hidl_to_rs<int>(sizes,                   [](int32_t val) { return static_cast<int>(val); });
    503     std::vector<RsClosure>       _depClosures = hidl_to_rs<RsClosure>(depClosures,       [](Closure val) { return hidl_to_rs<RsClosure>(val); });
    504     std::vector<RsScriptFieldID> _depFieldIDS = hidl_to_rs<RsScriptFieldID>(depFieldIDS, [](ScriptFieldID val) { return hidl_to_rs<RsScriptFieldID>(val); });
    505     RsClosure _closure = Device::getHal().ClosureCreate(mContext, _kernelID, _returnValue, _fieldIDS.data(), _fieldIDS.size(), _valuesPtr, _valuesLength, _sizes.data(), _sizes.size(), _depClosures.data(), _depClosures.size(), _depFieldIDS.data(), _depFieldIDS.size());
    506     return rs_to_hidl<Closure>(_closure);
    507 }
    508 
    509 Return<Closure> Context::invokeClosureCreate(ScriptInvokeID invokeID, const hidl_vec<uint8_t>& params, const hidl_vec<ScriptFieldID>& fieldIDS, const hidl_vec<int64_t>& values, const hidl_vec<int32_t>& sizes) {
    510     RsScriptInvokeID _invokeID = hidl_to_rs<RsScriptInvokeID>(invokeID);
    511     const void* _paramsPtr = params.data();
    512     size_t _paramsSize = params.size();
    513     std::vector<RsScriptFieldID> _fieldIDS = hidl_to_rs<RsScriptFieldID>(fieldIDS, [](ScriptFieldID val) { return hidl_to_rs<RsScriptFieldID>(val); });
    514     const int64_t* _valuesPtr = values.data();
    515     size_t _valuesLength = values.size();
    516     std::vector<int> _sizes = hidl_to_rs<int>(sizes, [](int32_t val) { return static_cast<int>(val); });
    517     RsClosure _closure = Device::getHal().InvokeClosureCreate(mContext, _invokeID, _paramsPtr, _paramsSize, _fieldIDS.data(), _fieldIDS.size(), _valuesPtr, _valuesLength, _sizes.data(), _sizes.size());
    518     return rs_to_hidl<Closure>(_closure);
    519 }
    520 
    521 Return<void> Context::closureSetArg(Closure closure, uint32_t index, Ptr value, int32_t size) {
    522     RsClosure _closure = hidl_to_rs<RsClosure>(closure);
    523     uint32_t _index = index;
    524     uintptr_t _value = hidl_to_rs<uintptr_t>(value);
    525     int _size = static_cast<int>(size);
    526     Device::getHal().ClosureSetArg(mContext, _closure, _index, _value, _size);
    527     return Void();
    528 }
    529 
    530 Return<void> Context::closureSetGlobal(Closure closure, ScriptFieldID fieldID, int64_t value, int32_t size) {
    531     RsClosure _closure = hidl_to_rs<RsClosure>(closure);
    532     RsScriptFieldID _fieldID = hidl_to_rs<RsScriptFieldID>(fieldID);
    533     int64_t _value = value;
    534     int _size = static_cast<int>(size);
    535     Device::getHal().ClosureSetGlobal(mContext, _closure, _fieldID, _value, _size);
    536     return Void();
    537 }
    538 
    539 Return<ScriptKernelID> Context::scriptKernelIDCreate(Script script, int32_t slot, int32_t sig) {
    540     RsScript _script = hidl_to_rs<RsScript>(script);
    541     int _slot = static_cast<int>(slot);
    542     int _sig = static_cast<int>(sig);
    543     RsScriptKernelID _scriptKernelID = Device::getHal().ScriptKernelIDCreate(mContext, _script, _slot, _sig);
    544     return rs_to_hidl<ScriptKernelID>(_scriptKernelID);
    545 }
    546 
    547 Return<ScriptInvokeID> Context::scriptInvokeIDCreate(Script script, int32_t slot) {
    548     RsScript _script = hidl_to_rs<RsScript>(script);
    549     int _slot = static_cast<int>(slot);
    550     RsScriptInvokeID _scriptInvokeID = Device::getHal().ScriptInvokeIDCreate(mContext, _script, _slot);
    551     return rs_to_hidl<ScriptInvokeID>(_scriptInvokeID);
    552 }
    553 
    554 Return<ScriptFieldID> Context::scriptFieldIDCreate(Script script, int32_t slot) {
    555     RsScript _script = hidl_to_rs<RsScript>(script);
    556     int _slot = static_cast<int>(slot);
    557     RsScriptFieldID _scriptFieldID = Device::getHal().ScriptFieldIDCreate(mContext, _script, _slot);
    558     return rs_to_hidl<ScriptFieldID>(_scriptFieldID);
    559 }
    560 
    561 Return<ScriptGroup> Context::scriptGroupCreate(const hidl_vec<ScriptKernelID>& kernels, const hidl_vec<ScriptKernelID>& srcK, const hidl_vec<ScriptKernelID>& dstK, const hidl_vec<ScriptFieldID>& dstF, const hidl_vec<Type>& types) {
    562     std::vector<RsScriptKernelID> _kernels = hidl_to_rs<RsScriptKernelID>(kernels, [](ScriptFieldID val) { return hidl_to_rs<RsScriptKernelID>(val); });
    563     std::vector<RsScriptKernelID> _srcK    = hidl_to_rs<RsScriptKernelID>(srcK,    [](ScriptFieldID val) { return hidl_to_rs<RsScriptKernelID>(val); });
    564     std::vector<RsScriptKernelID> _dstK    = hidl_to_rs<RsScriptKernelID>(dstK,    [](ScriptFieldID val) { return hidl_to_rs<RsScriptKernelID>(val); });
    565     std::vector<RsScriptFieldID>  _dstF    = hidl_to_rs<RsScriptFieldID>(dstF,     [](ScriptFieldID val) { return hidl_to_rs<RsScriptFieldID>(val); });
    566     std::vector<RsType>           _types   = hidl_to_rs<RsType>(types,             [](Type val) { return hidl_to_rs<RsType>(val); });
    567     RsScriptGroup _scriptGroup = Device::getHal().ScriptGroupCreate(mContext, _kernels.data(), _kernels.size() * sizeof(RsScriptKernelID), _srcK.data(), _srcK.size() * sizeof(RsScriptKernelID), _dstK.data(), _dstK.size() * sizeof(RsScriptKernelID), _dstF.data(), _dstF.size() * sizeof(RsScriptFieldID), _types.data(), _types.size() * sizeof(RsType));
    568     return rs_to_hidl<ScriptGroup>(_scriptGroup);
    569 }
    570 
    571 Return<ScriptGroup2> Context::scriptGroup2Create(const hidl_string& name, const hidl_string& cacheDir, const hidl_vec<Closure>& closures) {
    572     const hidl_string& _name = name;
    573     const hidl_string& _cacheDir = cacheDir;
    574     std::vector<RsClosure> _closures = hidl_to_rs<RsClosure>(closures, [](Closure val) { return hidl_to_rs<RsClosure>(val); });
    575     RsScriptGroup2 _scriptGroup2 = Device::getHal().ScriptGroup2Create(mContext, _name.c_str(), _name.size(), _cacheDir.c_str(), _cacheDir.size(), _closures.data(), _closures.size());
    576     return rs_to_hidl<ScriptGroup2>(_scriptGroup2);
    577 }
    578 
    579 Return<void> Context::scriptGroupSetOutput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc) {
    580     RsScriptGroup _sg = hidl_to_rs<RsScriptGroup>(sg);
    581     RsScriptKernelID _kid = hidl_to_rs<RsScriptKernelID>(kid);
    582     RsAllocation _alloc = hidl_to_rs<RsAllocation>(alloc);
    583     Device::getHal().ScriptGroupSetOutput(mContext, _sg, _kid, _alloc);
    584     return Void();
    585 }
    586 
    587 Return<void> Context::scriptGroupSetInput(ScriptGroup sg, ScriptKernelID kid, Allocation alloc) {
    588     RsScriptGroup _sg = hidl_to_rs<RsScriptGroup>(sg);
    589     RsScriptKernelID _kid = hidl_to_rs<RsScriptKernelID>(kid);
    590     RsAllocation _alloc = hidl_to_rs<RsAllocation>(alloc);
    591     Device::getHal().ScriptGroupSetInput(mContext, _sg, _kid, _alloc);
    592     return Void();
    593 }
    594 
    595 Return<void> Context::scriptGroupExecute(ScriptGroup sg) {
    596     RsScriptGroup _sg = hidl_to_rs<RsScriptGroup>(sg);
    597     Device::getHal().ScriptGroupExecute(mContext, _sg);
    598     return Void();
    599 }
    600 
    601 Return<void> Context::objDestroy(ObjectBase obj) {
    602     RsAsyncVoidPtr _obj = hidl_to_rs<RsAsyncVoidPtr>(obj);
    603     Device::getHal().ObjDestroy(mContext, _obj);
    604     return Void();
    605 }
    606 
    607 Return<Sampler> Context::samplerCreate(SamplerValue magFilter, SamplerValue minFilter, SamplerValue wrapS, SamplerValue wrapT, SamplerValue wrapR, float aniso) {
    608     RsSamplerValue _magFilter = static_cast<RsSamplerValue>(magFilter);
    609     RsSamplerValue _minFilter = static_cast<RsSamplerValue>(minFilter);
    610     RsSamplerValue _wrapS = static_cast<RsSamplerValue>(wrapS);
    611     RsSamplerValue _wrapT = static_cast<RsSamplerValue>(wrapT);
    612     RsSamplerValue _wrapR = static_cast<RsSamplerValue>(wrapR);
    613     float _aniso = static_cast<float>(aniso);
    614     RsSampler _sampler = Device::getHal().SamplerCreate(mContext, _magFilter, _minFilter, _wrapS, _wrapT, _wrapR, _aniso);
    615     return rs_to_hidl<Sampler>(_sampler);
    616 }
    617 
    618 Return<void> Context::scriptBindAllocation(Script script, Allocation allocation, uint32_t slot) {
    619     RsScript _script = hidl_to_rs<RsScript>(script);
    620     RsAllocation _allocation = hidl_to_rs<RsAllocation>(allocation);
    621     uint32_t _slot = slot;
    622     Device::getHal().ScriptBindAllocation(mContext, _script, _allocation, _slot);
    623     return Void();
    624 }
    625 
    626 Return<void> Context::scriptSetTimeZone(Script script, const hidl_string& timeZone) {
    627     RsScript _script = hidl_to_rs<RsScript>(script);
    628     const hidl_string& _timeZone = timeZone;
    629     Device::getHal().ScriptSetTimeZone(mContext, _script, _timeZone.c_str(), _timeZone.size());
    630     return Void();
    631 }
    632 
    633 Return<void> Context::scriptInvoke(Script vs, uint32_t slot) {
    634     RsScript _vs = hidl_to_rs<RsScript>(vs);
    635     uint32_t _slot = slot;
    636     Device::getHal().ScriptInvoke(mContext, _vs, _slot);
    637     return Void();
    638 }
    639 
    640 Return<void> Context::scriptInvokeV(Script vs, uint32_t slot, const hidl_vec<uint8_t>& data) {
    641     RsScript _vs = hidl_to_rs<RsScript>(vs);
    642     uint32_t _slot = slot;
    643     const void* _dataPtr = hidl_to_rs<const void*>(data.data());
    644     size_t _len = data.size();
    645     Device::getHal().ScriptInvokeV(mContext, _vs, _slot, _dataPtr, _len);
    646     return Void();
    647 }
    648 
    649 Return<void> Context::scriptForEach(Script vs, uint32_t slot, const hidl_vec<Allocation>& vains, Allocation vaout, const hidl_vec<uint8_t>& params, Ptr sc) {
    650     RsScript _vs = hidl_to_rs<RsScript>(vs);
    651     uint32_t _slot = slot;
    652     std::vector<RsAllocation> _vains = hidl_to_rs<RsAllocation>(vains, [](Allocation val) { return hidl_to_rs<RsAllocation>(val); });
    653     RsAllocation _vaout = hidl_to_rs<RsAllocation>(vaout);
    654     const void* _paramsPtr = hidl_to_rs<const void*>(params.data());
    655     size_t _paramLen = params.size();
    656     const RsScriptCall* _sc = hidl_to_rs<const RsScriptCall*>(sc);
    657     size_t _scLen = _sc != nullptr ? sizeof(ScriptCall) : 0;
    658     Device::getHal().ScriptForEachMulti(mContext, _vs, _slot, _vains.data(), _vains.size(), _vaout, _paramsPtr, _paramLen, _sc, _scLen);
    659     return Void();
    660 }
    661 
    662 Return<void> Context::scriptReduce(Script vs, uint32_t slot, const hidl_vec<Allocation>& vains, Allocation vaout, Ptr sc) {
    663     RsScript _vs = hidl_to_rs<RsScript>(vs);
    664     uint32_t _slot = slot;
    665     std::vector<RsAllocation> _vains = hidl_to_rs<RsAllocation>(vains, [](Allocation val) { return hidl_to_rs<RsAllocation>(val); });
    666     RsAllocation _vaout = hidl_to_rs<RsAllocation>(vaout);
    667     const RsScriptCall* _sc = hidl_to_rs<const RsScriptCall*>(sc);
    668     size_t _scLen = _sc != nullptr ? sizeof(ScriptCall) : 0;
    669     Device::getHal().ScriptReduce(mContext, _vs, _slot, _vains.data(), _vains.size(), _vaout, _sc, _scLen);
    670     return Void();
    671 }
    672 
    673 Return<void> Context::scriptSetVarI(Script vs, uint32_t slot, int32_t value) {
    674     RsScript _vs = hidl_to_rs<RsScript>(vs);
    675     uint32_t _slot = slot;
    676     int _value = static_cast<int>(value);
    677     Device::getHal().ScriptSetVarI(mContext, _vs, _slot, _value);
    678     return Void();
    679 }
    680 
    681 Return<void> Context::scriptSetVarObj(Script vs, uint32_t slot, ObjectBase obj) {
    682     RsScript _vs = hidl_to_rs<RsScript>(vs);
    683     uint32_t _slot = slot;
    684     RsObjectBase _obj = hidl_to_rs<RsObjectBase>(obj);
    685     Device::getHal().ScriptSetVarObj(mContext, _vs, _slot, _obj);
    686     return Void();
    687 }
    688 
    689 Return<void> Context::scriptSetVarJ(Script vs, uint32_t slot, int64_t value) {
    690     RsScript _vs = hidl_to_rs<RsScript>(vs);
    691     uint32_t _slot = slot;
    692     int64_t _value = static_cast<int64_t>(value);
    693     Device::getHal().ScriptSetVarJ(mContext, _vs, _slot, _value);
    694     return Void();
    695 }
    696 
    697 Return<void> Context::scriptSetVarF(Script vs, uint32_t slot, float value) {
    698     RsScript _vs = hidl_to_rs<RsScript>(vs);
    699     uint32_t _slot = slot;
    700     float _value = value;
    701     Device::getHal().ScriptSetVarF(mContext, _vs, _slot, _value);
    702     return Void();
    703 }
    704 
    705 Return<void> Context::scriptSetVarD(Script vs, uint32_t slot, double value) {
    706     RsScript _vs = hidl_to_rs<RsScript>(vs);
    707     uint32_t _slot = slot;
    708     double _value = value;
    709     Device::getHal().ScriptSetVarD(mContext, _vs, _slot, _value);
    710     return Void();
    711 }
    712 
    713 Return<void> Context::scriptSetVarV(Script vs, uint32_t slot, const hidl_vec<uint8_t>& data) {
    714     RsScript _vs = hidl_to_rs<RsScript>(vs);
    715     uint32_t _slot = slot;
    716     const void* _dataPtr = hidl_to_rs<const void*>(data.data());
    717     size_t _len = data.size();
    718     Device::getHal().ScriptSetVarV(mContext, _vs, _slot, _dataPtr, _len);
    719     return Void();
    720 }
    721 
    722 Return<void> Context::scriptGetVarV(Script vs, uint32_t slot, Size len, scriptGetVarV_cb _hidl_cb) {
    723     RsScript _vs = hidl_to_rs<RsScript>(vs);
    724     uint32_t _slot = slot;
    725     size_t _len = static_cast<size_t>(len);
    726     std::vector<uint8_t> _data(_len);
    727     Device::getHal().ScriptGetVarV(mContext, _vs, _slot, _data.data(), _data.size());
    728     hidl_vec<uint8_t> data = _data;
    729     _hidl_cb(data);
    730     return Void();
    731 }
    732 
    733 Return<void> Context::scriptSetVarVE(Script vs, uint32_t slot, const hidl_vec<uint8_t>& data, Element ve, const hidl_vec<uint32_t>& dims) {
    734     RsScript _vs = hidl_to_rs<RsScript>(vs);
    735     uint32_t _slot = slot;
    736     const void* _dataPtr = hidl_to_rs<const void*>(data.data());
    737     size_t _len = data.size();
    738     RsElement _ve = hidl_to_rs<RsElement>(ve);
    739     const uint32_t* _dimsPtr = dims.data();
    740     size_t _dimLen = dims.size() * sizeof(uint32_t);
    741     Device::getHal().ScriptSetVarVE(mContext, _vs, _slot, _dataPtr, _len, _ve, _dimsPtr, _dimLen);
    742     return Void();
    743 }
    744 
    745 Return<Script> Context::scriptCCreate(const hidl_string& resName, const hidl_string& cacheDir, const hidl_vec<uint8_t>& text) {
    746     const hidl_string& _resName = resName;
    747     const hidl_string& _cacheDir = cacheDir;
    748     const char* _textPtr = hidl_to_rs<const char*>(text.data());
    749     size_t _textSize = text.size();
    750     RsScript _script = Device::getHal().ScriptCCreate(mContext, _resName.c_str(), _resName.size(), _cacheDir.c_str(), _cacheDir.size(), _textPtr, _textSize);
    751     return rs_to_hidl<Script>(_script);
    752 }
    753 
    754 Return<Script> Context::scriptIntrinsicCreate(ScriptIntrinsicID id, Element elem) {
    755     RsScriptIntrinsicID _id = static_cast<RsScriptIntrinsicID>(id);
    756     RsElement _elem = hidl_to_rs<RsElement>(elem);
    757     RsScript _script = Device::getHal().ScriptIntrinsicCreate(mContext, _id, _elem);
    758     return rs_to_hidl<Script>(_script);
    759 }
    760 
    761 
    762 // Methods from ::android::hidl::base::V1_0::IBase follow.
    763 
    764 
    765 }  // namespace implementation
    766 }  // namespace V1_0
    767 }  // namespace renderscript
    768 }  // namespace hardware
    769 }  // namespace android
    770