nvbuf_utils.h

 
#ifndef __NVBUF_UTILS_COMPAT_H__
#define __NVBUF_UTILS_COMPAT_H__
 
// Check if we have the original nvbuf_utils.h (JetPack 4.x)
#if __has_include(<nvbuf_utils_orig.h>)
    // Use original header if available
    #include <nvbuf_utils_orig.h>
#else
    // JetPack 5.x: Use NvBufSurface API with compatibility mappings
    #include <nvbufsurface.h>
    #include <nvbufsurftransform.h>
    #include <EGL/egl.h>
    #include <EGL/eglext.h>
    #include <cstring>
    #include <sys/mman.h>  // For msync() fallback with V4L2 mmap buffers
 
    // ============================================================================
    // Type Aliases - Map old types to new types
    // ============================================================================
 
    // Color formats - map old enum values to new ones
    typedef NvBufSurfaceColorFormat NvBufferColorFormat;
 
    #define NvBufferColorFormat_UYVY        NVBUF_COLOR_FORMAT_UYVY
    #define NvBufferColorFormat_YUYV        NVBUF_COLOR_FORMAT_YUYV
    #define NvBufferColorFormat_YUV420      NVBUF_COLOR_FORMAT_YUV420
    #define NvBufferColorFormat_NV12        NVBUF_COLOR_FORMAT_NV12
    #define NvBufferColorFormat_NV12_ER     NVBUF_COLOR_FORMAT_NV12_ER
    #define NvBufferColorFormat_ABGR32      NVBUF_COLOR_FORMAT_ABGR
    #define NvBufferColorFormat_ARGB32      NVBUF_COLOR_FORMAT_ARGB
    #define NvBufferColorFormat_RGBA        NVBUF_COLOR_FORMAT_RGBA
    #define NvBufferColorFormat_BGRA        NVBUF_COLOR_FORMAT_BGRA
    #define NvBufferColorFormat_Invalid     NVBUF_COLOR_FORMAT_INVALID
    #define NvBufferColorFormat_GRAY8       NVBUF_COLOR_FORMAT_GRAY8
 
    // Layout - map old enum values to new ones
    typedef NvBufSurfaceLayout NvBufferLayout;
 
    #define NvBufferLayout_Pitch            NVBUF_LAYOUT_PITCH
    #define NvBufferLayout_BlockLinear      NVBUF_LAYOUT_BLOCK_LINEAR
 
    // Memory type / Payload type mapping
    typedef NvBufSurfaceMemType NvBufferPayload;
 
    #define NvBufferPayload_SurfArray       NVBUF_MEM_SURFACE_ARRAY
    #define NvBufferPayload_MemHandle       NVBUF_MEM_HANDLE
 
    // Tags for memory allocation
    #define NvBufferTag_NONE                NvBufSurfaceTag_NONE
    #define NvBufferTag_CAMERA              NvBufSurfaceTag_CAMERA
    #define NvBufferTag_VIDEO_DEC           NvBufSurfaceTag_VIDEO_DEC
    #define NvBufferTag_VIDEO_ENC           NvBufSurfaceTag_VIDEO_ENC
    #define NvBufferTag_VIDEO_CONVERT       NvBufSurfaceTag_VIDEO_CONVERT
 
    // Memory mapping flags
    typedef NvBufSurfaceMemMapFlags NvBufferMemMapFlags;
 
    #define NvBufferMem_Read                NVBUF_MAP_READ
    #define NvBufferMem_Write               NVBUF_MAP_WRITE
    #define NvBufferMem_Read_Write          NVBUF_MAP_READ_WRITE
 
    // Transform flip modes
    typedef NvBufSurfTransform_Flip NvBufferTransform_Flip;
 
    #define NvBufferTransform_None          NvBufSurfTransform_None
    #define NvBufferTransform_Rotate90      NvBufSurfTransform_Rotate90
    #define NvBufferTransform_Rotate180     NvBufSurfTransform_Rotate180
    #define NvBufferTransform_Rotate270     NvBufSurfTransform_Rotate270
    #define NvBufferTransform_FlipX         NvBufSurfTransform_FlipX
    #define NvBufferTransform_FlipY         NvBufSurfTransform_FlipY
 
    // Transform filter types
    typedef NvBufSurfTransform_Inter NvBufferTransform_Filter;
 
    #define NvBufferTransform_Filter_Nearest   NvBufSurfTransformInter_Nearest
    #define NvBufferTransform_Filter_Bilinear  NvBufSurfTransformInter_Bilinear
    #define NvBufferTransform_Filter_5_Tap     NvBufSurfTransformInter_Algo1
    #define NvBufferTransform_Filter_10_Tap    NvBufSurfTransformInter_Algo2
    #define NvBufferTransform_Filter_Smart     NvBufSurfTransformInter_Algo3
    #define NvBufferTransform_Filter_Nicest    NvBufSurfTransformInter_Algo4
 
    // Transform flags - map old enum values to new ones
    // These are bit flags used in NvBufferTransformParams.transform_flag
    #define NVBUFFER_TRANSFORM_FILTER         NVBUFSURF_TRANSFORM_FILTER
    #define NVBUFFER_TRANSFORM_CROP_SRC       NVBUFSURF_TRANSFORM_CROP_SRC
    #define NVBUFFER_TRANSFORM_CROP_DST       NVBUFSURF_TRANSFORM_CROP_DST
    #define NVBUFFER_TRANSFORM_FLIP           NVBUFSURF_TRANSFORM_FLIP
 
    // Rectangle type for transforms
    typedef NvBufSurfTransformRect NvBufferRect;
 
    // ============================================================================
    // Structure Definitions - Compatibility structures
    // ============================================================================
 
    typedef struct {
        uint32_t width;
        uint32_t height;
        NvBufferLayout layout;
        NvBufferColorFormat colorFormat;
        NvBufferPayload payloadType;
        NvBufSurfaceTag nvbuf_tag;
    } NvBufferCreateParams;
 
    typedef struct {
        uint32_t width[NVBUF_MAX_PLANES];
        uint32_t height[NVBUF_MAX_PLANES];
        uint32_t pitch[NVBUF_MAX_PLANES];
        uint32_t offset[NVBUF_MAX_PLANES];
        uint32_t psize[NVBUF_MAX_PLANES];
        NvBufferLayout layout[NVBUF_MAX_PLANES];
        uint32_t num_planes;
        uint32_t nv_buffer_size;
        uint32_t memsize;
        NvBufferColorFormat pixel_format;
    } NvBufferParams;
 
    typedef struct {
        NvBufferTransform_Flip transform_flip;
        NvBufferTransform_Filter transform_filter;
        NvBufferRect src_rect;
        NvBufferRect dst_rect;
        uint32_t transform_flag;
    } NvBufferTransformParams;
 
    // ============================================================================
    // Internal State Management
    // ============================================================================
 
    #include <map>
    #include <mutex>
 
    class NvBufSurfaceManager {
    public:
        static NvBufSurfaceManager& instance() {
            static NvBufSurfaceManager inst;
            return inst;
        }
 
        void registerSurface(int fd, NvBufSurface* surface) {
            std::lock_guard<std::mutex> lock(mutex_);
            fdToSurface_[fd] = surface;
        }
 
        NvBufSurface* getSurface(int fd) {
            std::lock_guard<std::mutex> lock(mutex_);
            auto it = fdToSurface_.find(fd);
            if (it != fdToSurface_.end()) {
                return it->second;
            }
            // Try to get surface from FD directly
            NvBufSurface* surface = nullptr;
            if (NvBufSurfaceFromFd(fd, (void**)&surface) == 0) {
                fdToSurface_[fd] = surface;
                return surface;
            }
            return nullptr;
        }
 
        void unregisterSurface(int fd) {
            std::lock_guard<std::mutex> lock(mutex_);
            fdToSurface_.erase(fd);
        }
 
    private:
        NvBufSurfaceManager() = default;
        std::map<int, NvBufSurface*> fdToSurface_;
        std::mutex mutex_;
    };
 
    // ============================================================================
    // Function Implementations - Inline compatibility functions
    // ============================================================================
 
    inline int NvBufferCreateEx(int* fd, NvBufferCreateParams* params) {
        if (!fd || !params) return -1;
 
        NvBufSurfaceCreateParams createParams = {0};
        createParams.gpuId = 0;
        createParams.width = params->width;
        createParams.height = params->height;
        createParams.size = 0;  // Let the API calculate
        createParams.isContiguous = true;
        createParams.colorFormat = params->colorFormat;
        createParams.layout = params->layout;
        createParams.memType = params->payloadType;
 
        NvBufSurface* surface = nullptr;
        int ret = NvBufSurfaceCreate(&surface, 1, &createParams);
        if (ret != 0 || surface == nullptr) {
            return -1;
        }
 
        // Extract the DMA buffer FD from the surface
        *fd = surface->surfaceList[0].bufferDesc;
 
        // Register the surface for later lookups
        NvBufSurfaceManager::instance().registerSurface(*fd, surface);
 
        return 0;
    }
 
    inline int NvBufferDestroy(int fd) {
        NvBufSurface* surface = NvBufSurfaceManager::instance().getSurface(fd);
        if (surface) {
            NvBufSurfaceManager::instance().unregisterSurface(fd);
            return NvBufSurfaceDestroy(surface);
        }
        return -1;
    }
 
    inline int NvBufferMemMap(int fd, uint32_t plane, NvBufferMemMapFlags memflag, void** ptr) {
        NvBufSurface* surface = NvBufSurfaceManager::instance().getSurface(fd);
        if (!surface) return -1;
 
        // For per-plane FDs, adjust plane index if necessary
        uint32_t num_planes = surface->surfaceList[0].planeParams.num_planes;
        uint32_t actual_plane = (plane < num_planes) ? plane : 0;
 
        int ret = NvBufSurfaceMap(surface, 0, actual_plane, memflag);
        if (ret != 0) return ret;
 
        *ptr = surface->surfaceList[0].mappedAddr.addr[actual_plane];
        return 0;
    }
 
    inline int NvBufferMemUnMap(int fd, uint32_t plane, void** ptr) {
        (void)ptr;  // Unused in new API
        NvBufSurface* surface = NvBufSurfaceManager::instance().getSurface(fd);
        if (!surface) return -1;
 
        // For per-plane FDs, adjust plane index if necessary
        uint32_t num_planes = surface->surfaceList[0].planeParams.num_planes;
        uint32_t actual_plane = (plane < num_planes) ? plane : 0;
 
        return NvBufSurfaceUnMap(surface, 0, actual_plane);
    }
 
    inline int NvBufferMemSyncForCpu(int fd, uint32_t plane, void** ptr) {
        NvBufSurface* surface = NvBufSurfaceManager::instance().getSurface(fd);
        if (!surface) {
            // Not an NvBufSurface buffer (likely V4L2 mmap buffer)
            // V4L2 driver typically handles cache coherency for mmap'd buffers
            // Return success to maintain compatibility
            return 0;
        }
 
        // For per-plane FDs (common in V4L2), each FD may represent a single plane
        // If the requested plane index exceeds available planes, sync plane 0
        uint32_t num_planes = surface->surfaceList[0].planeParams.num_planes;
        uint32_t actual_plane = (plane < num_planes) ? plane : 0;
 
        return NvBufSurfaceSyncForCpu(surface, 0, actual_plane);
    }
 
    inline int NvBufferMemSyncForDevice(int fd, uint32_t plane, void** ptr) {
        NvBufSurface* surface = NvBufSurfaceManager::instance().getSurface(fd);
        if (!surface) {
            // Not an NvBufSurface buffer (likely V4L2 mmap buffer)
            // V4L2 driver typically handles cache coherency for mmap'd buffers
            // Return success to maintain compatibility
            return 0;
        }
 
        // For per-plane FDs (common in V4L2), each FD may represent a single plane
        // If the requested plane index exceeds available planes, sync plane 0
        uint32_t num_planes = surface->surfaceList[0].planeParams.num_planes;
        uint32_t actual_plane = (plane < num_planes) ? plane : 0;
 
        return NvBufSurfaceSyncForDevice(surface, 0, actual_plane);
    }
 
    inline int NvBufferGetParams(int fd, NvBufferParams* params) {
        if (!params) return -1;
 
        NvBufSurface* surface = NvBufSurfaceManager::instance().getSurface(fd);
        if (!surface) return -1;
 
        NvBufSurfaceParams* surfParams = &surface->surfaceList[0];
 
        memset(params, 0, sizeof(NvBufferParams));
        params->num_planes = surfParams->planeParams.num_planes;
        params->pixel_format = surfParams->colorFormat;
        params->nv_buffer_size = surfParams->dataSize;
        params->memsize = surfParams->dataSize;
 
        for (uint32_t i = 0; i < params->num_planes && i < NVBUF_MAX_PLANES; i++) {
            params->width[i] = surfParams->planeParams.width[i];
            params->height[i] = surfParams->planeParams.height[i];
            params->pitch[i] = surfParams->planeParams.pitch[i];
            params->offset[i] = surfParams->planeParams.offset[i];
            params->psize[i] = surfParams->planeParams.psize[i];
            params->layout[i] = surfParams->layout;  // Layout is surface-level in new API
        }
 
        return 0;
    }
 
    inline int NvBufferTransform(int src_fd, int dst_fd, NvBufferTransformParams* params) {
        NvBufSurface* srcSurface = NvBufSurfaceManager::instance().getSurface(src_fd);
        NvBufSurface* dstSurface = NvBufSurfaceManager::instance().getSurface(dst_fd);
 
        if (!srcSurface || !dstSurface || !params) return -1;
 
        NvBufSurfTransformParams transformParams = {0};
        transformParams.transform_flag = params->transform_flag;
        transformParams.transform_flip = params->transform_flip;
        transformParams.transform_filter = params->transform_filter;
        transformParams.src_rect = &params->src_rect;
        transformParams.dst_rect = &params->dst_rect;
 
        return NvBufSurfTransform(srcSurface, dstSurface, &transformParams);
    }
 
    // ============================================================================
    // EGL Image Functions - JetPack 5.x compatibility
    // ============================================================================
 
    inline EGLImageKHR NvEGLImageFromFd(EGLDisplay eglDisplay, int fd) {
        NvBufSurface* surface = NvBufSurfaceManager::instance().getSurface(fd);
        if (!surface) {
            // Try to get surface from FD directly
            if (NvBufSurfaceFromFd(fd, (void**)&surface) != 0) {
                return EGL_NO_IMAGE_KHR;
            }
            NvBufSurfaceManager::instance().registerSurface(fd, surface);
        }
 
        // Map EGL image for the surface
        if (NvBufSurfaceMapEglImage(surface, 0) != 0) {
            return EGL_NO_IMAGE_KHR;
        }
 
        return surface->surfaceList[0].mappedAddr.eglImage;
    }
 
    inline int NvDestroyEGLImage(EGLDisplay eglDisplay, EGLImageKHR eglImage) {
        (void)eglDisplay;  // Not used in new API - display is managed internally
 
        // Find the surface that owns this EGL image and unmap it
        // Note: This is a simplified implementation. In practice, we'd need to
        // track which surface owns which EGL image, but for most use cases,
        // the surface is destroyed along with the EGL image.
 
        // For now, we rely on the caller to manage surface lifecycle properly
        // The EGL image will be cleaned up when the surface is destroyed
        (void)eglImage;
        return 0;
    }
 
#endif  // JetPack version check
 
#endif  // __NVBUF_UTILS_COMPAT_H__