Method load

python/mod_cvcuda/nvcv/ExternalBuffer.cpp:122–272

}

bool ExternalBuffer::load(PyObject *o)
{
    if (!o)
    {
        return false;
    }

    py::object tmp = py::reinterpret_borrow<py::object>(o);

    if (hasattr(tmp, "__cuda_array_interface__"))
    {
        py::dict iface = tmp.attr("__cuda_array_interface__").cast<py::dict>();

        if (!iface.contains("shape") || !iface.contains("typestr") || !iface.contains("data")
            || !iface.contains("version"))
        {
            return false;
        }

        int version = iface["version"].cast<int>();
        if (version < 2)
        {
            return false;
        }

        DLPackTensor dlTensor;
        {
            DLManagedTensor dlManagedTensor = {};
            dlManagedTensor.deleter         = [](DLManagedTensor *self)
            {
                delete[] self->dl_tensor.shape;
                delete[] self->dl_tensor.strides;
            };
            dlTensor = DLPackTensor{std::move(dlManagedTensor)};
        }

        dlTensor->byte_offset = 0;

        // TODO: infer the device type from the memory buffer
        dlTensor->device.device_type = kDLCUDA;
        // TODO: infer the device from the memory buffer
        dlTensor->device.device_id = 0;

        // Convert data
        py::tuple tdata = iface["data"].cast<py::tuple>();
        void     *ptr   = reinterpret_cast<void *>(tdata[0].cast<long>());
        CheckValidCUDABuffer(ptr);
        dlTensor->data = ptr;

        // Convert DataType
        py::dtype dt = util::ToDType(iface["typestr"].cast<std::string>());
        if (std::optional<nvcv::DataType> dtype = ToNVCVDataType(dt))
        {
            dlTensor->dtype = ToDLDataType(*dtype);
        }

        // Convert ndim
        py::tuple shape = iface["shape"].cast<py::tuple>();