diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/GrallocOps.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/GrallocOps.h new file mode 100644 index 0000000..97e92d4 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/GrallocOps.h @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2016 Rockchip Electronics Co., Ltd. + * Authors: + * Zhiqin Wei + * + * 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. + */ + +#ifndef _rk_graphic_buffer_h_ +#define _rk_graphic_buffer_h_ + +#ifdef ANDROID + +#include +#include +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include + +#include "drmrga.h" +#include "rga.h" + +// ------------------------------------------------------------------------------- +int RkRgaGetHandleFd(buffer_handle_t handle, int *fd); +int RkRgaGetHandleAttributes(buffer_handle_t handle, + std::vector *attrs); +int RkRgaGetHandleMapAddress(buffer_handle_t handle, + void **buf); +#endif //Android + +#endif //_rk_graphic_buffer_h_ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaApi.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaApi.h new file mode 100644 index 0000000..b0049f7 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaApi.h @@ -0,0 +1,81 @@ +/* + * Copyright (C) 2016 Rockchip Electronics Co., Ltd. + * Authors: + * Zhiqin Wei + * + * 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. + */ +#ifndef _rockchip_rga_c_h_ +#define _rockchip_rga_c_h_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "drmrga.h" +#include "rga.h" + +#ifdef __cplusplus +extern "C"{ +#endif + +/* + * Compatible with the old version of C interface.The new + * version of the C interface no longer requires users to + * initialize rga, so RgaInit and RgaDeInit are just for + * compatibility with the old C interface, so please do + * not use ctx, because it is usually a NULL. + */ +#define RgaInit(ctx) ({ \ + int ret = 0; \ + ret = c_RkRgaInit(); \ + c_RkRgaGetContext(ctx); \ + ret;\ +}) +#define RgaDeInit(ctx) { \ + (void)ctx; /* unused */ \ + c_RkRgaDeInit(); \ +} +#define RgaBlit(...) c_RkRgaBlit(__VA_ARGS__) +#define RgaCollorFill(...) c_RkRgaColorFill(__VA_ARGS__) +#define RgaFlush() c_RkRgaFlush() + +int c_RkRgaInit(); +void c_RkRgaDeInit(); +void c_RkRgaGetContext(void **ctx); +int c_RkRgaBlit(rga_info_t *src, rga_info_t *dst, rga_info_t *src1); +int c_RkRgaColorFill(rga_info_t *dst); +int c_RkRgaFlush(); + +#ifndef ANDROID /* linux */ +int c_RkRgaGetAllocBuffer(bo_t *bo_info, int width, int height, int bpp); +int c_RkRgaGetAllocBufferCache(bo_t *bo_info, int width, int height, int bpp); +int c_RkRgaGetMmap(bo_t *bo_info); +int c_RkRgaUnmap(bo_t *bo_info); +int c_RkRgaFree(bo_t *bo_info); +int c_RkRgaGetBufferFd(bo_t *bo_info, int *fd); +#endif /* #ifndef ANDROID */ + +#ifdef __cplusplus +} +#endif + +#endif /* #ifndef _rockchip_rga_c_h_ */ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaMutex.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaMutex.h new file mode 100644 index 0000000..61909e2 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaMutex.h @@ -0,0 +1,193 @@ +/* + * Copyright (C) 2020 Rockchip Electronics Co., Ltd. + * Authors: + * PutinLee + * + * 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. + */ + + +#ifndef _LIBS_RGA_MUTEX_H +#define _LIBS_RGA_MUTEX_H + +#ifndef ANDROID +#include +#include +#include + +#include + + +// Enable thread safety attributes only with clang. +// The attributes can be safely erased when compiling with other compilers. +#if defined(__clang__) && (!defined(SWIG)) +#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x)) +#else +#define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op +#endif + +#define CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(capability(x)) + +#define SCOPED_CAPABILITY THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable) + +#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x)) + +#define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x)) + +#define ACQUIRED_BEFORE(...) THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__)) + +#define ACQUIRED_AFTER(...) THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__)) + +#define REQUIRES(...) THREAD_ANNOTATION_ATTRIBUTE__(requires_capability(__VA_ARGS__)) + +#define REQUIRES_SHARED(...) THREAD_ANNOTATION_ATTRIBUTE__(requires_shared_capability(__VA_ARGS__)) + +#define ACQUIRE(...) THREAD_ANNOTATION_ATTRIBUTE__(acquire_capability(__VA_ARGS__)) + +#define ACQUIRE_SHARED(...) THREAD_ANNOTATION_ATTRIBUTE__(acquire_shared_capability(__VA_ARGS__)) + +#define RELEASE(...) THREAD_ANNOTATION_ATTRIBUTE__(release_capability(__VA_ARGS__)) + +#define RELEASE_SHARED(...) THREAD_ANNOTATION_ATTRIBUTE__(release_shared_capability(__VA_ARGS__)) + +#define TRY_ACQUIRE(...) THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_capability(__VA_ARGS__)) + +#define TRY_ACQUIRE_SHARED(...) \ + THREAD_ANNOTATION_ATTRIBUTE__(try_acquire_shared_capability(__VA_ARGS__)) + +#define EXCLUDES(...) THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__)) + +#define ASSERT_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(assert_capability(x)) + +#define ASSERT_SHARED_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_capability(x)) + +#define RETURN_CAPABILITY(x) THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x)) + +#define NO_THREAD_SAFETY_ANALYSIS THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis) + +class Condition; + +/* + * NOTE: This class is for code that builds on Win32. Its usage is + * deprecated for code which doesn't build for Win32. New code which + * doesn't build for Win32 should use std::mutex and std::lock_guard instead. + * + * Simple mutex class. The implementation is system-dependent. + * + * The mutex must be unlocked by the thread that locked it. They are not + * recursive, i.e. the same thread can't lock it multiple times. + */ +class CAPABILITY("mutex") Mutex { + public: + enum { + PRIVATE = 0, + SHARED = 1 + }; + + Mutex(); + explicit Mutex(const char* name); + explicit Mutex(int type, const char* name = nullptr); + ~Mutex(); + + // lock or unlock the mutex + int32_t lock() ACQUIRE(); + void unlock() RELEASE(); + + // lock if possible; returns 0 on success, error otherwise + int32_t tryLock() TRY_ACQUIRE(0); + + int32_t timedLock(int64_t timeoutNs) TRY_ACQUIRE(0); + + // Manages the mutex automatically. It'll be locked when Autolock is + // constructed and released when Autolock goes out of scope. + class SCOPED_CAPABILITY Autolock { + public: + inline explicit Autolock(Mutex& mutex) ACQUIRE(mutex) : mLock(mutex) { + mLock.lock(); + } + inline explicit Autolock(Mutex* mutex) ACQUIRE(mutex) : mLock(*mutex) { + mLock.lock(); + } + inline ~Autolock() RELEASE() { + mLock.unlock(); + } + + private: + Mutex& mLock; + // Cannot be copied or moved - declarations only + Autolock(const Autolock&); + Autolock& operator=(const Autolock&); + }; + + private: + friend class Condition; + + // A mutex cannot be copied + Mutex(const Mutex&); + Mutex& operator=(const Mutex&); + + pthread_mutex_t mMutex; +}; + +// --------------------------------------------------------------------------- +inline Mutex::Mutex() { + pthread_mutex_init(&mMutex, nullptr); +} +inline Mutex::Mutex(__attribute__((unused)) const char* name) { + pthread_mutex_init(&mMutex, nullptr); +} +inline Mutex::Mutex(int type, __attribute__((unused)) const char* name) { + if (type == SHARED) { + pthread_mutexattr_t attr; + pthread_mutexattr_init(&attr); + pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); + pthread_mutex_init(&mMutex, &attr); + pthread_mutexattr_destroy(&attr); + } else { + pthread_mutex_init(&mMutex, nullptr); + } +} +inline Mutex::~Mutex() { + pthread_mutex_destroy(&mMutex); +} +inline int32_t Mutex::lock() { + return -pthread_mutex_lock(&mMutex); +} +inline void Mutex::unlock() { + pthread_mutex_unlock(&mMutex); +} +inline int32_t Mutex::tryLock() { + return -pthread_mutex_trylock(&mMutex); +} +inline int32_t Mutex::timedLock(int64_t timeoutNs) { + timespec now; + clock_gettime(CLOCK_REALTIME, &now); + timeoutNs += now.tv_sec*1000000000 + now.tv_nsec; + const struct timespec ts = { + /* .tv_sec = */ static_cast(timeoutNs / 1000000000), + /* .tv_nsec = */ static_cast(timeoutNs % 1000000000), + }; + return -pthread_mutex_timedlock(&mMutex, &ts); +} + +// --------------------------------------------------------------------------- + +/* + * Automatic mutex. Declare one of these at the top of a function. + * When the function returns, it will go out of scope, and release the + * mutex. + */ + +typedef Mutex::Autolock AutoMutex; +#endif // __ANDROID_VNDK__ +#endif // _LIBS_RGA_MUTEX_H diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaSingleton.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaSingleton.h new file mode 100644 index 0000000..e87cf1c --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaSingleton.h @@ -0,0 +1,70 @@ +/* + * Copyright (C) 2016 Rockchip Electronics Co., Ltd. + * Authors: + * Zhiqin Wei + * + * 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. + */ + +#ifndef _LIBS_RGA_SINGLETON_H +#define _LIBS_RGA_SINGLETON_H + +#ifndef ANDROID +#include "RgaMutex.h" + +#if defined(__clang__) +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wundefined-var-template" +#endif + +template +class Singleton { + public: + static TYPE& getInstance() { + Mutex::Autolock _l(sLock); + TYPE* instance = sInstance; + if (instance == nullptr) { + instance = new TYPE(); + sInstance = instance; + } + return *instance; + } + + static bool hasInstance() { + Mutex::Autolock _l(sLock); + return sInstance != nullptr; + } + + protected: + ~Singleton() { } + Singleton() { } + + private: + Singleton(const Singleton&); + Singleton& operator = (const Singleton&); + static Mutex sLock; + static TYPE* sInstance; +}; + +#if defined(__clang__) +#pragma clang diagnostic pop +#endif + +#define RGA_SINGLETON_STATIC_INSTANCE(TYPE) \ + template<> ::Mutex \ + (::Singleton< TYPE >::sLock)(::Mutex::PRIVATE); \ + template<> TYPE* ::Singleton< TYPE >::sInstance(nullptr); /* NOLINT */ \ + template class ::Singleton< TYPE >; + +#endif //ANDROID +#endif //_LIBS_RGA_SINGLETON_H diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaUtils.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaUtils.h new file mode 100644 index 0000000..217ecea --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RgaUtils.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2016 Rockchip Electronics Co., Ltd. + * Authors: + * Zhiqin Wei + * + * 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. + */ + +#ifndef _rga_utils_h_ +#define _rga_utils_h_ + +// ------------------------------------------------------------------------------- +float get_bpp_from_format(int format); +int get_perPixel_stride_from_format(int format); +int get_buf_from_file(void *buf, int f, int sw, int sh, int index); +int output_buf_data_to_file(void *buf, int f, int sw, int sh, int index); +const char *translate_format_str(int format); +int get_buf_from_file_FBC(void *buf, int f, int sw, int sh, int index); +int output_buf_data_to_file_FBC(void *buf, int f, int sw, int sh, int index); +#endif + diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RockchipRga.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RockchipRga.h new file mode 100644 index 0000000..082f9e1 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/RockchipRga.h @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2016 Rockchip Electronics Co., Ltd. + * Authors: + * Zhiqin Wei + * + * 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. + */ + +#ifndef _rockchip_rga_h_ +#define _rockchip_rga_h_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "drmrga.h" +#include "GrallocOps.h" +#include "RgaUtils.h" +#include "rga.h" + +////////////////////////////////////////////////////////////////////////////////// +#ifndef ANDROID +#include "RgaSingleton.h" +#endif + +#ifdef ANDROID +#include +#include +#include + +namespace android { +#endif + + class RockchipRga :public Singleton { + public: + + static inline RockchipRga& get() { + return getInstance(); + } + + int RkRgaInit(); + void RkRgaDeInit(); + void RkRgaGetContext(void **ctx); +#ifndef ANDROID /* LINUX */ + int RkRgaAllocBuffer(int drm_fd /* input */, bo_t *bo_info, + int width, int height, int bpp, int flags); + int RkRgaFreeBuffer(int drm_fd /* input */, bo_t *bo_info); + int RkRgaGetAllocBuffer(bo_t *bo_info, int width, int height, int bpp); + int RkRgaGetAllocBufferExt(bo_t *bo_info, int width, int height, int bpp, int flags); + int RkRgaGetAllocBufferCache(bo_t *bo_info, int width, int height, int bpp); + int RkRgaGetMmap(bo_t *bo_info); + int RkRgaUnmap(bo_t *bo_info); + int RkRgaFree(bo_t *bo_info); + int RkRgaGetBufferFd(bo_t *bo_info, int *fd); +#else + int RkRgaGetBufferFd(buffer_handle_t handle, int *fd); + int RkRgaGetHandleMapCpuAddress(buffer_handle_t handle, void **buf); +#endif + int RkRgaBlit(rga_info *src, rga_info *dst, rga_info *src1); + int RkRgaCollorFill(rga_info *dst); + int RkRgaCollorPalette(rga_info *src, rga_info *dst, rga_info *lut); + int RkRgaFlush(); + + + void RkRgaSetLogOnceFlag(int log) { + mLogOnce = log; + } + void RkRgaSetAlwaysLogFlag(bool log) { + mLogAlways = log; + } + void RkRgaLogOutRgaReq(struct rga_req rgaReg); + int RkRgaLogOutUserPara(rga_info *rgaInfo); + inline bool RkRgaIsReady() { + return mSupportRga; + } + + RockchipRga(); + ~RockchipRga(); + private: + bool mSupportRga; + int mLogOnce; + int mLogAlways; + void * mContext; + + friend class Singleton; + }; + +#ifdef ANDROID +}; // namespace android +#endif + +#endif + diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/drmrga.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/drmrga.h new file mode 100644 index 0000000..f0ebf81 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/drmrga.h @@ -0,0 +1,358 @@ +/* + * Copyright (C) 2016 Rockchip Electronics Co., Ltd. + * Authors: + * Zhiqin Wei + * + * 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. + */ + +#ifndef _rk_drm_rga_ +#define _rk_drm_rga_ + +#include +#include +#include + +#include "rga.h" + +#ifdef ANDROID +#define DRMRGA_HARDWARE_MODULE_ID "librga" + +#include +#include +#include +#include + +#ifdef ANDROID_12 +#include +#endif + +#endif + +#define RGA_BLIT_SYNC 0x5017 +#define RGA_BLIT_ASYNC 0x5018 + +#ifndef ANDROID /* LINUX */ +/* flip source image horizontally (around the vertical axis) */ +#define HAL_TRANSFORM_FLIP_H 0x01 +/* flip source image vertically (around the horizontal axis)*/ +#define HAL_TRANSFORM_FLIP_V 0x02 +/* rotate source image 90 degrees clockwise */ +#define HAL_TRANSFORM_ROT_90 0x04 +/* rotate source image 180 degrees */ +#define HAL_TRANSFORM_ROT_180 0x03 +/* rotate source image 270 degrees clockwise */ +#define HAL_TRANSFORM_ROT_270 0x07 +#endif + +#define HAL_TRANSFORM_FLIP_H_V 0x08 + +/*****************************************************************************/ + +/* for compatibility */ +#define DRM_RGA_MODULE_API_VERSION HWC_MODULE_API_VERSION_0_1 +#define DRM_RGA_DEVICE_API_VERSION HWC_DEVICE_API_VERSION_0_1 +#define DRM_RGA_API_VERSION HWC_DEVICE_API_VERSION + +#define DRM_RGA_TRANSFORM_ROT_MASK 0x0000000F +#define DRM_RGA_TRANSFORM_ROT_0 0x00000000 +#define DRM_RGA_TRANSFORM_ROT_90 HAL_TRANSFORM_ROT_90 +#define DRM_RGA_TRANSFORM_ROT_180 HAL_TRANSFORM_ROT_180 +#define DRM_RGA_TRANSFORM_ROT_270 HAL_TRANSFORM_ROT_270 + +#define DRM_RGA_TRANSFORM_FLIP_MASK 0x00000003 +#define DRM_RGA_TRANSFORM_FLIP_H HAL_TRANSFORM_FLIP_H +#define DRM_RGA_TRANSFORM_FLIP_V HAL_TRANSFORM_FLIP_V + +enum { + AWIDTH = 0, + AHEIGHT, + ASTRIDE, + AFORMAT, + ASIZE, + ATYPE, +}; +/*****************************************************************************/ + +#ifndef ANDROID /* LINUX */ +/* memory type definitions. */ +enum drm_rockchip_gem_mem_type { + /* Physically Continuous memory and used as default. */ + ROCKCHIP_BO_CONTIG = 1 << 0, + /* cachable mapping. */ + ROCKCHIP_BO_CACHABLE = 1 << 1, + /* write-combine mapping. */ + ROCKCHIP_BO_WC = 1 << 2, + ROCKCHIP_BO_SECURE = 1 << 3, + ROCKCHIP_BO_MASK = ROCKCHIP_BO_CONTIG | ROCKCHIP_BO_CACHABLE | + ROCKCHIP_BO_WC | ROCKCHIP_BO_SECURE +}; + +typedef struct bo { + int fd; + void *ptr; + size_t size; + size_t offset; + size_t pitch; + unsigned handle; +} bo_t; +#endif + +/* + @value size: user not need care about.For avoid read/write out of memory + */ +typedef struct rga_rect { + int xoffset; + int yoffset; + int width; + int height; + int wstride; + int hstride; + int format; + int size; +} rga_rect_t; + +typedef struct rga_nn { + int nn_flag; + int scale_r; + int scale_g; + int scale_b; + int offset_r; + int offset_g; + int offset_b; +} rga_nn_t; + +typedef struct rga_dither { + int enable; + int mode; + int lut0_l; + int lut0_h; + int lut1_l; + int lut1_h; +} rga_dither_t; + +struct rga_mosaic_info { + uint8_t enable; + uint8_t mode; +}; + +struct rga_pre_intr_info { + uint8_t enable; + + uint8_t read_intr_en; + uint8_t write_intr_en; + uint8_t read_hold_en; + uint32_t read_threshold; + uint32_t write_start; + uint32_t write_step; +}; + +/* MAX(min, (max - channel_value)) */ +struct rga_osd_invert_factor { + uint8_t alpha_max; + uint8_t alpha_min; + uint8_t yg_max; + uint8_t yg_min; + uint8_t crb_max; + uint8_t crb_min; +}; + +struct rga_color { + union { + struct { + uint8_t red; + uint8_t green; + uint8_t blue; + uint8_t alpha; + }; + uint32_t value; + }; +}; + +struct rga_osd_bpp2 { + uint8_t ac_swap; // ac swap flag + // 0: CA + // 1: AC + uint8_t endian_swap; // rgba2bpp endian swap + // 0: Big endian + // 1: Little endian + struct rga_color color0; + struct rga_color color1; +}; + +struct rga_osd_mode_ctrl { + uint8_t mode; // OSD cal mode: + // 0b'1: statistics mode + // 1b'1: auto inversion overlap mode + uint8_t direction_mode; // horizontal or vertical + // 0: horizontal + // 1: vertical + uint8_t width_mode; // using @fix_width or LUT width + // 0: fix width + // 1: LUT width + uint16_t block_fix_width; // OSD block fixed width + // real width = (fix_width + 1) * 2 + uint8_t block_num; // OSD block num + uint16_t flags_index; // auto invert flags index + + /* invertion config */ + uint8_t color_mode; // selete color + // 0: src1 color + // 1: config data color + uint8_t invert_flags_mode; // invert flag selete + // 0: use RAM flag + // 1: usr last result + uint8_t default_color_sel; // default color mode + // 0: default is bright + // 1: default is dark + uint8_t invert_enable; // invert channel enable + // 1 << 0: aplha enable + // 1 << 1: Y/G disable + // 1 << 2: C/RB disable + uint8_t invert_mode; // invert cal mode + // 0: normal(max-data) + // 1: swap + uint8_t invert_thresh; // if luma > thresh, osd_flag to be 1 + uint8_t unfix_index; // OSD width config index +}; + +struct rga_osd_info { + uint8_t enable; + + struct rga_osd_mode_ctrl mode_ctrl; + struct rga_osd_invert_factor cal_factor; + struct rga_osd_bpp2 bpp2_info; + + union { + struct { + uint32_t last_flags1; + uint32_t last_flags0; + }; + uint64_t last_flags; + }; + + union { + struct { + uint32_t cur_flags1; + uint32_t cur_flags0; + }; + uint64_t cur_flags; + }; +}; + +/* + @value fd: use fd to share memory, it can be ion shard fd,and dma fd. + @value virAddr:userspace address + @value phyAddr:use phy address + @value hnd: use buffer_handle_t + */ +typedef struct rga_info { + int fd; + void *virAddr; + void *phyAddr; +#ifndef ANDROID /* LINUX */ + unsigned hnd; +#else /* Android */ + buffer_handle_t hnd; +#endif + int format; + rga_rect_t rect; + unsigned int blend; + int bufferSize; + int rotation; + int color; + int testLog; + int mmuFlag; + int colorkey_en; + int colorkey_mode; + int colorkey_max; + int colorkey_min; + int scale_mode; + int color_space_mode; + int sync_mode; + rga_nn_t nn; + rga_dither_t dither; + int rop_code; + int rd_mode; + unsigned short is_10b_compact; + unsigned short is_10b_endian; + + int in_fence_fd; + int out_fence_fd; + + int core; + int priority; + + unsigned short enable; + + int handle; + + struct rga_mosaic_info mosaic_info; + + struct rga_osd_info osd_info; + + struct rga_pre_intr_info pre_intr; + + int mpi_mode; + + union { + int ctx_id; + int job_handle; + }; + + char reserve[402]; +} rga_info_t; + + +typedef struct drm_rga { + rga_rect_t src; + rga_rect_t dst; +} drm_rga_t; + +/* + @fun rga_set_rect:For use to set the rects esayly + + @param rect:The rect user want to set,like setting the src rect: + drm_rga_t rects; + rga_set_rect(rects.src,0,0,1920,1080,1920,NV12); + mean to set the src rect to the value. + */ +static inline int rga_set_rect(rga_rect_t *rect, + int x, int y, int w, int h, int sw, int sh, int f) { + if (!rect) + return -EINVAL; + + rect->xoffset = x; + rect->yoffset = y; + rect->width = w; + rect->height = h; + rect->wstride = sw; + rect->hstride = sh; + rect->format = f; + + return 0; +} + +#ifndef ANDROID /* LINUX */ +static inline void rga_set_rotation(rga_info_t *info, int angle) { + if (angle == 90) + info->rotation = HAL_TRANSFORM_ROT_90; + else if (angle == 180) + info->rotation = HAL_TRANSFORM_ROT_180; + else if (angle == 270) + info->rotation = HAL_TRANSFORM_ROT_270; +} +#endif +/*****************************************************************************/ + +#endif diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d.h new file mode 100644 index 0000000..1878670 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d.h @@ -0,0 +1,32 @@ +/* + * Copyright (C) 2020 Rockchip Electronics Co., Ltd. + * Authors: + * PutinLee + * Cerf Yu + * + * 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. + */ + +#ifndef _im2d_h_ +#define _im2d_h_ + +#include "im2d_version.h" +#include "im2d_type.h" + +#include "im2d_common.h" +#include "im2d_buffer.h" +#include "im2d_single.h" +#include "im2d_task.h" +#include "im2d_mpi.h" + +#endif /* #ifndef _im2d_h_ */ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d.hpp b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d.hpp new file mode 100644 index 0000000..2d5ac83 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d.hpp @@ -0,0 +1,27 @@ +/* + * Copyright (C) 2020 Rockchip Electronics Co., Ltd. + * Authors: + * PutinLee + * Cerf Yu + * + * 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. + */ +#ifndef _im2d_hpp_ +#define _im2d_hpp_ + +#include "im2d.h" +#include "im2d_expand.h" + +#endif /* #ifndef _im2d_hpp_ */ + + diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_buffer.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_buffer.h new file mode 100644 index 0000000..41dc60e --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_buffer.h @@ -0,0 +1,179 @@ +/* + * Copyright (C) 2022 Rockchip Electronics Co., Ltd. + * Authors: + * Cerf Yu + * + * 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. + */ +#ifndef _im2d_buffer_h_ +#define _im2d_buffer_h_ + +#include "im2d_type.h" + +/** + * Import external buffers into RGA driver. + * + * @param fd/va/pa + * Select dma_fd/virtual_address/physical_address by buffer type + * @param size + * Describes the size of the image buffer + * + * @return rga_buffer_handle_t + */ +#ifdef __cplusplus +IM_API rga_buffer_handle_t importbuffer_fd(int fd, int size); +IM_API rga_buffer_handle_t importbuffer_virtualaddr(void *va, int size); +IM_API rga_buffer_handle_t importbuffer_physicaladdr(uint64_t pa, int size); +#endif + +/** + * Import external buffers into RGA driver. + * + * @param fd/va/pa + * Select dma_fd/virtual_address/physical_address by buffer type + * @param width + * Describes the pixel width stride of the image buffer + * @param height + * Describes the pixel height stride of the image buffer + * @param format + * Describes the pixel format of the image buffer + * + * @return rga_buffer_handle_t + */ +#ifdef __cplusplus +IM_API rga_buffer_handle_t importbuffer_fd(int fd, int width, int height, int format); +IM_API rga_buffer_handle_t importbuffer_virtualaddr(void *va, int width, int height, int format); +IM_API rga_buffer_handle_t importbuffer_physicaladdr(uint64_t pa, int width, int height, int format); +#endif + +/** + * Import external buffers into RGA driver. + * + * @param fd/va/pa + * Select dma_fd/virtual_address/physical_address by buffer type + * @param param + * Configure buffer parameters + * + * @return rga_buffer_handle_t + */ +IM_EXPORT_API rga_buffer_handle_t importbuffer_fd(int fd, im_handle_param_t *param); +IM_EXPORT_API rga_buffer_handle_t importbuffer_virtualaddr(void *va, im_handle_param_t *param); +IM_EXPORT_API rga_buffer_handle_t importbuffer_physicaladdr(uint64_t pa, im_handle_param_t *param); + +/** + * Import external buffers into RGA driver. + * + * @param handle + * rga buffer handle + * + * @return success or else negative error code. + */ +IM_EXPORT_API IM_STATUS releasebuffer_handle(rga_buffer_handle_t handle); + +/** + * Wrap image Parameters. + * + * @param handle/virtualaddr/physicaladdr/fd + * RGA buffer handle/virtualaddr/physicaladdr/fd. + * @param width + * Width of image manipulation area. + * @param height + * Height of image manipulation area. + * @param wstride + * Width pixel stride, default (width = wstride). + * @param hstride + * Height pixel stride, default (height = hstride). + * @param format + * Image format. + * + * @return rga_buffer_t + */ +#define wrapbuffer_handle(handle, width, height, format, ...) \ + ({ \ + rga_buffer_t im2d_api_buffer; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + im2d_api_buffer = wrapbuffer_handle_t(handle, width, height, width, height, format); \ + } else if (__argc == 2){ \ + im2d_api_buffer = wrapbuffer_handle_t(handle, width, height, __args[0], __args[1], format); \ + } else { \ + memset(&im2d_api_buffer, 0x0, sizeof(im2d_api_buffer)); \ + printf("invalid parameter\n"); \ + } \ + im2d_api_buffer; \ + }) + +#define wrapbuffer_virtualaddr(vir_addr, width, height, format, ...) \ + ({ \ + rga_buffer_t im2d_api_buffer; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + im2d_api_buffer = wrapbuffer_virtualaddr_t(vir_addr, width, height, width, height, format); \ + } else if (__argc == 2){ \ + im2d_api_buffer = wrapbuffer_virtualaddr_t(vir_addr, width, height, __args[0], __args[1], format); \ + } else { \ + memset(&im2d_api_buffer, 0x0, sizeof(im2d_api_buffer)); \ + printf("invalid parameter\n"); \ + } \ + im2d_api_buffer; \ + }) + +#define wrapbuffer_physicaladdr(phy_addr, width, height, format, ...) \ + ({ \ + rga_buffer_t im2d_api_buffer; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + im2d_api_buffer = wrapbuffer_physicaladdr_t(phy_addr, width, height, width, height, format); \ + } else if (__argc == 2){ \ + im2d_api_buffer = wrapbuffer_physicaladdr_t(phy_addr, width, height, __args[0], __args[1], format); \ + } else { \ + memset(&im2d_api_buffer, 0x0, sizeof(im2d_api_buffer)); \ + printf("invalid parameter\n"); \ + } \ + im2d_api_buffer; \ + }) + +#define wrapbuffer_fd(fd, width, height, format, ...) \ + ({ \ + rga_buffer_t im2d_api_buffer; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + im2d_api_buffer = wrapbuffer_fd_t(fd, width, height, width, height, format); \ + } else if (__argc == 2){ \ + im2d_api_buffer = wrapbuffer_fd_t(fd, width, height, __args[0], __args[1], format); \ + } else { \ + memset(&im2d_api_buffer, 0x0, sizeof(im2d_api_buffer)); \ + printf("invalid parameter\n"); \ + } \ + im2d_api_buffer; \ + }) +/* Symbols for define *_t functions */ +IM_C_API rga_buffer_t wrapbuffer_handle_t(rga_buffer_handle_t handle, int width, int height, int wstride, int hstride, int format); +IM_C_API rga_buffer_t wrapbuffer_virtualaddr_t(void* vir_addr, int width, int height, int wstride, int hstride, int format); +IM_C_API rga_buffer_t wrapbuffer_physicaladdr_t(void* phy_addr, int width, int height, int wstride, int hstride, int format); +IM_C_API rga_buffer_t wrapbuffer_fd_t(int fd, int width, int height, int wstride, int hstride, int format); + +#ifdef __cplusplus +#undef wrapbuffer_handle +IM_API rga_buffer_t wrapbuffer_handle(rga_buffer_handle_t handle, + int width, int height, int format); +IM_API rga_buffer_t wrapbuffer_handle(rga_buffer_handle_t handle, + int width, int height, int format, + int wstride, int hstride); +#endif + +#endif /* #ifndef _im2d_buffer_h_ */ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_common.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_common.h new file mode 100644 index 0000000..9030efe --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_common.h @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2022 Rockchip Electronics Co., Ltd. + * Authors: + * Cerf Yu + * + * 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. + */ +#ifndef _im2d_common_h_ +#define _im2d_common_h_ + +#include "im2d_type.h" + +/** + * Query RGA basic information, supported resolution, supported format, etc. + * + * @param name + * RGA_VENDOR + * RGA_VERSION + * RGA_MAX_INPUT + * RGA_MAX_OUTPUT + * RGA_INPUT_FORMAT + * RGA_OUTPUT_FORMAT + * RGA_EXPECTED + * RGA_ALL + * + * @returns a string describing properties of RGA. + */ +IM_EXPORT_API const char* querystring(int name); + +/** + * String to output the error message + * + * @param status + * process result value. + * + * @returns error message. + */ +#define imStrError(...) \ + ({ \ + const char* im2d_api_err; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + im2d_api_err = imStrError_t(IM_STATUS_INVALID_PARAM); \ + } else if (__argc == 1){ \ + im2d_api_err = imStrError_t((IM_STATUS)__args[0]); \ + } else { \ + im2d_api_err = ("Fatal error, imStrError() too many parameters\n"); \ + printf("Fatal error, imStrError() too many parameters\n"); \ + } \ + im2d_api_err; \ + }) +IM_C_API const char* imStrError_t(IM_STATUS status); + +/** + * check im2d api header file + * + * @param header_version + * Default is RGA_CURRENT_API_HEADER_VERSION, no need to change if there are no special cases. + * + * @returns no error or else negative error code. + */ +#ifdef __cplusplus +IM_API IM_STATUS imcheckHeader(im_api_version_t header_version = RGA_CURRENT_API_HEADER_VERSION); +#endif + +/** + * check RGA basic information, supported resolution, supported format, etc. + * + * @param src + * @param dst + * @param pat + * @param src_rect + * @param dst_rect + * @param pat_rect + * @param mode_usage + * + * @returns no error or else negative error code. + */ +#define imcheck(src, dst, src_rect, dst_rect, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_NOERROR; \ + rga_buffer_t __pat; \ + im_rect __pat_rect; \ + memset(&__pat, 0, sizeof(rga_buffer_t)); \ + memset(&__pat_rect, 0, sizeof(im_rect)); \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imcheck_t(src, dst, __pat, src_rect, dst_rect, __pat_rect, 0); \ + } else if (__argc == 1){ \ + __ret = imcheck_t(src, dst, __pat, src_rect, dst_rect, __pat_rect, __args[0]); \ + } else { \ + __ret = IM_STATUS_FAILED; \ + printf("check failed\n"); \ + } \ + __ret; \ + }) +#define imcheck_composite(src, dst, pat, src_rect, dst_rect, pat_rect, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_NOERROR; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imcheck_t(src, dst, pat, src_rect, dst_rect, pat_rect, 0); \ + } else if (__argc == 1){ \ + __ret = imcheck_t(src, dst, pat, src_rect, dst_rect, pat_rect, __args[0]); \ + } else { \ + __ret = IM_STATUS_FAILED; \ + printf("check failed\n"); \ + } \ + __ret; \ + }) +IM_C_API IM_STATUS imcheck_t(const rga_buffer_t src, const rga_buffer_t dst, const rga_buffer_t pat, + const im_rect src_rect, const im_rect dst_rect, const im_rect pat_rect, const int mode_usage); +/* Compatible with the legacy symbol */ +IM_C_API void rga_check_perpare(rga_buffer_t *src, rga_buffer_t *dst, rga_buffer_t *pat, + im_rect *src_rect, im_rect *dst_rect, im_rect *pat_rect, int mode_usage); + +/** + * block until all execution is complete + * + * @param release_fence_fd + * RGA job release fence fd + * + * @returns success or else negative error code. + */ +IM_EXPORT_API IM_STATUS imsync(int release_fence_fd); + +/** + * config + * + * @param name + * enum IM_CONFIG_NAME + * @param value + * + * @returns success or else negative error code. + */ +IM_EXPORT_API IM_STATUS imconfig(IM_CONFIG_NAME name, uint64_t value); + +#endif /* #ifndef _im2d_common_h_ */ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_expand.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_expand.h new file mode 100644 index 0000000..ef0220d --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_expand.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2022 Rockchip Electronics Co., Ltd. + * Authors: + * Cerf Yu + * + * 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. + */ +#ifndef _im2d_expand_h_ +#define _im2d_expand_h_ + +#ifdef __cplusplus + +#include "im2d_type.h" + +// #if ANDROID + +// #include + +// using namespace android; + +// IM_API rga_buffer_handle_t importbuffer_GraphicBuffer_handle(buffer_handle_t hnd); +// IM_API rga_buffer_handle_t importbuffer_GraphicBuffer(sp buf); + +// IM_API rga_buffer_t wrapbuffer_handle(buffer_handle_t hnd); +// IM_API rga_buffer_t wrapbuffer_GraphicBuffer(sp buf); + +// #if USE_AHARDWAREBUFFER +// #include +// IM_API rga_buffer_handle_t importbuffer_AHardwareBuffer(AHardwareBuffer *buf); +// IM_API rga_buffer_t wrapbuffer_AHardwareBuffer(AHardwareBuffer *buf); + +// #endif /* #if USE_AHARDWAREBUFFER */ +// #endif /* #if ANDROID */ + +#endif /* #ifdef __cplusplus */ + +#endif diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_mpi.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_mpi.h new file mode 100644 index 0000000..f984d15 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_mpi.h @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2022 Rockchip Electronics Co., Ltd. + * Authors: + * Cerf Yu + * + * 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. + */ +#ifndef _im2d_mpi_hpp_ +#define _im2d_mpi_hpp_ + +#include "im2d_type.h" + +/** + * Create and config an rga ctx for rockit-ko + * + * @param flags + * Some configuration flags for this job + * + * @returns job id. + */ +IM_EXPORT_API im_ctx_id_t imbegin(uint32_t flags); + +/** + * Cancel and delete an rga ctx for rockit-ko + * + * @param flags + * Some configuration flags for this job + * + * @returns success or else negative error code. + */ +IM_EXPORT_API IM_STATUS imcancel(im_ctx_id_t id); + +/** + * process for rockit-ko + * + * @param src + * The input source image and is also the foreground image in blend. + * @param dst + * The output destination image and is also the foreground image in blend. + * @param pat + * The foreground image, or a LUT table. + * @param srect + * The rectangle on the src channel image that needs to be processed. + * @param drect + * The rectangle on the dst channel image that needs to be processed. + * @param prect + * The rectangle on the pat channel image that needs to be processed. + * @param acquire_fence_fd + * @param release_fence_fd + * @param opt + * The image processing options configuration. + * @param usage + * The image processing usage. + * @param ctx_id + * ctx id + * + * @returns success or else negative error code. + */ +#ifdef __cplusplus +IM_API IM_STATUS improcess(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat, + im_rect srect, im_rect drect, im_rect prect, + int acquire_fence_fd, int *release_fence_fd, + im_opt_t *opt, int usage, im_ctx_id_t ctx_id); +#endif +IM_EXPORT_API IM_STATUS improcess_ctx(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat, + im_rect srect, im_rect drect, im_rect prect, + int acquire_fence_fd, int *release_fence_fd, + im_opt_t *opt, int usage, im_ctx_id_t ctx_id); + +#endif /* #ifndef _im2d_mpi_hpp_ */ \ No newline at end of file diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_single.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_single.h new file mode 100644 index 0000000..fb96a9a --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_single.h @@ -0,0 +1,940 @@ +/* + * Copyright (C) 2022 Rockchip Electronics Co., Ltd. + * Authors: + * Cerf Yu + * + * 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. + */ +#ifndef _im2d_single_h_ +#define _im2d_single_h_ + +#include "im2d_type.h" + +#ifdef __cplusplus + +/** + * copy + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * @param release_fence_fd + * When 'sync == 0', the fence_fd used to identify the current job state + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcopy(const rga_buffer_t src, rga_buffer_t dst, int sync = 1, int *release_fence_fd = NULL); + +/** + * Resize + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param fx + * X-direction resize factor. + * @param fy + * X-direction resize factor. + * @param interpolation + * Interpolation formula(Only RGA1 support). + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * @param release_fence_fd + * When 'sync == 0', the fence_fd used to identify the current job state + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imresize(const rga_buffer_t src, rga_buffer_t dst, double fx = 0, double fy = 0, int interpolation = 0, int sync = 1, int *release_fence_fd = NULL); + +/** + * Crop + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param rect + * The rectangle on the source image that needs to be cropped. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * @param release_fence_fd + * When 'sync == 0', the fence_fd used to identify the current job state + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcrop(const rga_buffer_t src, rga_buffer_t dst, im_rect rect, int sync = 1, int *release_fence_fd = NULL); + +/** + * translate + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param x + * Output the coordinates of the starting point in the X-direction of the destination image. + * @param y + * Output the coordinates of the starting point in the Y-direction of the destination image. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * @param release_fence_fd + * When 'sync == 0', the fence_fd used to identify the current job state + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imtranslate(const rga_buffer_t src, rga_buffer_t dst, int x, int y, int sync = 1, int *release_fence_fd = NULL); + +/** + * format convert + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param sfmt + * The source image format. + * @param dfmt + * The destination image format. + * @param mode + * color space mode: + * IM_YUV_TO_RGB_BT601_LIMIT + * IM_YUV_TO_RGB_BT601_FULL + * IM_YUV_TO_RGB_BT709_LIMIT + * IM_RGB_TO_YUV_BT601_FULL + * IM_RGB_TO_YUV_BT601_LIMIT + * IM_RGB_TO_YUV_BT709_LIMIT + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * @param release_fence_fd + * When 'sync == 0', the fence_fd used to identify the current job state + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcvtcolor(rga_buffer_t src, rga_buffer_t dst, int sfmt, int dfmt, int mode = IM_COLOR_SPACE_DEFAULT, int sync = 1, int *release_fence_fd = NULL); + +/** + * rotation + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param rotation + * IM_HAL_TRANSFORM_ROT_90 + * IM_HAL_TRANSFORM_ROT_180 + * IM_HAL_TRANSFORM_ROT_270 + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * @param release_fence_fd + * When 'sync == 0', the fence_fd used to identify the current job state + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imrotate(const rga_buffer_t src, rga_buffer_t dst, int rotation, int sync = 1, int *release_fence_fd = NULL); + +/** + * flip + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param mode + * IM_HAL_TRANSFORM_FLIP_H + * IM_HAL_TRANSFORM_FLIP_V + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * @param release_fence_fd + * When 'sync == 0', the fence_fd used to identify the current job state + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imflip(const rga_buffer_t src, rga_buffer_t dst, int mode, int sync = 1, int *release_fence_fd = NULL); + +/** + * 2-channel blend (SRC + DST -> DST or SRCA + SRCB -> DST) + * + * @param fg_image + * The foreground image. + * @param bg_image + * The background image, which is also the output destination image. + * @param mode + * Port-Duff mode: + * IM_ALPHA_BLEND_SRC + * IM_ALPHA_BLEND_DST + * IM_ALPHA_BLEND_SRC_OVER + * IM_ALPHA_BLEND_DST_OVER + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * @param release_fence_fd + * When 'sync == 0', the fence_fd used to identify the current job state + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imblend(const rga_buffer_t fd_image, rga_buffer_t bg_image, int mode = IM_ALPHA_BLEND_SRC_OVER, int sync = 1, int *release_fence_fd = NULL); + +/** + * 3-channel blend (SRC + DST -> DST or SRCA + SRCB -> DST) + * + * @param fg_image + * The foreground image. + * @param bg_image + * The background image. + * @param output_image + * The output destination image. + * @param mode + * Port-Duff mode: + * IM_ALPHA_BLEND_SRC + * IM_ALPHA_BLEND_DST + * IM_ALPHA_BLEND_SRC_OVER + * IM_ALPHA_BLEND_DST_OVER + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * @param release_fence_fd + * When 'sync == 0', the fence_fd used to identify the current job state + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcomposite(const rga_buffer_t srcA, const rga_buffer_t srcB, rga_buffer_t dst, int mode = IM_ALPHA_BLEND_SRC_OVER, int sync = 1, int *release_fence_fd = NULL); + +/** + * color key + * + * @param fg_image + * The foreground image. + * @param bg_image + * The background image, which is also the output destination image. + * @param colorkey_range + * The range of color key. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcolorkey(const rga_buffer_t src, rga_buffer_t dst, im_colorkey_range range, int mode = IM_ALPHA_COLORKEY_NORMAL, int sync = 1, int *release_fence_fd = NULL); + +/** + * OSD + * + * @param osd + * The osd text block. + * @param dst + * The background image. + * @param osd_rect + * The rectangle on the source image that needs to be OSD. + * @param osd_config + * osd mode configuration. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imosd(const rga_buffer_t osd,const rga_buffer_t dst, + const im_rect osd_rect, im_osd_t *osd_config, + int sync = 1, int *release_fence_fd = NULL); + +/** + * nn quantize + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param nninfo + * nn configuration + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imquantize(const rga_buffer_t src, rga_buffer_t dst, im_nn_t nn_info, int sync = 1, int *release_fence_fd = NULL); + +/** + * ROP + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param rop_code + * The ROP opcode. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imrop(const rga_buffer_t src, rga_buffer_t dst, int rop_code, int sync = 1, int *release_fence_fd = NULL); + +/** + * fill/reset/draw + * + * @param dst + * The output destination image. + * @param rect + * The rectangle on the source image that needs to be filled with color. + * @param color + * The fill color value. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imfill(rga_buffer_t dst, im_rect rect, int color, int sync = 1, int *release_fence_fd = NULL); + +/** + * fill array + * + * @param dst + * The output destination image. + * @param rect_array + * The rectangle arrays on the source image that needs to be filled with color. + * @param array_size + * The size of rectangular area arrays. + * @param color + * The fill color value. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imfillArray(rga_buffer_t dst, im_rect *rect_array, int array_size, uint32_t color, int sync = 1, int *release_fence_fd = NULL); + +/** + * fill rectangle + * + * @param dst + * The output destination image. + * @param rect + * The rectangle on the source image that needs to be filled with color. + * @param color + * The fill color value. + * @param thickness + * Thickness of lines that make up the rectangle. Negative values, like -1, + * mean that the function has to draw a filled rectangle. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imrectangle(rga_buffer_t dst, im_rect rect, + uint32_t color, int thickness, + int sync = 1, int *release_fence_fd = NULL); + +/** + * fill rectangle array + * + * @param dst + * The output destination image. + * @param rect_array + * The rectangle arrays on the source image that needs to be filled with color. + * @param array_size + * The size of rectangular area arrays. + * @param color + * The fill color value. + * @param thickness + * Thickness of lines that make up the rectangle. Negative values, like -1, + * mean that the function has to draw a filled rectangle. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imrectangleArray(rga_buffer_t dst, im_rect *rect_array, int array_size, + uint32_t color, int thickness, + int sync = 1, int *release_fence_fd = NULL); + +/** + * MOSAIC + * + * @param image + * The output destination image. + * @param rect + * The rectangle on the source image that needs to be mosaicked. + * @param mosaic_mode + * mosaic block width configuration: + * IM_MOSAIC_8 + * IM_MOSAIC_16 + * IM_MOSAIC_32 + * IM_MOSAIC_64 + * IM_MOSAIC_128 + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS immosaic(const rga_buffer_t image, im_rect rect, int mosaic_mode, int sync = 1, int *release_fence_fd = NULL); + +/** + * MOSAIC array + * + * @param image + * The output destination image. + * @param rect_array + * The rectangle arrays on the source image that needs to be filled with color. + * @param array_size + * The size of rectangular area arrays. + * @param mosaic_mode + * mosaic block width configuration: + * IM_MOSAIC_8 + * IM_MOSAIC_16 + * IM_MOSAIC_32 + * IM_MOSAIC_64 + * IM_MOSAIC_128 + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS immosaicArray(const rga_buffer_t image, im_rect *rect_array, int array_size, int mosaic_mode, int sync = 1, int *release_fence_fd = NULL); + +/** + * palette + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param lut + * The LUT table. + * @param sync + * When 'sync == 1', wait for the operation to complete and return, otherwise return directly. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS impalette(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t lut, int sync = 1, int *release_fence_fd = NULL); + +/** + * process for single task mode + * + * @param src + * The input source image and is also the foreground image in blend. + * @param dst + * The output destination image and is also the foreground image in blend. + * @param pat + * The foreground image, or a LUT table. + * @param srect + * The rectangle on the src channel image that needs to be processed. + * @param drect + * The rectangle on the dst channel image that needs to be processed. + * @param prect + * The rectangle on the pat channel image that needs to be processed. + * @param opt + * The image processing options configuration. + * @param usage + * The image processing usage. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS improcess(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat, + im_rect srect, im_rect drect, im_rect prect, + int acquire_fence_fd, int *release_fence_fd, + im_opt_t *opt_ptr, int usage); + +/** + * make border + * + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param top + * the top pixels + * @param bottom + * the bottom pixels + * @param left + * the left pixels + * @param right + * the right pixels + * @param border_type + * Border type. + * @param value + * The pixel value at which the border is filled. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS immakeBorder(rga_buffer_t src, rga_buffer_t dst, + int top, int bottom, int left, int right, + int border_type, int value = 0, + int sync = 1, int acquir_fence_fd = -1, int *release_fence_fd = NULL); + +#endif /* #ifdef __cplusplus */ + +IM_C_API IM_STATUS immosaic(const rga_buffer_t image, im_rect rect, int mosaic_mode, int sync); +IM_C_API IM_STATUS imosd(const rga_buffer_t osd,const rga_buffer_t dst, + const im_rect osd_rect, im_osd_t *osd_config, int sync); +IM_C_API IM_STATUS improcess(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat, + im_rect srect, im_rect drect, im_rect prect, int usage); + +/* Start: Symbols reserved for compatibility with macro functions */ +IM_C_API IM_STATUS imcopy_t(const rga_buffer_t src, rga_buffer_t dst, int sync); +IM_C_API IM_STATUS imresize_t(const rga_buffer_t src, rga_buffer_t dst, double fx, double fy, int interpolation, int sync); +IM_C_API IM_STATUS imcrop_t(const rga_buffer_t src, rga_buffer_t dst, im_rect rect, int sync); +IM_C_API IM_STATUS imtranslate_t(const rga_buffer_t src, rga_buffer_t dst, int x, int y, int sync); +IM_C_API IM_STATUS imcvtcolor_t(rga_buffer_t src, rga_buffer_t dst, int sfmt, int dfmt, int mode, int sync); +IM_C_API IM_STATUS imrotate_t(const rga_buffer_t src, rga_buffer_t dst, int rotation, int sync); +IM_C_API IM_STATUS imflip_t (const rga_buffer_t src, rga_buffer_t dst, int mode, int sync); +IM_C_API IM_STATUS imblend_t(const rga_buffer_t srcA, const rga_buffer_t srcB, rga_buffer_t dst, int mode, int sync); +IM_C_API IM_STATUS imcolorkey_t(const rga_buffer_t src, rga_buffer_t dst, im_colorkey_range range, int mode, int sync); +IM_C_API IM_STATUS imquantize_t(const rga_buffer_t src, rga_buffer_t dst, im_nn_t nn_info, int sync); +IM_C_API IM_STATUS imrop_t(const rga_buffer_t src, rga_buffer_t dst, int rop_code, int sync); +IM_C_API IM_STATUS imfill_t(rga_buffer_t dst, im_rect rect, int color, int sync); +IM_C_API IM_STATUS impalette_t(rga_buffer_t src, rga_buffer_t dst, rga_buffer_t lut, int sync); +/* End: Symbols reserved for compatibility with macro functions */ + +#ifndef __cplusplus + +#define RGA_GET_MIN(n1, n2) ((n1) < (n2) ? (n1) : (n2)) + +/** + * copy + * + * @param src + * @param dst + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imcopy(src, dst, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imcopy_t(src, dst, 1); \ + } else if (__argc == 1){ \ + __ret = imcopy_t(src, dst, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +/** + * Resize + * + * @param src + * @param dst + * @param fx + * @param fy + * @param interpolation + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imresize(src, dst, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + double __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(double); \ + if (__argc == 0) { \ + __ret = imresize_t(src, dst, 0, 0, INTER_LINEAR, 1); \ + } else if (__argc == 2){ \ + __ret = imresize_t(src, dst, __args[RGA_GET_MIN(__argc, 0)], __args[RGA_GET_MIN(__argc, 1)], INTER_LINEAR, 1); \ + } else if (__argc == 3){ \ + __ret = imresize_t(src, dst, __args[RGA_GET_MIN(__argc, 0)], __args[RGA_GET_MIN(__argc, 1)], (int)__args[RGA_GET_MIN(__argc, 2)], 1); \ + } else if (__argc == 4){ \ + __ret = imresize_t(src, dst, __args[RGA_GET_MIN(__argc, 0)], __args[RGA_GET_MIN(__argc, 1)], (int)__args[RGA_GET_MIN(__argc, 2)], (int)__args[RGA_GET_MIN(__argc, 3)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +#define impyramid(src, dst, direction) \ + imresize_t(src, \ + dst, \ + direction == IM_UP_SCALE ? 0.5 : 2, \ + direction == IM_UP_SCALE ? 0.5 : 2, \ + INTER_LINEAR, 1) + +/** + * format convert + * + * @param src + * @param dst + * @param sfmt + * @param dfmt + * @param mode + * color space mode: IM_COLOR_SPACE_MODE + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imcvtcolor(src, dst, sfmt, dfmt, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imcvtcolor_t(src, dst, sfmt, dfmt, IM_COLOR_SPACE_DEFAULT, 1); \ + } else if (__argc == 1){ \ + __ret = imcvtcolor_t(src, dst, sfmt, dfmt, (int)__args[RGA_GET_MIN(__argc, 0)], 1); \ + } else if (__argc == 2){ \ + __ret = imcvtcolor_t(src, dst, sfmt, dfmt, (int)__args[RGA_GET_MIN(__argc, 0)], (int)__args[RGA_GET_MIN(__argc, 1)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +/** + * Crop + * + * @param src + * @param dst + * @param rect + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imcrop(src, dst, rect, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imcrop_t(src, dst, rect, 1); \ + } else if (__argc == 1){ \ + __ret = imcrop_t(src, dst, rect, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +/** + * translate + * + * @param src + * @param dst + * @param x + * @param y + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imtranslate(src, dst, x, y, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imtranslate_t(src, dst, x, y, 1); \ + } else if (__argc == 1){ \ + __ret = imtranslate_t(src, dst, x, y, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +/** + * rotation + * + * @param src + * @param dst + * @param rotation + * IM_HAL_TRANSFORM_ROT_90 + * IM_HAL_TRANSFORM_ROT_180 + * IM_HAL_TRANSFORM_ROT_270 + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imrotate(src, dst, rotation, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imrotate_t(src, dst, rotation, 1); \ + } else if (__argc == 1){ \ + __ret = imrotate_t(src, dst, rotation, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + + +/** + * flip + * + * @param src + * @param dst + * @param mode + * IM_HAL_TRANSFORM_FLIP_H + * IM_HAL_TRANSFORM_FLIP_V + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imflip(src, dst, mode, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imflip_t(src, dst, mode, 1); \ + } else if (__argc == 1){ \ + __ret = imflip_t(src, dst, mode, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +/** + * blend (SRC + DST -> DST or SRCA + SRCB -> DST) + * + * @param srcA + * @param srcB can be NULL. + * @param dst + * @param mode + * IM_ALPHA_BLEND_MODE + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imblend(srcA, dst, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + rga_buffer_t srcB; \ + memset(&srcB, 0x00, sizeof(rga_buffer_t)); \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imblend_t(srcA, srcB, dst, IM_ALPHA_BLEND_SRC_OVER, 1); \ + } else if (__argc == 1){ \ + __ret = imblend_t(srcA, srcB, dst, (int)__args[RGA_GET_MIN(__argc, 0)], 1); \ + } else if (__argc == 2){ \ + __ret = imblend_t(srcA, srcB, dst, (int)__args[RGA_GET_MIN(__argc, 0)], (int)__args[RGA_GET_MIN(__argc, 1)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) +#define imcomposite(srcA, srcB, dst, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imblend_t(srcA, srcB, dst, IM_ALPHA_BLEND_SRC_OVER, 1); \ + } else if (__argc == 1){ \ + __ret = imblend_t(srcA, srcB, dst, (int)__args[RGA_GET_MIN(__argc, 0)], 1); \ + } else if (__argc == 2){ \ + __ret = imblend_t(srcA, srcB, dst, (int)__args[RGA_GET_MIN(__argc, 0)], (int)__args[RGA_GET_MIN(__argc, 1)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +/** + * color key + * + * @param src + * @param dst + * @param colorkey_range + * max color + * min color + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imcolorkey(src, dst, range, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imcolorkey_t(src, dst, range, IM_ALPHA_COLORKEY_NORMAL, 1); \ + } else if (__argc == 1){ \ + __ret = imcolorkey_t(src, dst, range, (int)__args[RGA_GET_MIN(__argc, 0)], 1); \ + } else if (__argc == 2){ \ + __ret = imcolorkey_t(src, dst, range, (int)__args[RGA_GET_MIN(__argc, 0)], (int)__args[RGA_GET_MIN(__argc, 1)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +/** + * nn quantize + * + * @param src + * @param dst + * @param nninfo + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imquantize(src, dst, nn_info, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imquantize_t(src, dst, nn_info, 1); \ + } else if (__argc == 1){ \ + __ret = imquantize_t(src, dst, nn_info, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + + +/** + * ROP + * + * @param src + * @param dst + * @param rop_code + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imrop(src, dst, rop_code, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imrop_t(src, dst, rop_code, 1); \ + } else if (__argc == 1){ \ + __ret = imrop_t(src, dst, rop_code, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +/** + * fill/reset/draw + * + * @param src + * @param dst + * @param rect + * @param color + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define imfill(buf, rect, color, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imfill_t(buf, rect, color, 1); \ + } else if (__argc == 1){ \ + __ret = imfill_t(buf, rect, color, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +#define imreset(buf, rect, color, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imfill_t(buf, rect, color, 1); \ + } else if (__argc == 1){ \ + __ret = imfill_t(buf, rect, color, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +#define imdraw(buf, rect, color, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = imfill_t(buf, rect, color, 1); \ + } else if (__argc == 1){ \ + __ret = imfill_t(buf, rect, color, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) + +/** + * palette + * + * @param src + * @param dst + * @param lut + * @param sync + * wait until operation complete + * + * @returns success or else negative error code. + */ +#define impalette(src, dst, lut, ...) \ + ({ \ + IM_STATUS __ret = IM_STATUS_SUCCESS; \ + int __args[] = {__VA_ARGS__}; \ + int __argc = sizeof(__args)/sizeof(int); \ + if (__argc == 0) { \ + __ret = impalette_t(src, dst, lut, 1); \ + } else if (__argc == 1){ \ + __ret = impalette_t(src, dst, lut, (int)__args[RGA_GET_MIN(__argc, 0)]); \ + } else { \ + __ret = IM_STATUS_INVALID_PARAM; \ + printf("invalid parameter\n"); \ + } \ + __ret; \ + }) +/* End define IM2D macro API */ +#endif + +#endif /* #ifndef _im2d_single_h_ */ \ No newline at end of file diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_task.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_task.h new file mode 100644 index 0000000..9f8db59 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_task.h @@ -0,0 +1,497 @@ +/* + * Copyright (C) 2022 Rockchip Electronics Co., Ltd. + * Authors: + * Cerf Yu + * + * 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. + */ +#ifndef _im2d_task_h_ +#define _im2d_task_h_ + +#include "im2d_type.h" + +#ifdef __cplusplus + +/** + * Create an rga job + * + * @param flags + * Some configuration flags for this job + * + * @returns job handle. + */ +IM_API im_job_handle_t imbeginJob(uint64_t flags = 0); + +/** + * Submit and run an rga job + * + * @param job_handle + * This is the job handle that will be submitted. + * @param sync_mode + * run mode: + * IM_SYNC + * IM_ASYNC + * @param acquire_fence_fd + * @param release_fence_fd + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imendJob(im_job_handle_t job_handle, + int sync_mode = IM_SYNC, + int acquire_fence_fd = 0, int *release_fence_fd = NULL); + +/** + * Cancel and delete an rga job + * + * @param job_handle + * This is the job handle that will be cancelled. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcancelJob(im_job_handle_t job_handle); + +/** + * Add copy task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcopyTask(im_job_handle_t job_handle, const rga_buffer_t src, rga_buffer_t dst); + +/** + * Add resize task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param fx + * X-direction resize factor. + * @param fy + * X-direction resize factor. + * @param interpolation + * Interpolation formula(Only RGA1 support). + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imresizeTask(im_job_handle_t job_handle, + const rga_buffer_t src, rga_buffer_t dst, + double fx = 0, double fy = 0, + int interpolation = 0); + +/** + * Add crop task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param rect + * The rectangle on the source image that needs to be cropped. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcropTask(im_job_handle_t job_handle, + const rga_buffer_t src, rga_buffer_t dst, im_rect rect); + +/** + * Add translate task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param x + * Output the coordinates of the starting point in the X-direction of the destination image. + * @param y + * Output the coordinates of the starting point in the Y-direction of the destination image. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imtranslateTask(im_job_handle_t job_handle, + const rga_buffer_t src, rga_buffer_t dst, int x, int y); + +/** + * Add format convert task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param sfmt + * The source image format. + * @param dfmt + * The destination image format. + * @param mode + * color space mode: + * IM_YUV_TO_RGB_BT601_LIMIT + * IM_YUV_TO_RGB_BT601_FULL + * IM_YUV_TO_RGB_BT709_LIMIT + * IM_RGB_TO_YUV_BT601_FULL + * IM_RGB_TO_YUV_BT601_LIMIT + * IM_RGB_TO_YUV_BT709_LIMIT + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcvtcolorTask(im_job_handle_t job_handle, + rga_buffer_t src, rga_buffer_t dst, + int sfmt, int dfmt, int mode = IM_COLOR_SPACE_DEFAULT); + +/** + * Add rotation task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param rotation + * IM_HAL_TRANSFORM_ROT_90 + * IM_HAL_TRANSFORM_ROT_180 + * IM_HAL_TRANSFORM_ROT_270 + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imrotateTask(im_job_handle_t job_handle, + const rga_buffer_t src, rga_buffer_t dst, int rotation); + +/** + * Add flip task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param mode + * IM_HAL_TRANSFORM_FLIP_H + * IM_HAL_TRANSFORM_FLIP_V + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imflipTask(im_job_handle_t job_handle, + const rga_buffer_t src, rga_buffer_t dst, int mode); + +/** + * Add blend(SRC + DST -> DST) task + * + * @param job_handle + * Insert the task into the job handle. + * @param fg_image + * The foreground image. + * @param bg_image + * The background image, which is also the output destination image. + * @param mode + * Port-Duff mode: + * IM_ALPHA_BLEND_SRC + * IM_ALPHA_BLEND_DST + * IM_ALPHA_BLEND_SRC_OVER + * IM_ALPHA_BLEND_DST_OVER + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imblendTask(im_job_handle_t job_handle, + const rga_buffer_t fg_image, rga_buffer_t bg_image, + int mode = IM_ALPHA_BLEND_SRC_OVER); + +/** + * Add composite(SRCA + SRCB -> DST) task + * + * @param job_handle + * Insert the task into the job handle. + * @param fg_image + * The foreground image. + * @param bg_image + * The background image. + * @param output_image + * The output destination image. + * @param mode + * Port-Duff mode: + * IM_ALPHA_BLEND_SRC + * IM_ALPHA_BLEND_DST + * IM_ALPHA_BLEND_SRC_OVER + * IM_ALPHA_BLEND_DST_OVER + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcompositeTask(im_job_handle_t job_handle, + const rga_buffer_t fg_image, const rga_buffer_t bg_image, + rga_buffer_t output_image, + int mode = IM_ALPHA_BLEND_SRC_OVER); + +/** + * Add color key task + * + * @param job_handle + * Insert the task into the job handle. + * @param fg_image + * The foreground image. + * @param bg_image + * The background image, which is also the output destination image. + * @param colorkey_range + * The range of color key. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imcolorkeyTask(im_job_handle_t job_handle, + const rga_buffer_t fg_image, rga_buffer_t bg_image, + im_colorkey_range range, int mode = IM_ALPHA_COLORKEY_NORMAL); + +/** + * Add OSD task + * + * @param job_handle + * Insert the task into the job handle. + * @param osd + * The osd text block. + * @param dst + * The background image. + * @param osd_rect + * The rectangle on the source image that needs to be OSD. + * @param osd_config + * osd mode configuration. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imosdTask(im_job_handle_t job_handle, + const rga_buffer_t osd,const rga_buffer_t bg_image, + const im_rect osd_rect, im_osd_t *osd_config); + +/** + * Add nn quantize task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param nninfo + * nn configuration + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imquantizeTask(im_job_handle_t job_handle, + const rga_buffer_t src, rga_buffer_t dst, im_nn_t nn_info); + +/** + * Add ROP task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param rop_code + * The ROP opcode. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imropTask(im_job_handle_t job_handle, + const rga_buffer_t src, rga_buffer_t dst, int rop_code); + +/** + * Add color fill task + * + * @param job_handle + * Insert the task into the job handle. + * @param dst + * The output destination image. + * @param rect + * The rectangle on the source image that needs to be filled with color. + * @param color + * The fill color value. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imfillTask(im_job_handle_t job_handle, rga_buffer_t dst, im_rect rect, uint32_t color); + +/** + * Add color fill task array + * + * @param job_handle + * Insert the task into the job handle. + * @param dst + * The output destination image. + * @param rect_array + * The rectangle arrays on the source image that needs to be filled with color. + * @param array_size + * The size of rectangular area arrays. + * @param color + * The fill color value. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imfillTaskArray(im_job_handle_t job_handle, + rga_buffer_t dst, + im_rect *rect_array, int array_size, uint32_t color); + +/** + * Add fill rectangle task + * + * @param job_handle + * Insert the task into the job handle. + * @param dst + * The output destination image. + * @param rect + * The rectangle on the source image that needs to be filled with color. + * @param color + * The fill color value. + * @param thickness + * Thickness of lines that make up the rectangle. Negative values, like -1, + * mean that the function has to draw a filled rectangle. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imrectangleTask(im_job_handle_t job_handle, + rga_buffer_t dst, + im_rect rect, + uint32_t color, int thickness); + +/** + * Add fill rectangle task array + * + * @param job_handle + * Insert the task into the job handle. + * @param dst + * The output destination image. + * @param rect_array + * The rectangle arrays on the source image that needs to be filled with color. + * @param array_size + * The size of rectangular area arrays. + * @param color + * The fill color value. + * @param thickness + * Thickness of lines that make up the rectangle. Negative values, like -1, + * mean that the function has to draw a filled rectangle. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS imrectangleTaskArray(im_job_handle_t job_handle, + rga_buffer_t dst, + im_rect *rect_array, int array_size, + uint32_t color, int thickness); + +/** + * Add mosaic task + * + * @param job_handle + * Insert the task into the job handle. + * @param image + * The output destination image. + * @param rect + * The rectangle on the source image that needs to be mosaicked. + * @param mosaic_mode + * mosaic block width configuration: + * IM_MOSAIC_8 + * IM_MOSAIC_16 + * IM_MOSAIC_32 + * IM_MOSAIC_64 + * IM_MOSAIC_128 + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS immosaicTask(im_job_handle_t job_handle, + const rga_buffer_t image, im_rect rect, int mosaic_mode); + +/** + * Add mosaic task + * + * @param job_handle + * Insert the task into the job handle. + * @param image + * The output destination image. + * @param rect_array + * The rectangle arrays on the source image that needs to be filled with color. + * @param array_size + * The size of rectangular area arrays. + * @param mosaic_mode + * mosaic block width configuration: + * IM_MOSAIC_8 + * IM_MOSAIC_16 + * IM_MOSAIC_32 + * IM_MOSAIC_64 + * IM_MOSAIC_128 + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS immosaicTaskArray(im_job_handle_t job_handle, + const rga_buffer_t image, + im_rect *rect_array, int array_size, int mosaic_mode); + +/** + * Add palette task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image. + * @param dst + * The output destination image. + * @param lut + * The LUT table. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS impaletteTask(im_job_handle_t job_handle, + rga_buffer_t src, rga_buffer_t dst, rga_buffer_t lut); + +/** + * Add process task + * + * @param job_handle + * Insert the task into the job handle. + * @param src + * The input source image and is also the foreground image in blend. + * @param dst + * The output destination image and is also the foreground image in blend. + * @param pat + * The foreground image, or a LUT table. + * @param srect + * The rectangle on the src channel image that needs to be processed. + * @param drect + * The rectangle on the dst channel image that needs to be processed. + * @param prect + * The rectangle on the pat channel image that needs to be processed. + * @param opt + * The image processing options configuration. + * @param usage + * The image processing usage. + * + * @returns success or else negative error code. + */ +IM_API IM_STATUS improcessTask(im_job_handle_t job_handle, + rga_buffer_t src, rga_buffer_t dst, rga_buffer_t pat, + im_rect srect, im_rect drect, im_rect prect, + im_opt_t *opt_ptr, int usage); + +#endif /* #ifdef __cplusplus */ + +#endif /* #ifndef _im2d_task_h_ */ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_type.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_type.h new file mode 100644 index 0000000..24365b4 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_type.h @@ -0,0 +1,436 @@ +/* + * Copyright (C) 2022 Rockchip Electronics Co., Ltd. + * Authors: + * Cerf Yu + * + * 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. + */ + +#ifndef _RGA_IM2D_TYPE_H_ +#define _RGA_IM2D_TYPE_H_ + +#include + +#include "rga.h" + +#define IM_API /* define API export as needed */ + +#ifdef __cplusplus +#define IM_C_API extern "C" +#define IM_EXPORT_API extern "C" +#else +#define IM_C_API +#define IM_EXPORT_API +#endif + +#ifdef __cplusplus +#define DEFAULT_INITIALIZER(x) = x +#else +#define DEFAULT_INITIALIZER(x) +#endif + +typedef uint32_t im_api_version_t; +typedef uint32_t im_job_handle_t; +typedef uint32_t im_ctx_id_t; +typedef uint32_t rga_buffer_handle_t; + +typedef enum { + /* Rotation */ + IM_HAL_TRANSFORM_ROT_90 = 1 << 0, + IM_HAL_TRANSFORM_ROT_180 = 1 << 1, + IM_HAL_TRANSFORM_ROT_270 = 1 << 2, + IM_HAL_TRANSFORM_FLIP_H = 1 << 3, + IM_HAL_TRANSFORM_FLIP_V = 1 << 4, + IM_HAL_TRANSFORM_FLIP_H_V = 1 << 5, + IM_HAL_TRANSFORM_MASK = 0x3f, + + /* + * Blend + * Additional blend usage, can be used with both source and target configs. + * If none of the below is set, the default "SRC over DST" is applied. + */ + IM_ALPHA_BLEND_SRC_OVER = 1 << 6, /* Default, Porter-Duff "SRC over DST" */ + IM_ALPHA_BLEND_SRC = 1 << 7, /* Porter-Duff "SRC" */ + IM_ALPHA_BLEND_DST = 1 << 8, /* Porter-Duff "DST" */ + IM_ALPHA_BLEND_SRC_IN = 1 << 9, /* Porter-Duff "SRC in DST" */ + IM_ALPHA_BLEND_DST_IN = 1 << 10, /* Porter-Duff "DST in SRC" */ + IM_ALPHA_BLEND_SRC_OUT = 1 << 11, /* Porter-Duff "SRC out DST" */ + IM_ALPHA_BLEND_DST_OUT = 1 << 12, /* Porter-Duff "DST out SRC" */ + IM_ALPHA_BLEND_DST_OVER = 1 << 13, /* Porter-Duff "DST over SRC" */ + IM_ALPHA_BLEND_SRC_ATOP = 1 << 14, /* Porter-Duff "SRC ATOP" */ + IM_ALPHA_BLEND_DST_ATOP = 1 << 15, /* Porter-Duff "DST ATOP" */ + IM_ALPHA_BLEND_XOR = 1 << 16, /* Xor */ + IM_ALPHA_BLEND_MASK = 0x1ffc0, + + IM_ALPHA_COLORKEY_NORMAL = 1 << 17, + IM_ALPHA_COLORKEY_INVERTED = 1 << 18, + IM_ALPHA_COLORKEY_MASK = 0x60000, + + IM_SYNC = 1 << 19, + IM_CROP = 1 << 20, /* Unused */ + IM_COLOR_FILL = 1 << 21, + IM_COLOR_PALETTE = 1 << 22, + IM_NN_QUANTIZE = 1 << 23, + IM_ROP = 1 << 24, + IM_ALPHA_BLEND_PRE_MUL = 1 << 25, + IM_ASYNC = 1 << 26, + IM_MOSAIC = 1 << 27, + IM_OSD = 1 << 28, + IM_PRE_INTR = 1 << 29, +} IM_USAGE; + +typedef enum { + IM_RASTER_MODE = 1 << 0, + IM_FBC_MODE = 1 << 1, + IM_TILE_MODE = 1 << 2, +} IM_RD_MODE; + +typedef enum { + IM_SCHEDULER_RGA3_CORE0 = 1 << 0, + IM_SCHEDULER_RGA3_CORE1 = 1 << 1, + IM_SCHEDULER_RGA2_CORE0 = 1 << 2, + IM_SCHEDULER_RGA3_DEFAULT = IM_SCHEDULER_RGA3_CORE0, + IM_SCHEDULER_RGA2_DEFAULT = IM_SCHEDULER_RGA2_CORE0, + IM_SCHEDULER_MASK = 0x7, + IM_SCHEDULER_DEFAULT = 0, +} IM_SCHEDULER_CORE; + +typedef enum { + IM_ROP_AND = 0x88, + IM_ROP_OR = 0xee, + IM_ROP_NOT_DST = 0x55, + IM_ROP_NOT_SRC = 0x33, + IM_ROP_XOR = 0xf6, + IM_ROP_NOT_XOR = 0xf9, +} IM_ROP_CODE; + +typedef enum { + IM_MOSAIC_8 = 0x0, + IM_MOSAIC_16 = 0x1, + IM_MOSAIC_32 = 0x2, + IM_MOSAIC_64 = 0x3, + IM_MOSAIC_128 = 0x4, +} IM_MOSAIC_MODE; + +typedef enum { + IM_BORDER_CONSTANT = 0, /* iiiiii|abcdefgh|iiiiiii with some specified value 'i' */ + IM_BORDER_REFLECT = 2, /* fedcba|abcdefgh|hgfedcb */ + IM_BORDER_WRAP = 3, /* cdefgh|abcdefgh|abcdefg */ +} IM_BORDER_TYPE; + +/* Status codes, returned by any blit function */ +typedef enum { + IM_YUV_TO_RGB_BT601_LIMIT = 1 << 0, + IM_YUV_TO_RGB_BT601_FULL = 2 << 0, + IM_YUV_TO_RGB_BT709_LIMIT = 3 << 0, + IM_YUV_TO_RGB_MASK = 3 << 0, + IM_RGB_TO_YUV_BT601_FULL = 1 << 2, + IM_RGB_TO_YUV_BT601_LIMIT = 2 << 2, + IM_RGB_TO_YUV_BT709_LIMIT = 3 << 2, + IM_RGB_TO_YUV_MASK = 3 << 2, + IM_RGB_TO_Y4 = 1 << 4, + IM_RGB_TO_Y4_DITHER = 2 << 4, + IM_RGB_TO_Y1_DITHER = 3 << 4, + IM_Y4_MASK = 3 << 4, + IM_RGB_FULL = 1 << 8, + IM_RGB_CLIP = 2 << 8, + IM_YUV_BT601_LIMIT_RANGE = 3 << 8, + IM_YUV_BT601_FULL_RANGE = 4 << 8, + IM_YUV_BT709_LIMIT_RANGE = 5 << 8, + IM_YUV_BT709_FULL_RANGE = 6 << 8, + IM_FULL_CSC_MASK = 0xf << 8, + IM_COLOR_SPACE_DEFAULT = 0, +} IM_COLOR_SPACE_MODE; + +typedef enum { + IM_UP_SCALE, + IM_DOWN_SCALE, +} IM_SCALE; + +typedef enum { + INTER_NEAREST, + INTER_LINEAR, + INTER_CUBIC, +} IM_SCALE_MODE; + +typedef enum { + IM_CONFIG_SCHEDULER_CORE, + IM_CONFIG_PRIORITY, + IM_CONFIG_CHECK, +} IM_CONFIG_NAME; + +typedef enum { + IM_OSD_MODE_STATISTICS = 0x1 << 0, + IM_OSD_MODE_AUTO_INVERT = 0x1 << 1, +} IM_OSD_MODE; + +typedef enum { + IM_OSD_INVERT_CHANNEL_NONE = 0x0, + IM_OSD_INVERT_CHANNEL_Y_G = 0x1 << 0, + IM_OSD_INVERT_CHANNEL_C_RB = 0x1 << 1, + IM_OSD_INVERT_CHANNEL_ALPHA = 0x1 << 2, + IM_OSD_INVERT_CHANNEL_COLOR = IM_OSD_INVERT_CHANNEL_Y_G | + IM_OSD_INVERT_CHANNEL_C_RB, + IM_OSD_INVERT_CHANNEL_BOTH = IM_OSD_INVERT_CHANNEL_COLOR | + IM_OSD_INVERT_CHANNEL_ALPHA, +} IM_OSD_INVERT_CHANNEL; + +typedef enum { + IM_OSD_FLAGS_INTERNAL = 0, + IM_OSD_FLAGS_EXTERNAL, +} IM_OSD_FLAGS_MODE; + +typedef enum { + IM_OSD_INVERT_USE_FACTOR, + IM_OSD_INVERT_USE_SWAP, +} IM_OSD_INVERT_MODE; + +typedef enum { + IM_OSD_BACKGROUND_DEFAULT_BRIGHT = 0, + IM_OSD_BACKGROUND_DEFAULT_DARK, +} IM_OSD_BACKGROUND_DEFAULT; + +typedef enum { + IM_OSD_BLOCK_MODE_NORMAL = 0, + IM_OSD_BLOCK_MODE_DIFFERENT, +} IM_OSD_BLOCK_WIDTH_MODE; + +typedef enum { + IM_OSD_MODE_HORIZONTAL, + IM_OSD_MODE_VERTICAL, +} IM_OSD_DIRECTION; + +typedef enum { + IM_OSD_COLOR_PIXEL, + IM_OSD_COLOR_EXTERNAL, +} IM_OSD_COLOR_MODE; + +typedef enum { + IM_INTR_READ_INTR = 1 << 0, + IM_INTR_READ_HOLD = 1 << 1, + IM_INTR_WRITE_INTR = 1 << 2, +} IM_PRE_INTR_FLAGS; + +typedef enum { + IM_CONTEXT_NONE = 0x0, + IM_CONTEXT_SRC_FIX_ENABLE = 0x1 << 0, // Enable kernel to modify the image parameters of the channel. + IM_CONTEXT_SRC_CACHE_INFO = 0x1 << 1, // It will replace the parameters in ctx with the modified parameters. + IM_CONTEXT_SRC1_FIX_ENABLE = 0x1 << 2, + IM_CONTEXT_SRC1_CACHE_INFO = 0x1 << 3, + IM_CONTEXT_DST_FIX_ENABLE = 0x1 << 4, + IM_CONTEXT_DST_CACHE_INFO = 0x1 << 5, +} IM_CONTEXT_FLAGS; + +/* Get RGA basic information index */ +typedef enum { + RGA_VENDOR = 0, + RGA_VERSION, + RGA_MAX_INPUT, + RGA_MAX_OUTPUT, + RGA_BYTE_STRIDE, + RGA_SCALE_LIMIT, + RGA_INPUT_FORMAT, + RGA_OUTPUT_FORMAT, + RGA_FEATURE, + RGA_EXPECTED, + RGA_ALL, +} IM_INFORMATION; + +/* Status codes, returned by any blit function */ +typedef enum { + IM_STATUS_NOERROR = 2, + IM_STATUS_SUCCESS = 1, + IM_STATUS_NOT_SUPPORTED = -1, + IM_STATUS_OUT_OF_MEMORY = -2, + IM_STATUS_INVALID_PARAM = -3, + IM_STATUS_ILLEGAL_PARAM = -4, + IM_STATUS_ERROR_VERSION = -5, + IM_STATUS_FAILED = 0, +} IM_STATUS; + +/* Rectangle definition */ +typedef struct { + int x; /* upper-left x */ + int y; /* upper-left y */ + int width; /* width */ + int height; /* height */ +} im_rect; + +typedef struct { + int max; /* The Maximum value of the color key */ + int min; /* The minimum value of the color key */ +} im_colorkey_range; + + +typedef struct im_nn { + int scale_r; /* scaling factor on R channal */ + int scale_g; /* scaling factor on G channal */ + int scale_b; /* scaling factor on B channal */ + int offset_r; /* offset on R channal */ + int offset_g; /* offset on G channal */ + int offset_b; /* offset on B channal */ +} im_nn_t; + +/* im_info definition */ +typedef struct { + void* vir_addr; /* virtual address */ + void* phy_addr; /* physical address */ + int fd; /* shared fd */ + + int width; /* width */ + int height; /* height */ + int wstride; /* wstride */ + int hstride; /* hstride */ + int format; /* format */ + + int color_space_mode; /* color_space_mode */ + int global_alpha; /* global_alpha */ + int rd_mode; + + /* legarcy */ + int color; /* color, used by color fill */ + im_colorkey_range colorkey_range; /* range value of color key */ + im_nn_t nn; + int rop_code; + + rga_buffer_handle_t handle; /* buffer handle */ +} rga_buffer_t; + +typedef struct im_color { + union { + struct { + uint8_t red; + uint8_t green; + uint8_t blue; + uint8_t alpha; + }; + uint32_t value; + }; +} im_color_t; + +typedef struct im_osd_invert_factor { + uint8_t alpha_max; + uint8_t alpha_min; + uint8_t yg_max; + uint8_t yg_min; + uint8_t crb_max; + uint8_t crb_min; +} im_osd_invert_factor_t; + +typedef struct im_osd_bpp2 { + uint8_t ac_swap; // ac swap flag + // 0: CA + // 1: AC + uint8_t endian_swap; // rgba2bpp endian swap + // 0: Big endian + // 1: Little endian + im_color_t color0; + im_color_t color1; +} im_osd_bpp2_t; + +typedef struct im_osd_block { + int width_mode; // normal or different + // IM_OSD_BLOCK_MODE_NORMAL + // IM_OSD_BLOCK_MODE_DIFFERENT + union { + int width; // normal_mode block width + int width_index; // different_mode block width index in RAM + }; + + int block_count; // block count + + int background_config; // background config is bright or dark + // IM_OSD_BACKGROUND_DEFAULT_BRIGHT + // IM_OSD_BACKGROUND_DEFAULT_DARK + + int direction; // osd block direction + // IM_OSD_MODE_HORIZONTAL + // IM_OSD_MODE_VERTICAL + + int color_mode; // using src1 color or config color + // IM_OSD_COLOR_PIXEL + // IM_OSD_COLOR_EXTERNAL + im_color_t normal_color; // config color: normal + im_color_t invert_color; // config color: invert +} im_osd_block_t; + +typedef struct im_osd_invert { + int invert_channel; // invert channel config: + // IM_OSD_INVERT_CHANNEL_NONE + // IM_OSD_INVERT_CHANNEL_Y_G + // IM_OSD_INVERT_CHANNEL_C_RB + // IM_OSD_INVERT_CHANNEL_ALPHA + // IM_OSD_INVERT_CHANNEL_COLOR + // IM_OSD_INVERT_CHANNEL_BOTH + int flags_mode; // use external or inertnal RAM invert flags + // IM_OSD_FLAGS_EXTERNAL + // IM_OSD_FLAGS_INTERNAL + int flags_index; // flags index when using internal RAM invert flags + + uint64_t invert_flags; // external invert flags + uint64_t current_flags; // current flags + + int invert_mode; // invert use swap or factor + // IM_OSD_INVERT_USE_FACTOR + // IM_OSD_INVERT_USE_SWAP + im_osd_invert_factor_t factor; + + int threash; +} im_osd_invert_t; + +typedef struct im_osd { + int osd_mode; // osd mode: statistics or auto_invert + // IM_OSD_MODE_STATISTICS + // IM_OSD_MODE_AUTO_INVERT + im_osd_block_t block_parm; // osd block info config + + im_osd_invert_t invert_config; + + im_osd_bpp2_t bpp2_info; +} im_osd_t; + +typedef struct im_intr_config { + uint32_t flags; + + int read_threshold; + int write_start; + int write_step; +} im_intr_config_t; + +typedef struct im_opt { + im_api_version_t version DEFAULT_INITIALIZER(RGA_CURRENT_API_HEADER_VERSION); + + int color; /* color, used by color fill */ + im_colorkey_range colorkey_range; /* range value of color key */ + im_nn_t nn; + int rop_code; + + int priority; + int core; + + int mosaic_mode; + + im_osd_t osd_config; + + im_intr_config_t intr_config; + + char reserve[128]; +} im_opt_t; + +typedef struct im_handle_param { + uint32_t width; + uint32_t height; + uint32_t format; +} im_handle_param_t; + +#endif /* _RGA_IM2D_TYPE_H_ */ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_version.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_version.h new file mode 100644 index 0000000..fa60b29 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/im2d_version.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2022 Rockchip Electronics Co., Ltd. + * Authors: + * Cerf Yu + * + * 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. + */ + +#ifndef _RGA_IM2D_VERSION_H_ +#define _RGA_IM2D_VERSION_H_ + +#define RGA_VERSION_STR_HELPER(x) #x +#define RGA_VERSION_STR(x) RGA_VERSION_STR_HELPER(x) + +/* RGA im2d api verison */ +#define RGA_API_MAJOR_VERSION 1 +#define RGA_API_MINOR_VERSION 9 +#define RGA_API_REVISION_VERSION 1 +#define RGA_API_BUILD_VERSION 4 + +#define RGA_API_VERSION \ + RGA_VERSION_STR(RGA_API_MAJOR_VERSION) "." \ + RGA_VERSION_STR(RGA_API_MINOR_VERSION) "." \ + RGA_VERSION_STR(RGA_API_REVISION_VERSION) "_[" \ + RGA_VERSION_STR(RGA_API_BUILD_VERSION) "]" +#define RGA_API_FULL_VERSION "rga_api version " RGA_API_VERSION + +/* For header file version verification */ +#define RGA_CURRENT_API_VERSION (\ + (RGA_API_MAJOR_VERSION & 0xff) << 24 | \ + (RGA_API_MINOR_VERSION & 0xff) << 16 | \ + (RGA_API_REVISION_VERSION & 0xff) << 8 | \ + (RGA_API_BUILD_VERSION & 0xff)\ + ) +#define RGA_CURRENT_API_HEADER_VERSION RGA_CURRENT_API_VERSION + +#endif /* _RGA_IM2D_VERSION_H_ */ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/rga.h b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/rga.h new file mode 100644 index 0000000..10045f5 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/include/rga.h @@ -0,0 +1,139 @@ +/* + * Copyright (C) 2016 Rockchip Electronics Co., Ltd. + * Authors: + * Zhiqin Wei + * + * 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. + */ + +#ifndef _RGA_DRIVER_H_ +#define _RGA_DRIVER_H_ + + +#ifndef ENABLE +#define ENABLE 1 +#endif + +#ifndef DISABLE +#define DISABLE 0 +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + +/* In order to be compatible with RK_FORMAT_XX and HAL_PIXEL_FORMAT_XX, + * RK_FORMAT_XX is shifted to the left by 8 bits to distinguish. */ +typedef enum _Rga_SURF_FORMAT { + RK_FORMAT_RGBA_8888 = 0x0 << 8, + RK_FORMAT_RGBX_8888 = 0x1 << 8, + RK_FORMAT_RGB_888 = 0x2 << 8, + RK_FORMAT_BGRA_8888 = 0x3 << 8, + RK_FORMAT_RGB_565 = 0x4 << 8, + RK_FORMAT_RGBA_5551 = 0x5 << 8, + RK_FORMAT_RGBA_4444 = 0x6 << 8, + RK_FORMAT_BGR_888 = 0x7 << 8, + + RK_FORMAT_YCbCr_422_SP = 0x8 << 8, + RK_FORMAT_YCbCr_422_P = 0x9 << 8, + RK_FORMAT_YCbCr_420_SP = 0xa << 8, + RK_FORMAT_YCbCr_420_P = 0xb << 8, + + RK_FORMAT_YCrCb_422_SP = 0xc << 8, + RK_FORMAT_YCrCb_422_P = 0xd << 8, + RK_FORMAT_YCrCb_420_SP = 0xe << 8, + RK_FORMAT_YCrCb_420_P = 0xf << 8, + + RK_FORMAT_BPP1 = 0x10 << 8, + RK_FORMAT_BPP2 = 0x11 << 8, + RK_FORMAT_BPP4 = 0x12 << 8, + RK_FORMAT_BPP8 = 0x13 << 8, + + RK_FORMAT_Y4 = 0x14 << 8, + RK_FORMAT_YCbCr_400 = 0x15 << 8, + + RK_FORMAT_BGRX_8888 = 0x16 << 8, + + RK_FORMAT_YVYU_422 = 0x18 << 8, + RK_FORMAT_YVYU_420 = 0x19 << 8, + RK_FORMAT_VYUY_422 = 0x1a << 8, + RK_FORMAT_VYUY_420 = 0x1b << 8, + RK_FORMAT_YUYV_422 = 0x1c << 8, + RK_FORMAT_YUYV_420 = 0x1d << 8, + RK_FORMAT_UYVY_422 = 0x1e << 8, + RK_FORMAT_UYVY_420 = 0x1f << 8, + + RK_FORMAT_YCbCr_420_SP_10B = 0x20 << 8, + RK_FORMAT_YCrCb_420_SP_10B = 0x21 << 8, + RK_FORMAT_YCbCr_422_SP_10B = 0x22 << 8, + RK_FORMAT_YCrCb_422_SP_10B = 0x23 << 8, + /* For compatibility with misspellings */ + RK_FORMAT_YCbCr_422_10b_SP = RK_FORMAT_YCbCr_422_SP_10B, + RK_FORMAT_YCrCb_422_10b_SP = RK_FORMAT_YCrCb_422_SP_10B, + + RK_FORMAT_BGR_565 = 0x24 << 8, + RK_FORMAT_BGRA_5551 = 0x25 << 8, + RK_FORMAT_BGRA_4444 = 0x26 << 8, + + RK_FORMAT_ARGB_8888 = 0x28 << 8, + RK_FORMAT_XRGB_8888 = 0x29 << 8, + RK_FORMAT_ARGB_5551 = 0x2a << 8, + RK_FORMAT_ARGB_4444 = 0x2b << 8, + RK_FORMAT_ABGR_8888 = 0x2c << 8, + RK_FORMAT_XBGR_8888 = 0x2d << 8, + RK_FORMAT_ABGR_5551 = 0x2e << 8, + RK_FORMAT_ABGR_4444 = 0x2f << 8, + + RK_FORMAT_RGBA2BPP = 0x30 << 8, + + RK_FORMAT_UNKNOWN = 0x100 << 8, +} RgaSURF_FORMAT; + +enum { + yuv2rgb_mode0 = 0x0, /* BT.601 MPEG */ + yuv2rgb_mode1 = 0x1, /* BT.601 JPEG */ + yuv2rgb_mode2 = 0x2, /* BT.709 */ + + rgb2yuv_601_full = 0x1 << 8, + rgb2yuv_709_full = 0x2 << 8, + yuv2yuv_601_limit_2_709_limit = 0x3 << 8, + yuv2yuv_601_limit_2_709_full = 0x4 << 8, + yuv2yuv_709_limit_2_601_limit = 0x5 << 8, + yuv2yuv_709_limit_2_601_full = 0x6 << 8, //not support + yuv2yuv_601_full_2_709_limit = 0x7 << 8, + yuv2yuv_601_full_2_709_full = 0x8 << 8, //not support + yuv2yuv_709_full_2_601_limit = 0x9 << 8, //not support + yuv2yuv_709_full_2_601_full = 0xa << 8, //not support + full_csc_mask = 0xf00, +}; + +enum { + RGA3_SCHEDULER_CORE0 = 1 << 0, + RGA3_SCHEDULER_CORE1 = 1 << 1, + RGA2_SCHEDULER_CORE0 = 1 << 2, +}; + +/* RGA3 rd_mode */ +enum +{ + raster_mode = 0x1 << 0, + fbc_mode = 0x1 << 1, + tile_mode = 0x1 << 2, +}; + +#ifdef __cplusplus +} +#endif + +#endif /*_RK29_IPP_DRIVER_H_*/ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/arm64-v8a/librga.a b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/arm64-v8a/librga.a new file mode 100644 index 0000000..4dca23b Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/arm64-v8a/librga.a differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/arm64-v8a/librga.so b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/arm64-v8a/librga.so new file mode 100644 index 0000000..74bd4de Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/arm64-v8a/librga.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/armeabi-v7a/librga.a b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/armeabi-v7a/librga.a new file mode 100644 index 0000000..dd02fa3 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/armeabi-v7a/librga.a differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/armeabi-v7a/librga.so b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/armeabi-v7a/librga.so new file mode 100644 index 0000000..e018d30 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Android/armeabi-v7a/librga.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Linux/aarch64/librga.a b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Linux/aarch64/librga.a new file mode 100644 index 0000000..bb4ae5d Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Linux/aarch64/librga.a differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Linux/aarch64/librga.so b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Linux/aarch64/librga.so new file mode 100644 index 0000000..9223831 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/3rdparty/rga/RK3588/lib/Linux/aarch64/librga.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/README.md b/Code/RK3588/stereo_yolo/rknpu2/examples/README.md new file mode 100644 index 0000000..1023d56 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/README.md @@ -0,0 +1,13 @@ +# problem +./rknn_yolov5_demo: error while loading shared libraries: libopencv_highgui.so.405: cannot open shared object file: No such file or directory +# solution +export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH +# ldconfig + +### +ln -s /usr/local/lib/libopencv_highgui.so /home/firefly/rknpu2/examples/rknn_yolov5_demo + +### run +~/rknpu2/examples/rknn_yolov5_demo$ bash bash ./build-linux_RK3588.sh +~/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux$ + ./rknn_yolov5_demo \ No newline at end of file diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/CMakeLists.txt b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/CMakeLists.txt new file mode 100644 index 0000000..fd8191d --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/CMakeLists.txt @@ -0,0 +1,79 @@ +cmake_minimum_required(VERSION 3.4.1) + +project(rknn_yolov5_demo) + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +# skip 3rd-party lib dependencies +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--allow-shlib-undefined") + +# install target and libraries +set(CMAKE_INSTALL_PREFIX ${CMAKE_SOURCE_DIR}/install/rknn_yolov5_demo_${CMAKE_SYSTEM_NAME}) + +set(CMAKE_SKIP_INSTALL_RPATH FALSE) +set(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE) +set(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/lib") + +if(CMAKE_C_COMPILER MATCHES "aarch64") + set(LIB_ARCH aarch64) +else() + set(LIB_ARCH armhf) +endif() + +include_directories(${CMAKE_SOURCE_DIR}) + +# rknn api +set(RKNN_API_PATH ${CMAKE_SOURCE_DIR}/../../runtime/RK3588/${CMAKE_SYSTEM_NAME}/librknn_api) +set(RKNN_RT_LIB ${RKNN_API_PATH}/${LIB_ARCH}/librknnrt.so) + +include_directories(${RKNN_API_PATH}/include) +include_directories(${CMAKE_SOURCE_DIR}/../3rdparty) + +# opencv +# set(OpenCV_DIR ${CMAKE_SOURCE_DIR}/../3rdparty/opencv/opencv-linux-aarch64/share/OpenCV) +find_package(OpenCV REQUIRED) + +#Threads +find_package(Threads REQUIRED) + +# rga +set(RGA_PATH ${CMAKE_SOURCE_DIR}/../3rdparty/rga/RK3588) +set(RGA_LIB ${RGA_PATH}/lib/Linux//${LIB_ARCH}/librga.so) + +include_directories(${RGA_PATH}/include) + +# mpp +set(MPP_PATH ${CMAKE_CURRENT_SOURCE_DIR}/../3rdparty/mpp) + +include_directories(${MPP_PATH}/include) + +set(CMAKE_INSTALL_RPATH "lib") + +# rknn_yolov5_demo +include_directories(${CMAKE_SOURCE_DIR}/include) + +add_executable(rknn_yolov5_demo + src/main.cpp + src/preprocess.cc + src/postprocess.cc + src/detection.cc + src/ranging.cpp + # src/video.cpp +) + +target_link_libraries(rknn_yolov5_demo + ${RKNN_RT_LIB} + ${RGA_LIB} + ${OpenCV_LIBS} + Threads::Threads +) + +# install target and libraries +set(CMAKE_INSTALL_PREFIX ${CMAKE_SOURCE_DIR}/install/rknn_yolov5_demo_${CMAKE_SYSTEM_NAME}) +install(TARGETS rknn_yolov5_demo DESTINATION ./) + +install(PROGRAMS ${RKNN_RT_LIB} DESTINATION lib) +install(PROGRAMS ${RGA_LIB} DESTINATION lib) +install(DIRECTORY model DESTINATION ./) + diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/build-linux_RK3588.sh b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/build-linux_RK3588.sh new file mode 100644 index 0000000..e110463 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/build-linux_RK3588.sh @@ -0,0 +1,24 @@ +set -e + +TARGET_SOC="rk3588" +GCC_COMPILER=aarch64-linux-gnu + +export LD_LIBRARY_PATH=${TOOL_CHAIN}/lib64:$LD_LIBRARY_PATH +export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH +export CC=${GCC_COMPILER}-gcc +export CXX=${GCC_COMPILER}-g++ + +ROOT_PWD=$( cd "$( dirname $0 )" && cd -P "$( dirname "$SOURCE" )" && pwd ) + +# build +BUILD_DIR=${ROOT_PWD}/build/build_linux_aarch64 + +if [[ ! -d "${BUILD_DIR}" ]]; then + mkdir -p ${BUILD_DIR} +fi + +cd ${BUILD_DIR} +cmake ../.. -DCMAKE_SYSTEM_NAME=Linux -DTARGET_SOC=${TARGET_SOC} +make -j4 +make install +cd - diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/Timer.h b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/Timer.h new file mode 100644 index 0000000..245f662 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/Timer.h @@ -0,0 +1,33 @@ +/** + * @file Timer.h + * @author hcy + * @brief 用于计时 + * @version 1 + * @date 2023-04-10 + * + */ + + +#include +#include + +class Timer +{ +public: + Timer() + { + start = std::chrono::high_resolution_clock::now(); + }; + ~Timer() + { + end = std::chrono::high_resolution_clock::now(); + duration = end - start; + double ms = duration.count() * 1000.f; + std::cout << "Timer took " << ms << "ms" << std::endl; + }; + +private: + std::chrono::time_point start; + std::chrono::time_point end; + std::chrono::duration duration; +}; \ No newline at end of file diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/detection.h b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/detection.h new file mode 100644 index 0000000..b5ebc57 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/detection.h @@ -0,0 +1,48 @@ +#include +#include +#include +#include + +#define _BASETSD_H + +#include "rknn_api.h" +#include "preprocess.h" +#include "postprocess.h" +#include "Timer.h" + +#define PERF_WITH_POST 1 + +class Detection +{ +private: + + int ret; + rknn_context ctx; + size_t actual_size = 0; + int img_width = 0; + int img_height = 0; + int img_channel = 0; + const float nms_threshold = NMS_THRESH; // 默认的NMS阈值 + const float box_conf_threshold = BOX_THRESH; // 默认的置信度阈值 + char* model_name = "/home/firefly/rknpu2/examples/rknn_yolov5_demo/model/RK3588/yolov5s-640-640.rknn"; + + cv::Mat orig_img; + rknn_input_output_num io_num; + + int channel = 3; + int width = 0; + int height = 0; + + rknn_input inputs[1]; + + std::vector out_scales; + std::vector out_zps; + +public: + Detection(); + static unsigned char *load_data(FILE *fp, size_t ofst, size_t sz); + static unsigned char *load_model(const char *filename, int *model_size); + detect_result_group_t outputParse(cv::Mat netInputImg); + + +}; \ No newline at end of file diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/postprocess.h b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/postprocess.h new file mode 100644 index 0000000..de3c288 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/postprocess.h @@ -0,0 +1,42 @@ +#ifndef _RKNN_YOLOV5_DEMO_POSTPROCESS_H_ +#define _RKNN_YOLOV5_DEMO_POSTPROCESS_H_ + +#include +#include + +#define OBJ_NAME_MAX_SIZE 16 +#define OBJ_NUMB_MAX_SIZE 64 +#define OBJ_CLASS_NUM 80 +#define NMS_THRESH 0.45 +#define BOX_THRESH 0.25 +#define PROP_BOX_SIZE (5 + OBJ_CLASS_NUM) + +typedef struct _BOX_RECT +{ + int left; + int right; + int top; + int bottom; +} BOX_RECT; + +typedef struct __detect_result_t +{ + char name[OBJ_NAME_MAX_SIZE]; + BOX_RECT box; + float prop; +} detect_result_t; + +typedef struct _detect_result_group_t +{ + int id; + int count; + detect_result_t results[OBJ_NUMB_MAX_SIZE]; +} detect_result_group_t; + +int post_process(int8_t *input0, int8_t *input1, int8_t *input2, int model_in_h, int model_in_w, + float conf_threshold, float nms_threshold, BOX_RECT pads, float scale_w, float scale_h, + std::vector &qnt_zps, std::vector &qnt_scales, + detect_result_group_t *group); + +void deinitPostProcess(); +#endif //_RKNN_YOLOV5_DEMO_POSTPROCESS_H_ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/preprocess.h b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/preprocess.h new file mode 100644 index 0000000..dc8319f --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/preprocess.h @@ -0,0 +1,16 @@ +#ifndef _RKNN_YOLOV5_DEMO_PREPROCESS_H_ +#define _RKNN_YOLOV5_DEMO_PREPROCESS_H_ + +#include +#include "im2d.h" +#include "rga.h" +#include "opencv2/core/core.hpp" +#include "opencv2/imgcodecs.hpp" +#include "opencv2/imgproc.hpp" +#include "postprocess.h" + +void letterbox(const cv::Mat &image, cv::Mat &padded_image, BOX_RECT &pads, const float scale, const cv::Size &target_size, const cv::Scalar &pad_color = cv::Scalar(128, 128, 128)); + +int resize_rga(rga_buffer_t &src, rga_buffer_t &dst, const cv::Mat &image, cv::Mat &resized_image, const cv::Size &target_size); + +#endif //_RKNN_YOLOV5_DEMO_PREPROCESS_H_ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/ranging.h b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/ranging.h new file mode 100644 index 0000000..d6f84fb --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/include/ranging.h @@ -0,0 +1,56 @@ +#pragma once + +#include +#include + +#include +#include +#include "detection.h" +#include + + +using namespace cv; + +class Ranging +{ +private: + // rknn_handle hdx; + cv::VideoCapture vcapture; + Detection yolov5s; + + //new + Mat cam_matrix_left = (Mat_(3, 3) << + 4.809895643547006e+02, 0, 0, + 0,4.807599168204821e+02, 0, + 3.362108165786334e+02, 2.298502481932070e+02, 1); + Mat cam_matrix_right = (Mat_(3, 3) << + 4.903260126250775e+02, 0, 0, + 0,4.900310486342847e+02, 0, + 3.230124997386542e+02, 2.346297967642670e+02, 1); + Mat distortion_l = (Mat_(1, 5) <<0.113688825569154,-0.106166584327678, 0, + 0, 0); + + Mat distortion_r = (Mat_(1, 5) <<0.121425307936153,-0.141892782717707, 0, + 0, 0); + Mat rotate = (Mat_(3, 3) << + 0.999996295879846, 8.723884080433472e-04, 0.002578209660240, + -8.682590894537506e-04,0.999998339366207, -0.001602308016931, + -0.002579603213718,0.001600063527818,0.999995392711370); + Mat trans = (Mat_(3, 1) << + -60.348359844102470,-0.030699794141365, 0.495248628081046); + + + cv::Mat mapX1, mapX2, mapY1, mapY2, q, Z; + + int imgw, imgh; + detect_result_group_t detect_result_group; + +public: + Ranging(int index, int imgw, int imgh); + void rectifyImage(cv::Mat &oriImgL, cv::Mat &oriImgR); + void getInfo(cv::Mat &imgl, cv::Mat &imgr, cv::Mat &detBoxes, cv::Mat &info); + std::vector pic2cam(int u, int v); + std::vector muban(cv::Mat &left_image, cv::Mat &right_image, const int *coordinates); + std::vector get_range(); + void horizon_estimate(cv::Mat& img, cv::Mat& bboxs,int k); +}; diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/libmk_api.so b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/libmk_api.so new file mode 100644 index 0000000..3ed2124 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/libmk_api.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/librga.so b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/librga.so new file mode 100644 index 0000000..9223831 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/librga.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/librknnrt.so b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/librknnrt.so new file mode 100644 index 0000000..1a9dc54 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/librknnrt.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/librockchip_mpp.so b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/librockchip_mpp.so new file mode 100644 index 0000000..9fe09e9 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/lib/librockchip_mpp.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/rknn_yolov5_demo b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/rknn_yolov5_demo new file mode 100644 index 0000000..ff58437 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/install/rknn_yolov5_demo_Linux/rknn_yolov5_demo differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/lib b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/lib new file mode 100644 index 0000000..7153018 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/lib differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/libopencv_highgui.so b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/libopencv_highgui.so new file mode 100644 index 0000000..0b833a5 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/libopencv_highgui.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/model/RK3588/yolov5s-640-640.rknn b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/model/RK3588/yolov5s-640-640.rknn new file mode 100644 index 0000000..87419fd Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/model/RK3588/yolov5s-640-640.rknn differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/model/coco_80_labels_list.txt b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/model/coco_80_labels_list.txt new file mode 100644 index 0000000..941cb4e --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/model/coco_80_labels_list.txt @@ -0,0 +1,80 @@ +person +bicycle +car +motorcycle +airplane +bus +train +truck +boat +traffic light +fire hydrant +stop sign +parking meter +bench +bird +cat +dog +horse +sheep +cow +elephant +bear +zebra +giraffe +backpack +umbrella +handbag +tie +suitcase +frisbee +skis +snowboard +sports ball +kite +baseball bat +baseball glove +skateboard +surfboard +tennis racket +bottle +wine glass +cup +fork +knife +spoon +bowl +banana +apple +sandwich +orange +broccoli +carrot +hot dog +pizza +donut +cake +chair +couch +potted plant +bed +dining table +toilet +tv +laptop +mouse +remote +keyboard +cell phone +microwave +oven +toaster +sink +refrigerator +book +clock +vase +scissors +teddy bear +hair drier +toothbrush diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/detection.cc b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/detection.cc new file mode 100644 index 0000000..3b6816e --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/detection.cc @@ -0,0 +1,201 @@ +#include "detection.h" +#include + + +unsigned char * Detection::load_data(FILE *fp, size_t ofst, size_t sz) +{ + unsigned char *data; + int ret; + + data = NULL; + + if (NULL == fp) + { + return NULL; + } + + ret = fseek(fp, ofst, SEEK_SET); + if (ret != 0) + { + printf("blob seek failure.\n"); + return NULL; + } + + data = (unsigned char *)malloc(sz); + if (data == NULL) + { + printf("buffer malloc failure.\n"); + return NULL; + } + ret = fread(data, 1, sz, fp); + return data; +} + +unsigned char * Detection::load_model(const char *filename, int *model_size) +{ + FILE *fp; + unsigned char *data; + + fp = fopen(filename, "rb"); + if (NULL == fp) + { + printf("Open file %s failed.\n", filename); + return NULL; + } + + fseek(fp, 0, SEEK_END); + int size = ftell(fp); + + data = load_data(fp, 0, size); + + fclose(fp); + + *model_size = size; + return data; +} + +Detection::Detection() +{ + + /* Create the neural network */ + printf("Loading mode...\n"); + int model_data_size = 0; + unsigned char *model_data = load_model(model_name, &model_data_size); + ret = rknn_init(&ctx, model_data, model_data_size, 0, NULL); + if (ret < 0) + { + printf("rknn_init error ret=%d\n", ret); + } + + rknn_sdk_version version; + ret = rknn_query(ctx, RKNN_QUERY_SDK_VERSION, &version, sizeof(rknn_sdk_version)); + if (ret < 0) + { + printf("rknn_init error ret=%d\n", ret); + } + printf("sdk version: %s driver version: %s\n", version.api_version, version.drv_version); + + ret = rknn_query(ctx, RKNN_QUERY_IN_OUT_NUM, &io_num, sizeof(io_num)); + if (ret < 0) + { + printf("rknn_init error ret=%d\n", ret); + } + printf("model input num: %d, output num: %d\n", io_num.n_input, io_num.n_output); + + rknn_tensor_attr input_attrs[io_num.n_input]; + memset(input_attrs, 0, sizeof(input_attrs)); + for (int i = 0; i < io_num.n_input; i++) + { + input_attrs[i].index = i; + ret = rknn_query(ctx, RKNN_QUERY_INPUT_ATTR, &(input_attrs[i]), sizeof(rknn_tensor_attr)); + if (ret < 0) + { + printf("rknn_init error ret=%d\n", ret); + } + // dump_tensor_attr(&(input_attrs[i])); + } + + rknn_tensor_attr output_attrs[io_num.n_output]; + memset(output_attrs, 0, sizeof(output_attrs)); + for (int i = 0; i < io_num.n_output; i++) + { + output_attrs[i].index = i; + ret = rknn_query(ctx, RKNN_QUERY_OUTPUT_ATTR, &(output_attrs[i]), sizeof(rknn_tensor_attr)); + // dump_tensor_attr(&(output_attrs[i])); + } + + for (int i = 0; i < io_num.n_output; ++i) + { + out_scales.push_back(output_attrs[i].scale); + out_zps.push_back(output_attrs[i].zp); + } + + if (input_attrs[0].fmt == RKNN_TENSOR_NCHW) + { + printf("model is NCHW input fmt\n"); + channel = input_attrs[0].dims[1]; + height = input_attrs[0].dims[2]; + width = input_attrs[0].dims[3]; + } + else + { + printf("model is NHWC input fmt\n"); + height = input_attrs[0].dims[1]; + width = input_attrs[0].dims[2]; + channel = input_attrs[0].dims[3]; + } + + printf("model input height=%d, width=%d, channel=%d\n", height, width, channel); + + + memset(inputs, 0, sizeof(inputs)); + inputs[0].index = 0; + inputs[0].type = RKNN_TENSOR_UINT8; + inputs[0].size = width * height * channel; + inputs[0].fmt = RKNN_TENSOR_NHWC; + inputs[0].pass_through = 0; + + } + +detect_result_group_t Detection::outputParse(cv::Mat netInputImg) +{ + + orig_img = netInputImg.clone(); + + if (!orig_img.data) + { + printf("no image\n"); + } + cv::Mat img; + cv::cvtColor(orig_img, img, cv::COLOR_BGR2RGB); + img_width = img.cols; + img_height = img.rows; + // printf("img width = %d, img height = %d\n", img_width, img_height); + + // 指定目标大小和预处理方式,默认使用LetterBox的预处理 + BOX_RECT pads; + memset(&pads, 0, sizeof(BOX_RECT)); + cv::Size target_size(width, height); + cv::Mat resized_img(target_size.height, target_size.width, CV_8UC3); + // 计算缩放比例 + float scale_w = (float)target_size.width / img.cols; + float scale_h = (float)target_size.height / img.rows; + + if (img_width != width || img_height != height) + { + // printf("resize image with letterbox\n"); + float min_scale = std::min(scale_w, scale_h); + scale_w = min_scale; + scale_h = min_scale; + letterbox(img, resized_img, pads, min_scale, target_size); + // 保存预处理图片 + // cv::imwrite("letterbox_input.jpg", resized_img); + inputs[0].buf = resized_img.data; + } + else + { + inputs[0].buf = img.data; + } + + rknn_inputs_set(ctx, io_num.n_input, inputs); + + rknn_output outputs[io_num.n_output]; + memset(outputs, 0, sizeof(outputs)); + for (int i = 0; i < io_num.n_output; i++) + { + outputs[i].want_float = 0; + } + + // 执行推理 + ret = rknn_run(ctx, NULL); + ret = rknn_outputs_get(ctx, io_num.n_output, outputs, NULL); + + // 后处理 + detect_result_group_t detect_result_group; + + post_process((int8_t *)outputs[0].buf, (int8_t *)outputs[1].buf, (int8_t *)outputs[2].buf, height, width, + box_conf_threshold, nms_threshold, pads, scale_w, scale_h, out_zps, out_scales, &detect_result_group); + + + return detect_result_group; +} \ No newline at end of file diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/main.cpp b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/main.cpp new file mode 100644 index 0000000..e9de129 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/main.cpp @@ -0,0 +1,51 @@ +#include +#include +// #include "lidar.h" +// #include +// #include +#include +#include "ranging.h" +// #include "fusion.h" +#include +#include +#include +#include +// #include "detection.h" +/*#include +#include */ +#include "opencv2/imgcodecs/imgcodecs.hpp" +#include +#include + +#define ANGLE_TO_RADIAN(angle) ((angle)*3141.59 / 180000) + +Ranging r(12, 640, 480); +std::queue> frameInfo; +std::mutex g_mutex; + +void *ranging(void *args) // ranging线程 +{ + while (true) + { + // std::cout<<" ************ enter ranging *********** "< result = r.get_range(); + g_mutex.lock(); + for (uchar i = 0; i < frameInfo.size(); i++) // 只保存当前最新的图片帧信息 + frameInfo.pop(); + frameInfo.push(result); + g_mutex.unlock(); + } +} + +int main(int argc, char **argv) +{ + + pthread_t tids[1]; // 执行ranging线程 + int ret = pthread_create(&tids[0], NULL, ranging, NULL); + + while(1){ + usleep(150000); + } + + return 0; +} diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/postprocess.cc b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/postprocess.cc new file mode 100644 index 0000000..34953f4 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/postprocess.cc @@ -0,0 +1,374 @@ +// Copyright (c) 2021 by Rockchip Electronics Co., Ltd. All Rights Reserved. +// +// 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 "postprocess.h" + +#include +#include +#include +#include +#include +#include + +#include +#include +#define LABEL_NALE_TXT_PATH "./model/coco_80_labels_list.txt" + +static char *labels[OBJ_CLASS_NUM]; + +const int anchor0[6] = {10, 13, 16, 30, 33, 23}; +const int anchor1[6] = {30, 61, 62, 45, 59, 119}; +const int anchor2[6] = {116, 90, 156, 198, 373, 326}; + +inline static int clamp(float val, int min, int max) { return val > min ? (val < max ? val : max) : min; } + +char *readLine(FILE *fp, char *buffer, int *len) +{ + int ch; + int i = 0; + size_t buff_len = 0; + + buffer = (char *)malloc(buff_len + 1); + if (!buffer) + return NULL; // Out of memory + + while ((ch = fgetc(fp)) != '\n' && ch != EOF) + { + buff_len++; + void *tmp = realloc(buffer, buff_len + 1); + if (tmp == NULL) + { + free(buffer); + return NULL; // Out of memory + } + buffer = (char *)tmp; + + buffer[i] = (char)ch; + i++; + } + buffer[i] = '\0'; + + *len = buff_len; + + // Detect end + if (ch == EOF && (i == 0 || ferror(fp))) + { + free(buffer); + return NULL; + } + return buffer; +} + +int readLines(const char *fileName, char *lines[], int max_line) +{ + FILE *file = fopen(fileName, "r"); + char *s; + int i = 0; + int n = 0; + + if (file == NULL) + { + printf("Open %s fail!\n", fileName); + return -1; + } + + while ((s = readLine(file, s, &n)) != NULL) + { + lines[i++] = s; + if (i >= max_line) + break; + } + fclose(file); + return i; +} + +int loadLabelName(const char *locationFilename, char *label[]) +{ + printf("loadLabelName %s\n", locationFilename); + readLines(locationFilename, label, OBJ_CLASS_NUM); + return 0; +} + +static float CalculateOverlap(float xmin0, float ymin0, float xmax0, float ymax0, float xmin1, float ymin1, float xmax1, + float ymax1) +{ + float w = fmax(0.f, fmin(xmax0, xmax1) - fmax(xmin0, xmin1) + 1.0); + float h = fmax(0.f, fmin(ymax0, ymax1) - fmax(ymin0, ymin1) + 1.0); + float i = w * h; + float u = (xmax0 - xmin0 + 1.0) * (ymax0 - ymin0 + 1.0) + (xmax1 - xmin1 + 1.0) * (ymax1 - ymin1 + 1.0) - i; + return u <= 0.f ? 0.f : (i / u); +} + +static int nms(int validCount, std::vector &outputLocations, std::vector classIds, std::vector &order, + int filterId, float threshold) +{ + for (int i = 0; i < validCount; ++i) + { + if (order[i] == -1 || classIds[i] != filterId) + { + continue; + } + int n = order[i]; + for (int j = i + 1; j < validCount; ++j) + { + int m = order[j]; + if (m == -1 || classIds[i] != filterId) + { + continue; + } + float xmin0 = outputLocations[n * 4 + 0]; + float ymin0 = outputLocations[n * 4 + 1]; + float xmax0 = outputLocations[n * 4 + 0] + outputLocations[n * 4 + 2]; + float ymax0 = outputLocations[n * 4 + 1] + outputLocations[n * 4 + 3]; + + float xmin1 = outputLocations[m * 4 + 0]; + float ymin1 = outputLocations[m * 4 + 1]; + float xmax1 = outputLocations[m * 4 + 0] + outputLocations[m * 4 + 2]; + float ymax1 = outputLocations[m * 4 + 1] + outputLocations[m * 4 + 3]; + + float iou = CalculateOverlap(xmin0, ymin0, xmax0, ymax0, xmin1, ymin1, xmax1, ymax1); + + if (iou > threshold) + { + order[j] = -1; + } + } + } + return 0; +} + +static int quick_sort_indice_inverse(std::vector &input, int left, int right, std::vector &indices) +{ + float key; + int key_index; + int low = left; + int high = right; + if (left < right) + { + key_index = indices[left]; + key = input[left]; + while (low < high) + { + while (low < high && input[high] <= key) + { + high--; + } + input[low] = input[high]; + indices[low] = indices[high]; + while (low < high && input[low] >= key) + { + low++; + } + input[high] = input[low]; + indices[high] = indices[low]; + } + input[low] = key; + indices[low] = key_index; + quick_sort_indice_inverse(input, left, low - 1, indices); + quick_sort_indice_inverse(input, low + 1, right, indices); + } + return low; +} + +static float sigmoid(float x) { return 1.0 / (1.0 + expf(-x)); } + +static float unsigmoid(float y) { return -1.0 * logf((1.0 / y) - 1.0); } + +inline static int32_t __clip(float val, float min, float max) +{ + float f = val <= min ? min : (val >= max ? max : val); + return f; +} + +static int8_t qnt_f32_to_affine(float f32, int32_t zp, float scale) +{ + float dst_val = (f32 / scale) + zp; + int8_t res = (int8_t)__clip(dst_val, -128, 127); + return res; +} + +static float deqnt_affine_to_f32(int8_t qnt, int32_t zp, float scale) { return ((float)qnt - (float)zp) * scale; } + +static int process(int8_t *input, int *anchor, int grid_h, int grid_w, int height, int width, int stride, + std::vector &boxes, std::vector &objProbs, std::vector &classId, float threshold, + int32_t zp, float scale) +{ + int validCount = 0; + int grid_len = grid_h * grid_w; + int8_t thres_i8 = qnt_f32_to_affine(threshold, zp, scale); + for (int a = 0; a < 3; a++) + { + for (int i = 0; i < grid_h; i++) + { + for (int j = 0; j < grid_w; j++) + { + int8_t box_confidence = input[(PROP_BOX_SIZE * a + 4) * grid_len + i * grid_w + j]; + if (box_confidence >= thres_i8) + { + int offset = (PROP_BOX_SIZE * a) * grid_len + i * grid_w + j; + int8_t *in_ptr = input + offset; + float box_x = (deqnt_affine_to_f32(*in_ptr, zp, scale)) * 2.0 - 0.5; + float box_y = (deqnt_affine_to_f32(in_ptr[grid_len], zp, scale)) * 2.0 - 0.5; + float box_w = (deqnt_affine_to_f32(in_ptr[2 * grid_len], zp, scale)) * 2.0; + float box_h = (deqnt_affine_to_f32(in_ptr[3 * grid_len], zp, scale)) * 2.0; + box_x = (box_x + j) * (float)stride; + box_y = (box_y + i) * (float)stride; + box_w = box_w * box_w * (float)anchor[a * 2]; + box_h = box_h * box_h * (float)anchor[a * 2 + 1]; + box_x -= (box_w / 2.0); + box_y -= (box_h / 2.0); + + int8_t maxClassProbs = in_ptr[5 * grid_len]; + int maxClassId = 0; + for (int k = 1; k < OBJ_CLASS_NUM; ++k) + { + int8_t prob = in_ptr[(5 + k) * grid_len]; + if (prob > maxClassProbs) + { + maxClassId = k; + maxClassProbs = prob; + } + } + if (maxClassProbs > thres_i8) + { + objProbs.push_back((deqnt_affine_to_f32(maxClassProbs, zp, scale)) * (deqnt_affine_to_f32(box_confidence, zp, scale))); + classId.push_back(maxClassId); + validCount++; + boxes.push_back(box_x); + boxes.push_back(box_y); + boxes.push_back(box_w); + boxes.push_back(box_h); + } + } + } + } + } + return validCount; +} + +int post_process(int8_t *input0, int8_t *input1, int8_t *input2, int model_in_h, int model_in_w, float conf_threshold, + float nms_threshold, BOX_RECT pads, float scale_w, float scale_h, std::vector &qnt_zps, + std::vector &qnt_scales, detect_result_group_t *group) +{ + static int init = -1; + if (init == -1) + { + int ret = 0; + ret = loadLabelName(LABEL_NALE_TXT_PATH, labels); + if (ret < 0) + { + return -1; + } + + init = 0; + } + memset(group, 0, sizeof(detect_result_group_t)); + + std::vector filterBoxes; + std::vector objProbs; + std::vector classId; + + // stride 8 + int stride0 = 8; + int grid_h0 = model_in_h / stride0; + int grid_w0 = model_in_w / stride0; + int validCount0 = 0; + validCount0 = process(input0, (int *)anchor0, grid_h0, grid_w0, model_in_h, model_in_w, stride0, filterBoxes, objProbs, + classId, conf_threshold, qnt_zps[0], qnt_scales[0]); + + // stride 16 + int stride1 = 16; + int grid_h1 = model_in_h / stride1; + int grid_w1 = model_in_w / stride1; + int validCount1 = 0; + validCount1 = process(input1, (int *)anchor1, grid_h1, grid_w1, model_in_h, model_in_w, stride1, filterBoxes, objProbs, + classId, conf_threshold, qnt_zps[1], qnt_scales[1]); + + // stride 32 + int stride2 = 32; + int grid_h2 = model_in_h / stride2; + int grid_w2 = model_in_w / stride2; + int validCount2 = 0; + validCount2 = process(input2, (int *)anchor2, grid_h2, grid_w2, model_in_h, model_in_w, stride2, filterBoxes, objProbs, + classId, conf_threshold, qnt_zps[2], qnt_scales[2]); + + int validCount = validCount0 + validCount1 + validCount2; + // no object detect + if (validCount <= 0) + { + return 0; + } + + std::vector indexArray; + for (int i = 0; i < validCount; ++i) + { + indexArray.push_back(i); + } + + quick_sort_indice_inverse(objProbs, 0, validCount - 1, indexArray); + + std::set class_set(std::begin(classId), std::end(classId)); + + for (auto c : class_set) + { + nms(validCount, filterBoxes, classId, indexArray, c, nms_threshold); + } + + int last_count = 0; + group->count = 0; + /* box valid detect target */ + for (int i = 0; i < validCount; ++i) + { + if (indexArray[i] == -1 || last_count >= OBJ_NUMB_MAX_SIZE) + { + continue; + } + int n = indexArray[i]; + + float x1 = filterBoxes[n * 4 + 0] - pads.left; + float y1 = filterBoxes[n * 4 + 1] - pads.top; + float x2 = x1 + filterBoxes[n * 4 + 2]; + float y2 = y1 + filterBoxes[n * 4 + 3]; + int id = classId[n]; + float obj_conf = objProbs[i]; + + group->results[last_count].box.left = (int)(clamp(x1, 0, model_in_w) / scale_w); + group->results[last_count].box.top = (int)(clamp(y1, 0, model_in_h) / scale_h); + group->results[last_count].box.right = (int)(clamp(x2, 0, model_in_w) / scale_w); + group->results[last_count].box.bottom = (int)(clamp(y2, 0, model_in_h) / scale_h); + group->results[last_count].prop = obj_conf; + char *label = labels[id]; + strncpy(group->results[last_count].name, label, OBJ_NAME_MAX_SIZE); + + // printf("result %2d: (%4d, %4d, %4d, %4d), %s\n", i, group->results[last_count].box.left, + // group->results[last_count].box.top, + // group->results[last_count].box.right, group->results[last_count].box.bottom, label); + last_count++; + } + group->count = last_count; + + return 0; +} + +void deinitPostProcess() +{ + for (int i = 0; i < OBJ_CLASS_NUM; i++) + { + if (labels[i] != nullptr) + { + free(labels[i]); + labels[i] = nullptr; + } + } +} diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/preprocess.cc b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/preprocess.cc new file mode 100644 index 0000000..4fc1d7b --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/preprocess.cc @@ -0,0 +1,61 @@ +// Copyright (c) 2023 by Rockchip Electronics Co., Ltd. All Rights Reserved. +// +// 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 "preprocess.h" + +void letterbox(const cv::Mat &image, cv::Mat &padded_image, BOX_RECT &pads, const float scale, const cv::Size &target_size, const cv::Scalar &pad_color) +{ + // 调整图像大小 + cv::Mat resized_image; + cv::resize(image, resized_image, cv::Size(), scale, scale); + + // 计算填充大小 + int pad_width = target_size.width - resized_image.cols; + int pad_height = target_size.height - resized_image.rows; + + pads.left = pad_width / 2; + pads.right = pad_width - pads.left; + pads.top = pad_height / 2; + pads.bottom = pad_height - pads.top; + + // 在图像周围添加填充 + cv::copyMakeBorder(resized_image, padded_image, pads.top, pads.bottom, pads.left, pads.right, cv::BORDER_CONSTANT, pad_color); +} + +int resize_rga(rga_buffer_t &src, rga_buffer_t &dst, const cv::Mat &image, cv::Mat &resized_image, const cv::Size &target_size) +{ + im_rect src_rect; + im_rect dst_rect; + memset(&src_rect, 0, sizeof(src_rect)); + memset(&dst_rect, 0, sizeof(dst_rect)); + size_t img_width = image.cols; + size_t img_height = image.rows; + if (image.type() != CV_8UC3) + { + printf("source image type is %d!\n", image.type()); + return -1; + } + size_t target_width = target_size.width; + size_t target_height = target_size.height; + src = wrapbuffer_virtualaddr((void *)image.data, img_width, img_height, RK_FORMAT_RGB_888); + dst = wrapbuffer_virtualaddr((void *)resized_image.data, target_width, target_height, RK_FORMAT_RGB_888); + int ret = imcheck(src, dst, src_rect, dst_rect); + if (IM_STATUS_NOERROR != ret) + { + fprintf(stderr, "rga check error! %s", imStrError((IM_STATUS)ret)); + return -1; + } + IM_STATUS STATUS = imresize(src, dst); + return 0; +} diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/ranging.cpp b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/ranging.cpp new file mode 100644 index 0000000..0cc10e9 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/ranging.cpp @@ -0,0 +1,380 @@ +#include +#include +#include +#include +#include "ranging.h" +#include +#include + +#include +#include +#include +#include "opencv2/core.hpp" +#include "opencv2/imgcodecs.hpp" +#include "opencv2/imgproc.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include +// #include + + +using namespace cv; +void Ranging::rectifyImage(Mat &oriImgL, Mat &oriImgR) //重映射函数 +{ + remap(oriImgL, oriImgL, mapX1, mapX2, cv::INTER_LINEAR); + remap(oriImgR, oriImgR, mapY1, mapY2, cv::INTER_LINEAR); +} + +std::vector Ranging::pic2cam(int u, int v) //像素坐标转相机坐标 +{ + //(u,v)->(x,y)"(loc[0],loc[1])" + std::vector loc; + loc.push_back((u - cam_matrix_right.at(0, 2)) * q.at(2, 3) / cam_matrix_right.at(0, 0)); + loc.push_back((v - cam_matrix_right.at(1, 2)) * q.at(2, 3) / cam_matrix_right.at(1, 1)); + return loc; +} + +std::vector Ranging::muban(Mat &left_image, Mat &right_image, const int *coordinates) //模板匹配 +{ + int x1 = coordinates[0], y1 = coordinates[1], x2 = coordinates[2], y2 = coordinates[3]; + Mat tpl = right_image.rowRange(max(y1 - 2, 0), min(y2 + 2, 479)).colRange(x1, x2); //获取目标框 + Mat target = left_image.rowRange(max(y1 - 20, 0), min(y2 + 20, 479)).colRange(0, 639); //待匹配图像，极线约束，只需要同水平区域 + int th = tpl.rows, tw = tpl.cols; + Mat result; + + matchTemplate(target, tpl, result, TM_CCOEFF_NORMED); //匹配方法：归一化相关系数即零均值归一化互相关 + double minVal, maxVal; + Point minLoc, maxLoc; + minMaxLoc(result, &minVal, &maxVal, &minLoc, &maxLoc); //得到匹配点坐标 + Point tl = maxLoc, br; + + br.x = min(maxLoc.x + tw, 639); //转为像素坐标系 + br.y = min(maxLoc.y + th, 479); //转为像素坐标系 + ////展示匹配结果 + // br.x = min(maxLoc.x + tw, 319); + // br.y = min(maxLoc.y + th, 239); + //rectangle(target, tl, br, (0, 255, 0), 3); + //imshow("match-", target); + //waitKey(2); + + std::vector maxloc; + maxloc.push_back(maxLoc.x); + maxloc.push_back(maxLoc.y); + return maxloc; +} + +void Ranging::horizon_estimate(Mat& img, Mat& bboxs,int k) +{ + //保证摄像头与地面平行 + int x1 = bboxs.at(k, 0); + int x2 = bboxs.at(k, 2); + int y1 = bboxs.at(k, 1); + int y2 = bboxs.at(k, 3); + float Conf = bboxs.at(k, 4); + int cls = bboxs.at(k, 5); + float Y_B, Y_H; + cv::Mat edge, grayImage; + std::vector idx; + cv::Mat tpl = img.rowRange(y1, min(y2+5,479)).colRange(x1, x2); // 取感兴趣范围 + //Mat target = left_image.rowRange(max(y1 - 20, 0), min(y2 + 20, 479)).colRange(0, 639); + cv::Mat Z = Mat::zeros(2, tpl.cols, CV_32FC1); + cvtColor(tpl, grayImage, COLOR_BGR2GRAY); + GaussianBlur(grayImage,grayImage,Size(5,5),0); + Canny(grayImage, edge, 120, 180, 3); //提取边缘，获取与地面接触点 + //cv::imshow("1",edge); + //cv::waitKey(1); + float cluster[650]; + for (int i = 0;i<650;i++) + { + cluster[i] = 0; + } + int y_b, y_h; + int j = 0; + for (int i = 0; i < x2-x1; i++) + { + //Mat temp = edge.rowRange(max(y1, 0), min(y2 + 4, 479)).colRange(x1, x2); + Mat temp = edge.col(i); //取第i列 + // std::cout << "temp: " < point_b = pic2cam(x1 + i, 240); //转为相机坐标系 + std::vector point_H = pic2cam(320, 240); + float alfa = atan((point_b[0] - point_H[0]) / q.at(2, 3)); + if (idx.size() < 1) + { + Z.at(0, i) = 0; + Z.at(1, i) = alfa; + continue; + } + int y_b = idx[idx.size() - 1].y + y1; // + y_b = int(y_b + y_b*0.03); + int y_h = 240; + point_b = pic2cam(x1 + i, y_b); //转为相机坐标系 + point_H = pic2cam(320, y_h); + Y_B = point_b[1]; + Y_H = point_H[1]; + + float H_c = 60; //摄像头离地高度，单位mm + float theta = 0; //摄像头与地面夹角，弧度 + float d = (1/cos(theta)* cos(theta)) * q.at(2, 3) * H_c / (Y_B - Y_H)- H_c*tan(theta); + alfa = atan((point_b[0] - point_H[0]) / q.at(2, 3)); + //cout << "d: " << d << endl; + if (d > 700) + {d = 0;} + Z.at(0, i) = d/cos(alfa); + Z.at(1, i) = alfa; + } + + this->Z = Z.clone(); +} + +void Ranging::getInfo(Mat &imgL, Mat &imgR, Mat &detBoxes, Mat &info) +{ + Mat imgGrayL, imgGrayR; + cvtColor(imgL, imgGrayL, COLOR_BGR2GRAY); + cvtColor(imgR, imgGrayR, COLOR_BGR2GRAY); + Mat imgR_weight = imgR.clone(); + Mat infoRow; + for (uchar i = 0; i < detBoxes.rows; i++) + { + int x1 = detBoxes.at(i, 0); + int y1 = detBoxes.at(i, 1); + int x2 = detBoxes.at(i, 2); + int y2 = detBoxes.at(i, 3); + + float Conf = detBoxes.at(i, 4); + int cls = detBoxes.at(i, 5); + + if (x1 > 600 || x2 < 50 || y1 < 5 || y2 > 475 || x1 < 2 || x2 > 590 || abs(x2 - x1) > 550) //当目标框偏左、偏右或者过大，略去该物体 + { + continue; + } + + rectangle(imgR, Point(int(x1), int(y1)), + Point(int(x2), int(y2)), Scalar(0, 0, 255)); //绘制目标框 + + int coordinates[4] = {x1, y1, x2, y2}; + std::vector disp_pixel = muban(imgGrayL, imgGrayR, coordinates); //模板匹配 + float disp_pixel_x = disp_pixel[0] - x1; //ˮ计算水平视差 + float disp_pixel_y = disp_pixel[1] - y1; // + disp_pixel_x = (int)(disp_pixel_x + disp_pixel_x * 0.12); //0.12为模板匹配产生的误差，为经验值，通过拟合得到 + + //Mat disp_matrix = Mat(1, 1, CV_32F, Scalar(disp_pixel_x)), disp_pixel_xyz; + Mat disp_matrix = Mat(imgGrayL.rows, imgGrayL.cols, CV_32F, Scalar(disp_pixel_x)); //定义视差矩阵，所有值均为水平视差，方便转换为三维坐标，并具有水平距离信息 + Mat threed_pixel_xyz, threedImage; + reprojectImageTo3D(disp_matrix, threedImage, q, false); //2d->3d + threed_pixel_xyz = threedImage.mul(threedImage); //每一像素点求平方， + std::vector channels; + split(threed_pixel_xyz.clone(), channels); + threed_pixel_xyz = channels[0] + channels[1] + channels[2]; //计算欧式距离 + threed_pixel_xyz.forEach([](float &value, const int *position) { value = sqrt(value); }); // 获得距离d + + int mid_pixel = int((x1 + x2) / 2); + std::vector mid = pic2cam(imgGrayR.cols / 2, imgGrayR.rows); //计算角度，从像素坐标转为相机坐标 + std::vector loc_tar = pic2cam(mid_pixel, imgGrayR.rows); + float alfa = atan((loc_tar[0] - mid[0]) / q.at(2, 3)); + + + if (disp_pixel_x > 240) // 距离太近，视差过大 + { + char cm[15]; + //sprintf(cm, "cannot match !"); + sprintf(cm, "%d , %.2f", cls,Conf); + putText(imgR, cm, Point((x1), (y1)), FONT_HERSHEY_PLAIN, 2.2, Scalar(0, 0, 255), 2); + infoRow = (Mat_(1, 4) << -1, -1, -1, -1); + infoRow.copyTo(info.row(i)); + continue; + } + else + { + float median = threed_pixel_xyz.at((int)(y1 + y2) / 2, (int)(x1 + x2) / 2); + + std::vector ltPoint = pic2cam(x1, y1); + std::vector rbPoint = pic2cam(x2, y2); + float xx1 = ltPoint[0], yy1 = ltPoint[1], xx2 = rbPoint[0], yy2 = rbPoint[1]; //计算宽高 + float f = q.at(2, 3); + float f1 = sqrt(xx1 * xx1 + yy1 * yy1 + f * f); //推导得出 + //float w1 = median * sqrt((xx1 - xx2) * (xx1 - xx2) / 4) / f1; + float h1 = median * sqrt((yy1 - yy2) * (yy1 - yy2) / 4) / f1; + float f2 = sqrt(xx2 * xx2 + yy2 * yy2 + f * f); + //float w2 = median * sqrt((xx2 - xx1) * (xx2 - xx1) / 4) / f2; + float h2 = median * sqrt((yy2 - yy1) * (yy2 - yy1) / 4) / f2; + float w1 = sqrt(pow((threedImage.at(y2, x1)[0] - threedImage.at(y2, x2)[0]), 2) + + pow((threedImage.at(y2, x1)[1] - threedImage.at(y2, x2)[1]), 2) + + pow((threedImage.at(y2, x1)[2] - threedImage.at(y2, x2)[2]), 2)); + + w1 = w1 / 10; + h1 = (h1 + h2) / 10; + median /= 10; + if (median > 120) //过远测距误差较大 + { + //char tf[9]; + //sprintf(tf, "Too far!"); + char cm[15]; + //sprintf(cm, "cannot match !"); + sprintf(cm, "%d , %.2f", cls,Conf); + putText(imgR, cm, Point((x1), (y1)), FONT_HERSHEY_PLAIN, 2.2, Scalar(0, 0, 255), 2); + infoRow = (Mat_(1, 4) << -1, -1, -1, -1); + infoRow.copyTo(info.row(i)); + continue; + } + // ��ͼ���ϻ�����Ϣ + // char dc[50], wh[50]; + // std::string cname = className[cls + 1]; + // sprintf(dc, "dis:%.2fcm %d", median, cls); + // sprintf(wh, "W: %.2fcm H: %.2fcm alfa: %2f", w1, h1, alfa); + // putText(imgR, dc, Point(x1, y2), FONT_HERSHEY_PLAIN, 1.5, Scalar(0, 0, 255), 2); + // putText(imgR, wh, Point(x1, y1), FONT_HERSHEY_PLAIN, 1.5, Scalar(0, 0, 255), 1.5); + + + //返回数据 + infoRow = (Mat_(1, 4) << median, w1, h1, alfa); + infoRow.copyTo(info.row(i)); + }; + } + // cv::imshow("kk",imgR); + // cv::waitKey(1); + +} + +Ranging::Ranging(int index, int imgw, int imgh) : //初始化 + mapX1(imgh, imgw, CV_64F), //初始化矩阵 ，用于计算无畸变和修正转换映射。 + mapX2(imgh, imgw, CV_64F), + mapY1(imgh, imgw, CV_64F), + mapY2(imgh, imgw, CV_64F), + q(4, 4, CV_64F), + imgw(imgw), + imgh(imgh) +{ + // Z = Mat::zeros(2, 1, CV_32FC1); + vcapture = cv::VideoCapture(index); + //vcapture.set(CAP_PROP_FOURCC, CAP_OPENCV_MJPEG); + vcapture.set(cv::CAP_PROP_FPS, 30); + vcapture.set(cv::CAP_PROP_FRAME_WIDTH, imgw * 2); + vcapture.set(cv::CAP_PROP_FRAME_HEIGHT, imgh); + vcapture.set(cv::CAP_PROP_BUFFERSIZE, 1); + + + auto imgSize = Size(imgw, imgh); + Mat r1(3, 3, CV_64F), r2(3, 3, CV_64F), p1(3, 4, CV_64F), p2(3, 4, CV_64F); + + stereoRectify(cam_matrix_left.t(), distortion_l, cam_matrix_right.t(), distortion_r, + imgSize, rotate.t(), trans, r1, r2, p1, p2, q);//立体校正 + + initUndistortRectifyMap(cam_matrix_left.t(), distortion_l, r1, p1, imgSize, CV_32F, mapX1, mapX2);//计算无畸变和修正转换映射 + initUndistortRectifyMap(cam_matrix_right.t(), distortion_r, r2, p2, imgSize, CV_32F, mapY1, mapY2);//计算无畸变和修正转换映射 + + // RKNN_Create(&hdx, modelPath); // 初始化检测模型 + std::cout<< " ******************* CAMERA initialization ********************" << std::endl; + +} + + + + +std::vector Ranging::get_range() +{ + + double rang_old, rang_now; + // rang_old = ros::Time::now().toSec(); //测试运行时间 + Mat frame, lframe, rframe; + // vcapture.read(frame); //获取视频帧 + vcapture >> frame; + + // cv::imshow("frame",frame); + + if (!frame.empty()) + { + int64 t = getTickCount(); + Mat lframe(frame.colRange(0, imgw).clone()); //拷贝左图 + Mat rframe(frame.colRange(imgw, imgw * 2).clone()); //拷贝右图 + + rectifyImage(lframe, rframe); // + + cv::Mat Rframe = rframe.clone(); + + detect_result_group = yolov5s.outputParse(Rframe); + + if (detect_result_group.count<=0) + { + std::cout<<"detect nothing"<name, det_result->prop * 100); + // printf("%s @ (%d %d %d %d) %f\n", det_result->name, det_result->box.left, det_result->box.top, + // det_result->box.right, det_result->box.bottom, det_result->prop); + + int xmin = det_result->box.left; + int ymin = det_result->box.top; + int xmax = det_result->box.right; + int ymax = det_result->box.bottom; + + rectangle(Rframe, cv::Point(xmin, ymin), cv::Point(xmax, ymax), cv::Scalar(256, 0, 0, 256), 3); + putText(Rframe, text, cv::Point(xmin, ymin + 12), cv::FONT_HERSHEY_SIMPLEX, 0.4, cv::Scalar(255, 255, 255)); + + // (x,y) (x,y) conf + detBoxes.at(i, 0) = xmin; + detBoxes.at(i, 1) = ymin; + detBoxes.at(i, 2) = xmax; + detBoxes.at(i, 3) = ymax; + detBoxes.at(i, 4) = det_result->prop; + // 实验测试，过滤过大的误检框 + // float ratio = (xmax - xmin) * (ymax - ymin) / 308480.; + // if (ratio > 0.7) + // { + // detBoxes.at(i, 5) = -1; + // continue; + // } + } + + Mat info(detect_result_group.count, 4, CV_32F); // 存储测距信息，存储格式：距离d，宽w，高h，角度α + if (detect_result_group.count) + { + getInfo(lframe, rframe, detBoxes, info); + + //show stereo distance + //zai zhe li kai ke neng cheng xu hui beng le + + // for(int i=0; i(i, 0); + // float w1 = info.at(i, 1); + // float h1 = info.at(i, 2); + // float alfa = info.at(i, 3); + + // int x1 = det_result->box.left; + // int y1 = det_result->box.top; + // int x2 = det_result->box.right; + // int y2 = det_result->box.bottom; + // char dc[50], wh[50]; + // sprintf(dc, "dis:%.2fcm ", median); + // sprintf(wh, "W: %.2fcm H: %.2fcm ", w1, h1); + // putText(Rframe, dc, Point(x1, y2), FONT_HERSHEY_PLAIN, 1.5, Scalar(0, 0, 255), 2); + // putText(Rframe, wh, Point(x1, y1), FONT_HERSHEY_PLAIN, 1.5, Scalar(0, 0, 255), 1.5); + // } + } + + t = getTickCount() - t; + char fps[50]; + sprintf(fps, "fps: %d", int(1 / (t / getTickFrequency()))); + putText(Rframe, fps, Point(20, 20), FONT_HERSHEY_PLAIN, 1, Scalar(0, 0, 255), 1.5); + + cv::imshow("k",Rframe); + cv::waitKey(1); + return std::vector{rframe, detBoxes, info}; + } + return std::vector{rframe}; +} diff --git a/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/video_test.cpp b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/video_test.cpp new file mode 100644 index 0000000..62e5b9f --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/examples/rknn_yolov5_demo/src/video_test.cpp @@ -0,0 +1,23 @@ +#include +#include +#include +#include +#include +int main(){ + cv::namedWindow("Camera", cv::WINDOW_AUTOSIZE); // set windows auto + cv::VideoCapture capture(11); // default 0 is the first of camera in computer + cv::Mat bgr_frame; + capture.set(cv::CAP_PROP_FPS, 30); + capture.set(cv::CAP_PROP_FRAME_WIDTH, 2560); + capture.set(cv::CAP_PROP_FRAME_HEIGHT, 720); + while (true){ + capture >> bgr_frame; // >> is a overload opeator, in C++ Grammar + if(bgr_frame.empty()) + break; + cv::imshow("Camera", bgr_frame); + char c = cv::waitKey(1); + if( c== 27 ) + break; + } + capture.release(); +} \ No newline at end of file diff --git a/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/aarch64/librknn_api.so b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/aarch64/librknn_api.so new file mode 100644 index 0000000..1f8feeb Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/aarch64/librknn_api.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/aarch64/librknnrt.so b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/aarch64/librknnrt.so new file mode 100644 index 0000000..1a9dc54 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/aarch64/librknnrt.so differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/include/rknn_api.h b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/include/rknn_api.h new file mode 100644 index 0000000..1ff6a93 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/include/rknn_api.h @@ -0,0 +1,720 @@ +/**************************************************************************** +* +* Copyright (c) 2017 - 2022 by Rockchip Corp. All rights reserved. +* +* The material in this file is confidential and contains trade secrets +* of Rockchip Corporation. This is proprietary information owned by +* Rockchip Corporation. No part of this work may be disclosed, +* reproduced, copied, transmitted, or used in any way for any purpose, +* without the express written permission of Rockchip Corporation. +* +*****************************************************************************/ + + +#ifndef _RKNN_API_H +#define _RKNN_API_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* + Definition of extended flag for rknn_init. +*/ +/* set high priority context. */ +#define RKNN_FLAG_PRIOR_HIGH 0x00000000 + +/* set medium priority context */ +#define RKNN_FLAG_PRIOR_MEDIUM 0x00000001 + +/* set low priority context. */ +#define RKNN_FLAG_PRIOR_LOW 0x00000002 + +/* asynchronous mode. + when enable, rknn_outputs_get will not block for too long because it directly retrieves the result of + the previous frame which can increase the frame rate on single-threaded mode, but at the cost of + rknn_outputs_get not retrieves the result of the current frame. + in multi-threaded mode you do not need to turn this mode on. */ +#define RKNN_FLAG_ASYNC_MASK 0x00000004 + +/* collect performance mode. + when enable, you can get detailed performance reports via rknn_query(ctx, RKNN_QUERY_PERF_DETAIL, ...), + but it will reduce the frame rate. */ +#define RKNN_FLAG_COLLECT_PERF_MASK 0x00000008 + +/* allocate all memory in outside, includes weight/internal/inputs/outputs */ +#define RKNN_FLAG_MEM_ALLOC_OUTSIDE 0x00000010 + +/* weight sharing with the same network structure */ +#define RKNN_FLAG_SHARE_WEIGHT_MEM 0x00000020 + +/* send fence fd from outside */ +#define RKNN_FLAG_FENCE_IN_OUTSIDE 0x00000040 + +/* get fence fd from inside */ +#define RKNN_FLAG_FENCE_OUT_OUTSIDE 0x00000080 + +/* dummy init flag: could only get total_weight_size and total_internal_size by rknn_query*/ +#define RKNN_FLAG_COLLECT_MODEL_INFO_ONLY 0x00000100 + +/* set GPU as the preferred execution backend When the operator is not supported by the NPU */ +#define RKNN_FLAG_EXECUTE_FALLBACK_PRIOR_DEVICE_GPU 0x00000400 + +/* allocate internal memory in outside */ +#define RKNN_FLAG_INTERNAL_ALLOC_OUTSIDE 0x00000200 + +/* + Error code returned by the RKNN API. +*/ +#define RKNN_SUCC 0 /* execute succeed. */ +#define RKNN_ERR_FAIL -1 /* execute failed. */ +#define RKNN_ERR_TIMEOUT -2 /* execute timeout. */ +#define RKNN_ERR_DEVICE_UNAVAILABLE -3 /* device is unavailable. */ +#define RKNN_ERR_MALLOC_FAIL -4 /* memory malloc fail. */ +#define RKNN_ERR_PARAM_INVALID -5 /* parameter is invalid. */ +#define RKNN_ERR_MODEL_INVALID -6 /* model is invalid. */ +#define RKNN_ERR_CTX_INVALID -7 /* context is invalid. */ +#define RKNN_ERR_INPUT_INVALID -8 /* input is invalid. */ +#define RKNN_ERR_OUTPUT_INVALID -9 /* output is invalid. */ +#define RKNN_ERR_DEVICE_UNMATCH -10 /* the device is unmatch, please update rknn sdk + and npu driver/firmware. */ +#define RKNN_ERR_INCOMPATILE_PRE_COMPILE_MODEL -11 /* This RKNN model use pre_compile mode, but not compatible with current driver. */ +#define RKNN_ERR_INCOMPATILE_OPTIMIZATION_LEVEL_VERSION -12 /* This RKNN model set optimization level, but not compatible with current driver. */ +#define RKNN_ERR_TARGET_PLATFORM_UNMATCH -13 /* This RKNN model set target platform, but not compatible with current platform. */ + +/* + Definition for tensor +*/ +#define RKNN_MAX_DIMS 16 /* maximum dimension of tensor. */ +#define RKNN_MAX_NUM_CHANNEL 15 /* maximum channel number of input tensor. */ +#define RKNN_MAX_NAME_LEN 256 /* maximum name lenth of tensor. */ +#define RKNN_MAX_DYNAMIC_SHAPE_NUM 512 /* maximum number of dynamic shape for each input. */ + +#ifdef __arm__ +typedef uint32_t rknn_context; +#else +typedef uint64_t rknn_context; +#endif + + +/* + The query command for rknn_query +*/ +typedef enum _rknn_query_cmd { + RKNN_QUERY_IN_OUT_NUM = 0, /* query the number of input & output tensor. */ + RKNN_QUERY_INPUT_ATTR = 1, /* query the attribute of input tensor. */ + RKNN_QUERY_OUTPUT_ATTR = 2, /* query the attribute of output tensor. */ + RKNN_QUERY_PERF_DETAIL = 3, /* query the detail performance, need set + RKNN_FLAG_COLLECT_PERF_MASK when call rknn_init, + this query needs to be valid after rknn_outputs_get. */ + RKNN_QUERY_PERF_RUN = 4, /* query the time of run, + this query needs to be valid after rknn_outputs_get. */ + RKNN_QUERY_SDK_VERSION = 5, /* query the sdk & driver version */ + + RKNN_QUERY_MEM_SIZE = 6, /* query the weight & internal memory size */ + RKNN_QUERY_CUSTOM_STRING = 7, /* query the custom string */ + + RKNN_QUERY_NATIVE_INPUT_ATTR = 8, /* query the attribute of native input tensor. */ + RKNN_QUERY_NATIVE_OUTPUT_ATTR = 9, /* query the attribute of native output tensor. */ + + RKNN_QUERY_NATIVE_NC1HWC2_INPUT_ATTR = 8, /* query the attribute of native input tensor. */ + RKNN_QUERY_NATIVE_NC1HWC2_OUTPUT_ATTR = 9, /* query the attribute of native output tensor. */ + + RKNN_QUERY_NATIVE_NHWC_INPUT_ATTR = 10, /* query the attribute of native input tensor. */ + RKNN_QUERY_NATIVE_NHWC_OUTPUT_ATTR = 11, /* query the attribute of native output tensor. */ + + RKNN_QUERY_DEVICE_MEM_INFO = 12, /* query the attribute of rknn memory information. */ + + RKNN_QUERY_INPUT_DYNAMIC_RANGE = 13, /* query the dynamic shape range of rknn input tensor. */ + RKNN_QUERY_CURRENT_INPUT_ATTR = 14, /* query the current shape of rknn input tensor, only valid for dynamic rknn model*/ + RKNN_QUERY_CURRENT_OUTPUT_ATTR = 15, /* query the current shape of rknn output tensor, only valid for dynamic rknn model*/ + + RKNN_QUERY_CURRENT_NATIVE_INPUT_ATTR = 16, /* query the current native shape of rknn input tensor, only valid for dynamic rknn model*/ + RKNN_QUERY_CURRENT_NATIVE_OUTPUT_ATTR = 17, /* query the current native shape of rknn output tensor, only valid for dynamic rknn model*/ + + + RKNN_QUERY_CMD_MAX +} rknn_query_cmd; + +/* + the tensor data type. +*/ +typedef enum _rknn_tensor_type { + RKNN_TENSOR_FLOAT32 = 0, /* data type is float32. */ + RKNN_TENSOR_FLOAT16, /* data type is float16. */ + RKNN_TENSOR_INT8, /* data type is int8. */ + RKNN_TENSOR_UINT8, /* data type is uint8. */ + RKNN_TENSOR_INT16, /* data type is int16. */ + RKNN_TENSOR_UINT16, /* data type is uint16. */ + RKNN_TENSOR_INT32, /* data type is int32. */ + RKNN_TENSOR_UINT32, /* data type is uint32. */ + RKNN_TENSOR_INT64, /* data type is int64. */ + RKNN_TENSOR_BOOL, + + RKNN_TENSOR_TYPE_MAX +} rknn_tensor_type; + +inline static const char* get_type_string(rknn_tensor_type type) +{ + switch(type) { + case RKNN_TENSOR_FLOAT32: return "FP32"; + case RKNN_TENSOR_FLOAT16: return "FP16"; + case RKNN_TENSOR_INT8: return "INT8"; + case RKNN_TENSOR_UINT8: return "UINT8"; + case RKNN_TENSOR_INT16: return "INT16"; + case RKNN_TENSOR_UINT16: return "UINT16"; + case RKNN_TENSOR_INT32: return "INT32"; + case RKNN_TENSOR_UINT32: return "UINT32"; + case RKNN_TENSOR_INT64: return "INT64"; + case RKNN_TENSOR_BOOL: return "BOOL"; + default: return "UNKNOW"; + } +} + +/* + the quantitative type. +*/ +typedef enum _rknn_tensor_qnt_type { + RKNN_TENSOR_QNT_NONE = 0, /* none. */ + RKNN_TENSOR_QNT_DFP, /* dynamic fixed point. */ + RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC, /* asymmetric affine. */ + + RKNN_TENSOR_QNT_MAX +} rknn_tensor_qnt_type; + +inline static const char* get_qnt_type_string(rknn_tensor_qnt_type type) +{ + switch(type) { + case RKNN_TENSOR_QNT_NONE: return "NONE"; + case RKNN_TENSOR_QNT_DFP: return "DFP"; + case RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC: return "AFFINE"; + default: return "UNKNOW"; + } +} + +/* + the tensor data format. +*/ +typedef enum _rknn_tensor_format { + RKNN_TENSOR_NCHW = 0, /* data format is NCHW. */ + RKNN_TENSOR_NHWC, /* data format is NHWC. */ + RKNN_TENSOR_NC1HWC2, /* data format is NC1HWC2. */ + RKNN_TENSOR_UNDEFINED, + + RKNN_TENSOR_FORMAT_MAX +} rknn_tensor_format; + +/* + the mode of running on target NPU core. +*/ +typedef enum _rknn_core_mask { + RKNN_NPU_CORE_AUTO = 0, /* default, run on NPU core randomly. */ + RKNN_NPU_CORE_0 = 1, /* run on NPU core 0. */ + RKNN_NPU_CORE_1 = 2, /* run on NPU core 1. */ + RKNN_NPU_CORE_2 = 4, /* run on NPU core 2. */ + RKNN_NPU_CORE_0_1 = RKNN_NPU_CORE_0 | RKNN_NPU_CORE_1, /* run on NPU core 0 and core 1. */ + RKNN_NPU_CORE_0_1_2 = RKNN_NPU_CORE_0_1 | RKNN_NPU_CORE_2, /* run on NPU core 0 and core 1 and core 2. */ + + RKNN_NPU_CORE_UNDEFINED, +} rknn_core_mask; + +inline static const char* get_format_string(rknn_tensor_format fmt) +{ + switch(fmt) { + case RKNN_TENSOR_NCHW: return "NCHW"; + case RKNN_TENSOR_NHWC: return "NHWC"; + case RKNN_TENSOR_NC1HWC2: return "NC1HWC2"; + case RKNN_TENSOR_UNDEFINED: return "UNDEFINED"; + default: return "UNKNOW"; + } +} + +/* + the information for RKNN_QUERY_IN_OUT_NUM. +*/ +typedef struct _rknn_input_output_num { + uint32_t n_input; /* the number of input. */ + uint32_t n_output; /* the number of output. */ +} rknn_input_output_num; + +/* + the information for RKNN_QUERY_INPUT_ATTR / RKNN_QUERY_OUTPUT_ATTR. +*/ +typedef struct _rknn_tensor_attr { + uint32_t index; /* input parameter, the index of input/output tensor, + need set before call rknn_query. */ + + uint32_t n_dims; /* the number of dimensions. */ + uint32_t dims[RKNN_MAX_DIMS]; /* the dimensions array. */ + char name[RKNN_MAX_NAME_LEN]; /* the name of tensor. */ + + uint32_t n_elems; /* the number of elements. */ + uint32_t size; /* the bytes size of tensor. */ + + rknn_tensor_format fmt; /* the data format of tensor. */ + rknn_tensor_type type; /* the data type of tensor. */ + rknn_tensor_qnt_type qnt_type; /* the quantitative type of tensor. */ + int8_t fl; /* fractional length for RKNN_TENSOR_QNT_DFP. */ + int32_t zp; /* zero point for RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC. */ + float scale; /* scale for RKNN_TENSOR_QNT_AFFINE_ASYMMETRIC. */ + + uint32_t w_stride; /* the stride of tensor along the width dimention of input, + Note: it is read-only, 0 means equal to width. */ + uint32_t size_with_stride; /* the bytes size of tensor with stride. */ + + uint8_t pass_through; /* pass through mode, for rknn_set_io_mem interface. + if TRUE, the buf data is passed directly to the input node of the rknn model + without any conversion. the following variables do not need to be set. + if FALSE, the buf data is converted into an input consistent with the model + according to the following type and fmt. so the following variables + need to be set.*/ + uint32_t h_stride; /* the stride along the height dimention of input, + Note: it is write-only, if it was set to 0, h_stride = height. */ +} rknn_tensor_attr; + +typedef struct _rknn_input_range { + uint32_t index; /* input parameter, the index of input/output tensor, + need set before call rknn_query. */ + uint32_t shape_number; /* the number of shape. */ + rknn_tensor_format fmt; /* the data format of tensor. */ + char name[RKNN_MAX_NAME_LEN]; /* the name of tensor. */ + uint32_t dyn_range[RKNN_MAX_DYNAMIC_SHAPE_NUM][RKNN_MAX_DIMS]; /* the dynamic input dimensions range. */ + uint32_t n_dims; /* the number of dimensions. */ + +} rknn_input_range; + +/* + the information for RKNN_QUERY_PERF_DETAIL. +*/ +typedef struct _rknn_perf_detail { + char* perf_data; /* the string pointer of perf detail. don't need free it by user. */ + uint64_t data_len; /* the string length. */ +} rknn_perf_detail; + +/* + the information for RKNN_QUERY_PERF_RUN. +*/ +typedef struct _rknn_perf_run { + int64_t run_duration; /* real inference time (us) */ +} rknn_perf_run; + +/* + the information for RKNN_QUERY_SDK_VERSION. +*/ +typedef struct _rknn_sdk_version { + char api_version[256]; /* the version of rknn api. */ + char drv_version[256]; /* the version of rknn driver. */ +} rknn_sdk_version; + +/* + the information for RKNN_QUERY_MEM_SIZE. +*/ +typedef struct _rknn_mem_size { + uint32_t total_weight_size; /* the weight memory size */ + uint32_t total_internal_size; /* the internal memory size, exclude inputs/outputs */ + uint64_t total_dma_allocated_size; /* total dma memory allocated size */ + uint32_t total_sram_size; /* total system sram size reserved for rknn */ + uint32_t free_sram_size; /* free system sram size reserved for rknn */ + uint32_t reserved[10]; /* reserved */ +} rknn_mem_size; + +/* + the information for RKNN_QUERY_CUSTOM_STRING. +*/ +typedef struct _rknn_custom_string { + char string[1024]; /* the string of custom, lengths max to 1024 bytes */ +} rknn_custom_string; + +/* + The flags of rknn_tensor_mem. +*/ +typedef enum _rknn_tensor_mem_flags { + RKNN_TENSOR_MEMORY_FLAGS_ALLOC_INSIDE = 1, /*Used to mark in rknn_destroy_mem() whether it is necessary to release the "mem" pointer itself. + If the flag RKNN_TENSOR_MEMORY_FLAGS_ALLOC_INSIDE is set, rknn_destroy_mem() will call free(mem).*/ + RKNN_TENSOR_MEMORY_FLAGS_FROM_FD = 2, /*Used to mark in rknn_create_mem_from_fd() whether it is necessary to release the "mem" pointer itself. + If the flag RKNN_TENSOR_MEMORY_FLAGS_FROM_FD is set, rknn_destroy_mem() will call free(mem).*/ + RKNN_TENSOR_MEMORY_FLAGS_FROM_PHYS = 3, /*Used to mark in rknn_create_mem_from_phys() whether it is necessary to release the "mem" pointer itself. + If the flag RKNN_TENSOR_MEMORY_FLAGS_FROM_PHYS is set, rknn_destroy_mem() will call free(mem).*/ + RKNN_TENSOR_MEMORY_FLAGS_UNKNOWN +} rknn_tensor_mem_flags; + +/* + the memory information of tensor. +*/ +typedef struct _rknn_tensor_memory { + void* virt_addr; /* the virtual address of tensor buffer. */ + uint64_t phys_addr; /* the physical address of tensor buffer. */ + int32_t fd; /* the fd of tensor buffer. */ + int32_t offset; /* indicates the offset of the memory. */ + uint32_t size; /* the size of tensor buffer. */ + uint32_t flags; /* the flags of tensor buffer, reserved */ + void * priv_data; /* the private data of tensor buffer. */ +} rknn_tensor_mem; + +/* + the input information for rknn_input_set. +*/ +typedef struct _rknn_input { + uint32_t index; /* the input index. */ + void* buf; /* the input buf for index. */ + uint32_t size; /* the size of input buf. */ + uint8_t pass_through; /* pass through mode. + if TRUE, the buf data is passed directly to the input node of the rknn model + without any conversion. the following variables do not need to be set. + if FALSE, the buf data is converted into an input consistent with the model + according to the following type and fmt. so the following variables + need to be set.*/ + rknn_tensor_type type; /* the data type of input buf. */ + rknn_tensor_format fmt; /* the data format of input buf. + currently the internal input format of NPU is NCHW by default. + so entering NCHW data can avoid the format conversion in the driver. */ +} rknn_input; + +/* + the output information for rknn_outputs_get. +*/ +typedef struct _rknn_output { + uint8_t want_float; /* want transfer output data to float */ + uint8_t is_prealloc; /* whether buf is pre-allocated. + if TRUE, the following variables need to be set. + if FALSE, the following variables do not need to be set. */ + uint32_t index; /* the output index. */ + void* buf; /* the output buf for index. + when is_prealloc = FALSE and rknn_outputs_release called, + this buf pointer will be free and don't use it anymore. */ + uint32_t size; /* the size of output buf. */ +} rknn_output; + +/* + the extend information for rknn_init. +*/ +typedef struct _rknn_init_extend { + rknn_context ctx; /* rknn context */ + int32_t real_model_offset; /* real rknn model file offset, only valid when init context with rknn file path */ + uint32_t real_model_size; /* real rknn model file size, only valid when init context with rknn file path */ + uint8_t reserved[120]; /* reserved */ +} rknn_init_extend; + +/* + the extend information for rknn_run. +*/ +typedef struct _rknn_run_extend { + uint64_t frame_id; /* output parameter, indicate current frame id of run. */ + int32_t non_block; /* block flag of run, 0 is block else 1 is non block */ + int32_t timeout_ms; /* timeout for block mode, in milliseconds */ + int32_t fence_fd; /* fence fd from other unit */ +} rknn_run_extend; + +/* + the extend information for rknn_outputs_get. +*/ +typedef struct _rknn_output_extend { + uint64_t frame_id; /* output parameter, indicate the frame id of outputs, corresponds to + struct rknn_run_extend.frame_id.*/ +} rknn_output_extend; + + +/* rknn_init + + initial the context and load the rknn model. + + input: + rknn_context* context the pointer of context handle. + void* model if size > 0, pointer to the rknn model, if size = 0, filepath to the rknn model. + uint32_t size the size of rknn model. + uint32_t flag extend flag, see the define of RKNN_FLAG_XXX_XXX. + rknn_init_extend* extend the extend information of init. + return: + int error code. +*/ +int rknn_init(rknn_context* context, void* model, uint32_t size, uint32_t flag, rknn_init_extend* extend); + +/* rknn_dup_context + + initial the context and load the rknn model. + + input: + rknn_context* context_in the pointer of context in handle. + rknn_context* context_out the pointer of context out handle. + return: + int error code. +*/ +int rknn_dup_context(rknn_context* context_in, rknn_context* context_out); + +/* rknn_destroy + + unload the rknn model and destroy the context. + + input: + rknn_context context the handle of context. + return: + int error code. +*/ +int rknn_destroy(rknn_context context); + + +/* rknn_query + + query the information about model or others. see rknn_query_cmd. + + input: + rknn_context context the handle of context. + rknn_query_cmd cmd the command of query. + void* info the buffer point of information. + uint32_t size the size of information. + return: + int error code. +*/ +int rknn_query(rknn_context context, rknn_query_cmd cmd, void* info, uint32_t size); + + +/* rknn_inputs_set + + set inputs information by input index of rknn model. + inputs information see rknn_input. + + input: + rknn_context context the handle of context. + uint32_t n_inputs the number of inputs. + rknn_input inputs[] the arrays of inputs information, see rknn_input. + return: + int error code +*/ +int rknn_inputs_set(rknn_context context, uint32_t n_inputs, rknn_input inputs[]); + +/* + rknn_set_batch_core_num + + set rknn batch core_num. + + input: + rknn_context context the handle of context. + int core_num the core number. + return: + int error code. + +*/ +int rknn_set_batch_core_num(rknn_context context, int core_num); + +/* rknn_set_core_mask + + set rknn core mask.(only supported on RK3588 now) + + RKNN_NPU_CORE_AUTO: auto mode, default value + RKNN_NPU_CORE_0: core 0 mode + RKNN_NPU_CORE_1: core 1 mode + RKNN_NPU_CORE_2: core 2 mode + RKNN_NPU_CORE_0_1: combine core 0/1 mode + RKNN_NPU_CORE_0_1_2: combine core 0/1/2 mode + + input: + rknn_context context the handle of context. + rknn_core_mask core_mask the core mask. + return: + int error code. +*/ +int rknn_set_core_mask(rknn_context context, rknn_core_mask core_mask); + +/* rknn_run + + run the model to execute inference. + + input: + rknn_context context the handle of context. + rknn_run_extend* extend the extend information of run. + return: + int error code. +*/ +int rknn_run(rknn_context context, rknn_run_extend* extend); + + +/* rknn_wait + + wait the model after execute inference. + + input: + rknn_context context the handle of context. + rknn_run_extend* extend the extend information of run. + return: + int error code. +*/ +int rknn_wait(rknn_context context, rknn_run_extend* extend); + + +/* rknn_outputs_get + + wait the inference to finish and get the outputs. + this function will block until inference finish. + the results will set to outputs[]. + + input: + rknn_context context the handle of context. + uint32_t n_outputs the number of outputs. + rknn_output outputs[] the arrays of output, see rknn_output. + rknn_output_extend* the extend information of output. + return: + int error code. +*/ +int rknn_outputs_get(rknn_context context, uint32_t n_outputs, rknn_output outputs[], rknn_output_extend* extend); + + +/* rknn_outputs_release + + release the outputs that get by rknn_outputs_get. + after called, the rknn_output[x].buf get from rknn_outputs_get will + also be free when rknn_output[x].is_prealloc = FALSE. + + input: + rknn_context context the handle of context. + uint32_t n_ouputs the number of outputs. + rknn_output outputs[] the arrays of output. + return: + int error code +*/ +int rknn_outputs_release(rknn_context context, uint32_t n_ouputs, rknn_output outputs[]); + + +/* new api for zero copy */ + +/* rknn_create_mem_from_phys (memory allocated outside) + + initialize tensor memory from physical address. + + input: + rknn_context ctx the handle of context. + uint64_t phys_addr physical address. + void *virt_addr virtual address. + uint32_t size the size of tensor buffer. + return: + rknn_tensor_mem the pointer of tensor memory information. +*/ +rknn_tensor_mem* rknn_create_mem_from_phys(rknn_context ctx, uint64_t phys_addr, void *virt_addr, uint32_t size); + + +/* rknn_create_mem_from_fd (memory allocated outside) + + initialize tensor memory from file description. + + input: + rknn_context ctx the handle of context. + int32_t fd file description. + void *virt_addr virtual address. + uint32_t size the size of tensor buffer. + int32_t offset indicates the offset of the memory (virt_addr without offset). + return: + rknn_tensor_mem the pointer of tensor memory information. +*/ +rknn_tensor_mem* rknn_create_mem_from_fd(rknn_context ctx, int32_t fd, void *virt_addr, uint32_t size, int32_t offset); + + +/* rknn_create_mem_from_mb_blk (memory allocated outside) + + create tensor memory from mb_blk. + + input: + rknn_context ctx the handle of context. + void *mb_blk mb_blk allocate from system api. + int32_t offset indicates the offset of the memory. + return: + rknn_tensor_mem the pointer of tensor memory information. +*/ +rknn_tensor_mem* rknn_create_mem_from_mb_blk(rknn_context ctx, void *mb_blk, int32_t offset); + + +/* rknn_create_mem (memory allocated inside) + + create tensor memory. + + input: + rknn_context ctx the handle of context. + uint32_t size the size of tensor buffer. + return: + rknn_tensor_mem the pointer of tensor memory information. +*/ +rknn_tensor_mem* rknn_create_mem(rknn_context ctx, uint32_t size); + + +/* rknn_destroy_mem (support allocate inside and outside) + + destroy tensor memory. + + input: + rknn_context ctx the handle of context. + rknn_tensor_mem *mem the pointer of tensor memory information. + return: + int error code +*/ +int rknn_destroy_mem(rknn_context ctx, rknn_tensor_mem *mem); + + +/* rknn_set_weight_mem + + set the weight memory. + + input: + rknn_context ctx the handle of context. + rknn_tensor_mem *mem the array of tensor memory information + return: + int error code. +*/ +int rknn_set_weight_mem(rknn_context ctx, rknn_tensor_mem *mem); + + +/* rknn_set_internal_mem + + set the internal memory. + + input: + rknn_context ctx the handle of context. + rknn_tensor_mem *mem the array of tensor memory information + return: + int error code. +*/ +int rknn_set_internal_mem(rknn_context ctx, rknn_tensor_mem *mem); + + +/* rknn_set_io_mem + + set the input and output tensors buffer. + + input: + rknn_context ctx the handle of context. + rknn_tensor_mem *mem the array of tensor memory information. + rknn_tensor_attr *attr the attribute of input or output tensor buffer. + return: + int error code. +*/ +int rknn_set_io_mem(rknn_context ctx, rknn_tensor_mem *mem, rknn_tensor_attr *attr); + +/* rknn_set_input_shape(deprecated) + + set the input tensor shape (only valid for dynamic shape rknn model). + + input: + rknn_context ctx the handle of context. + rknn_tensor_attr *attr the attribute of input or output tensor buffer. + return: + int error code. +*/ +int rknn_set_input_shape(rknn_context ctx, rknn_tensor_attr* attr); + +/* rknn_set_input_shapes + + set all the input tensor shapes. graph will run under current set of input shapes after rknn_set_input_shapes.(only valid for dynamic shape rknn model). + + input: + rknn_context ctx the handle of context. + uint32_t n_inputs the number of inputs. + rknn_tensor_attr attr[] the attribute array of all input tensors. + return: + int error code. +*/ +int rknn_set_input_shapes(rknn_context ctx, uint32_t n_inputs, rknn_tensor_attr attr[]); + +#ifdef __cplusplus +} //extern "C" +#endif + +#endif //_RKNN_API_H diff --git a/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/include/rknn_matmul_api.h b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/include/rknn_matmul_api.h new file mode 100644 index 0000000..6c514bd --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/librknn_api/include/rknn_matmul_api.h @@ -0,0 +1,261 @@ +/**************************************************************************** + * + * Copyright (c) 2017 - 2018 by Rockchip Corp. All rights reserved. + * + * The material in this file is confidential and contains trade secrets + * of Rockchip Corporation. This is proprietary information owned by + * Rockchip Corporation. No part of this work may be disclosed, + * reproduced, copied, transmitted, or used in any way for any purpose, + * without the express written permission of Rockchip Corporation. + * + *****************************************************************************/ + +#ifndef _RKNN_MATMUL_API_H +#define _RKNN_MATMUL_API_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "rknn_api.h" + +typedef rknn_context rknn_matmul_ctx; + +typedef struct _rknn_matmul_tensor_attr +{ + char name[RKNN_MAX_NAME_LEN]; + + // indicate A(M, K) or B(K, N) or C(M, N) + uint32_t n_dims; + uint32_t dims[RKNN_MAX_DIMS]; + + // matmul tensor size + uint32_t size; + + // matmul tensor data type + // int8 : A, B + // int32: C + rknn_tensor_type type; +} rknn_matmul_tensor_attr; + +typedef struct _rknn_matmul_io_attr +{ + // indicate A(M, K) or B(K, N) or C(M, N) + rknn_matmul_tensor_attr A; + rknn_matmul_tensor_attr B; + rknn_matmul_tensor_attr C; +} rknn_matmul_io_attr; + +/* + matmul information struct + */ +typedef struct rknn_matmul_info_t +{ + int32_t M; + int32_t K; // limit: rk356x: int8 type must be aligned with 32byte, float16 type must be aligned with 16byte; + // rk3588: int8 type must be aligned with 32byte, float16 type must be aligned with 32byte; + int32_t N; // limit: rk356x: int8 type must be aligned with 16byte, float16 type must be aligned with 8byte; + // rk3588: int8 type must be aligned with 32byte, float16 type must be aligned with 16byte; + + // matmul data type + // int8: int8(A) x int8(B) -> int32(C) + // float16: float16(A) x float16(B) -> float32(C) + rknn_tensor_type type; + + // matmul native layout for B + // 0: normal layout + // 1: native layout + int32_t native_layout; + + // matmul perf layout for A and C + // 0: normal layout + // 1: perf layout + int32_t perf_layout; +} rknn_matmul_info; + +/* rknn_matmul_create + + params: + rknn_matmul_ctx *ctx the handle of context. + rknn_matmul_info *info the matmal information. + rknn_matmul_io_attr *io_attr inputs/output attribute + return: + int error code +*/ +int rknn_matmul_create(rknn_matmul_ctx* ctx, rknn_matmul_info* info, rknn_matmul_io_attr* io_attr); + +/* rknn_matmul_set_io_mem + + params: + rknn_matmul_ctx ctx the handle of context. + rknn_tensor_mem *mem the pointer of tensor memory information. + rknn_matmul_tensor_attr *attr the attribute of input or output tensor buffer. + return: + int error code. + + formula: + C = A * B, + + limit: + K <= 4096 + K limit: rk356x: int8 type must be aligned with 32byte, float16 type must be aligned with 16byte; + rk3588: int8 type must be aligned with 32byte, float16 type must be aligned with 32byte; + N limit: rk356x: int8 type must be aligned with 16byte, float16 type must be aligned with 8byte; + rk3588: int8 type must be aligned with 32byte, float16 type must be aligned with 16byte; + + A shape: M x K + normal layout: (M, K) + [M1K1, M1K2, ..., M1Kk, + M2K1, M2K2, ..., M2Kk, + ... + MmK1, MmK2, ..., MmKk] + for rk356x： + int8: + perf layout: (K / 8, M, 8) + [K1M1, K2M1, ..., K8M1, + K9M2, K10M2, ..., K16M2, + ... + K(k-7)Mm, K(k-6)Mm, ..., KkMm] + float16: + perf layout: (K / 4, M, 4) + [K1M1, K2M1, ..., K4M1, + K9M2, K10M2, ..., K8M2, + ... + K(k-3)Mm, K(k-2)Mm, ..., KkMm] + for rk3588： + int8: + perf layout: (K / 16, M, 16) + [K1M1, K2M1, ..., K16M1, + K9M2, K10M2, ..., K32M2, + ... + K(k-15)Mm, K(k-14)Mm, ..., KkMm] + float16: + perf layout: (K / 8, M, 8) + [K1M1, K2M1, ..., K8M1, + K9M2, K10M2, ..., K16M2, + ... + K(k-7)Mm, K(k-6)Mm, ..., KkMm] + B shape: K x N + normal layout: (K, N) + [K1N1, K1N2, ..., K1Nn, + K2N1, K2N2, ..., K2Nn, + ... + KkN1, KkN2, ..., KkNn] + for rk356x： + int8: + native layout: (N / 16, K / 32, 16, 32) + [K1N1, K2N1, ..., K32N1, + K1N2, K2N2, ..., K32N2, + ... + K1N16, K2N16, ..., K32N16, + K33N1, K34N1, ..., K64N1, + K33N2, K34N2, ..., K64N2, + ... + K(k-31)N16, K(k-30)N16, ..., KkN16, + K1N17, K2N17, ..., K32N17, + K1N18, K2N18, ..., K32N18, + ... + K(k-31)Nn, K(k-30)Nn, ..., KkNn] + float16: + native layout: (N / 8, K / 16, 8, 16) + [K1N1, K2N1, ..., K16N1, + K1N2, K2N2, ..., K16N2, + ... + K1N8, K2N8, ..., K16N8, + K17N1, K18N1, ..., K32N1, + K17N2, K18N2, ..., K32N2, + ... + K(k-15)N8, K(k-30)N8, ..., KkN8, + K1N9, K2N9, ..., K16N9, + K1N10, K2N10, ..., K16N10, + ... + K(k-15)Nn, K(k-14)Nn, ..., KkNn] + for rk3588： + int8: + native layout: (N / 32, K / 32, 32, 32) + [K1N1, K2N1, ..., K32N1, + K1N2, K2N2, ..., K32N2, + ... + K1N32, K2N32, ..., K32N32, + K33N1, K34N1, ..., K64N1, + K33N2, K34N2, ..., K64N2, + ... + K(k-31)N32, K(k-30)N32, ..., KkN32, + K1N33, K2N33, ..., K32N33, + K1N34, K2N34, ..., K32N34, + ... + K(k-31)Nn, K(k-30)Nn, ..., KkNn] + float16: + native layout: (N / 16, K / 32, 16, 32) + [K1N1, K2N1, ..., K32N1, + K1N2, K2N2, ..., K32N2, + ... + K1N16, K2N16, ..., K32N16, + K33N1, K34N1, ..., K64N1, + K33N2, K34N2, ..., K64N2, + ... + K(k-31)N16, K(k-30)N16, ..., KkN16, + K1N17, K2N17, ..., K32N17, + K1N18, K2N18, ..., K32N18, + ... + K(k-31)Nn, K(k-30)Nn, ..., KkNn] + C shape: M x N + normal layout: (M, N) + [M1N1, M1N2, ..., M1Nn, + M2N1, M2N2, ..., M2Nn, + ... + MmN1, MmN2, ..., MmNn] + perf layout: (N / 4, M, 4) + [N1M1, N2M1, ..., N4M1, + N5M2, N6M2, ..., N8M2, + ... + N(n-3)Mm, N(n-2)Mm, ..., NnMm] + */ +int rknn_matmul_set_io_mem(rknn_matmul_ctx ctx, rknn_tensor_mem* mem, rknn_matmul_tensor_attr* attr); + +/* rknn_matmul_set_core_mask + + set rknn core mask.(only support rk3588 in current) + + RKNN_NPU_CORE_AUTO: auto mode, default value + RKNN_NPU_CORE_0: core 0 mode + RKNN_NPU_CORE_1: core 1 mode + RKNN_NPU_CORE_2: core 2 mode + RKNN_NPU_CORE_0_1: combine core 0/1 mode + RKNN_NPU_CORE_0_1_2: combine core 0/1/2 mode + + input: + rknn_matmul_ctx context the handle of context. + rknn_core_mask core_mask the core mask. + return: + int error code. +*/ +int rknn_matmul_set_core_mask(rknn_matmul_ctx context, rknn_core_mask core_mask); + +/* rknn_matmul_run + + run the matmul in blocking mode + + params: + rknn_matmul_ctx ctx the handle of context. + return: + int error code. + */ +int rknn_matmul_run(rknn_matmul_ctx ctx); + +/* rknn_matmul_destroy + + destroy the matmul context + + params: + rknn_matmul_ctx ctx the handle of context. + return: + int error code. + */ +int rknn_matmul_destroy(rknn_matmul_ctx ctx); + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _RKNN_MATMUL_API_H \ No newline at end of file diff --git a/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/restart_rknn.sh b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/restart_rknn.sh new file mode 100644 index 0000000..6c443a1 --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/restart_rknn.sh @@ -0,0 +1,5 @@ +#!/bin/sh + +killall start_rknn.sh > /dev/null 2>&1 +killall rknn_server > /dev/null 2>&1 +start_rknn.sh & \ No newline at end of file diff --git a/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/rknn_server b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/rknn_server new file mode 100644 index 0000000..d688172 Binary files /dev/null and b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/rknn_server differ diff --git a/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/start_rknn.sh b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/start_rknn.sh new file mode 100644 index 0000000..01843ff --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/runtime/RK3588/Linux/rknn_server/aarch64/usr/bin/start_rknn.sh @@ -0,0 +1,7 @@ +#!/bin/sh + +while true +do + sleep 1 + rknn_server #>/dev/null 2>&1 +done diff --git a/Code/RK3588/stereo_yolo/rknpu2/runtime/init.rknn_server.rc b/Code/RK3588/stereo_yolo/rknpu2/runtime/init.rknn_server.rc new file mode 100644 index 0000000..731f0bb --- /dev/null +++ b/Code/RK3588/stereo_yolo/rknpu2/runtime/init.rknn_server.rc @@ -0,0 +1,9 @@ +#on early-boot +on init + start rknn_server + + +service rknn_server /vendor/bin/rknn_server + class core + seclabel u:r:rknn_server:s0 + disabled