diff options
Diffstat (limited to 'camera/QCamera2/stack/mm-lib2d-interface/test')
| -rw-r--r-- | camera/QCamera2/stack/mm-lib2d-interface/test/Android.mk | 37 | ||||
| -rw-r--r-- | camera/QCamera2/stack/mm-lib2d-interface/test/mm_lib2d_test.c | 543 |
2 files changed, 580 insertions, 0 deletions
diff --git a/camera/QCamera2/stack/mm-lib2d-interface/test/Android.mk b/camera/QCamera2/stack/mm-lib2d-interface/test/Android.mk new file mode 100644 index 0000000..63cd5b7 --- /dev/null +++ b/camera/QCamera2/stack/mm-lib2d-interface/test/Android.mk @@ -0,0 +1,37 @@ +#lib2d sample test +OLD_LOCAL_PATH := $(LOCAL_PATH) +MM_LIB2D_TEST_PATH := $(call my-dir) + +include $(LOCAL_PATH)/../../common.mk +include $(CLEAR_VARS) +LOCAL_PATH := $(MM_LIB2D_TEST_PATH) +LOCAL_MODULE_TAGS := optional + +LOCAL_CFLAGS := -DCAMERA_ION_HEAP_ID=ION_IOMMU_HEAP_ID +LOCAL_CFLAGS += -Wall -Wextra -Werror -Wno-unused-parameter +LOCAL_CFLAGS += -D_ANDROID_ + +ifeq ($(strip $(TARGET_USES_ION)),true) +LOCAL_CFLAGS += -DUSE_ION +endif + +IMGLIB_HEADER_PATH := $(TARGET_OUT_INTERMEDIATES)/include/mm-camera/imglib + +LOCAL_C_INCLUDES += \ + $(IMGLIB_HEADER_PATH) \ + $(LOCAL_PATH)/../../common \ + $(LOCAL_PATH)/../inc + +LOCAL_C_INCLUDES+= $(kernel_includes) +LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) + +LOCAL_SRC_FILES := mm_lib2d_test.c + +LOCAL_32_BIT_ONLY := $(BOARD_QTI_CAMERA_32BIT_ONLY) +LOCAL_MODULE := mm-lib2d-interface-test +LOCAL_PRELINK_MODULE := false +LOCAL_SHARED_LIBRARIES := libcutils libdl libmmlib2d_interface + +include $(BUILD_EXECUTABLE) + +LOCAL_PATH := $(OLD_LOCAL_PATH) diff --git a/camera/QCamera2/stack/mm-lib2d-interface/test/mm_lib2d_test.c b/camera/QCamera2/stack/mm-lib2d-interface/test/mm_lib2d_test.c new file mode 100644 index 0000000..908a4a6 --- /dev/null +++ b/camera/QCamera2/stack/mm-lib2d-interface/test/mm_lib2d_test.c @@ -0,0 +1,543 @@ +/* Copyright (c) 2015-2016, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +// System dependencies +#include <dlfcn.h> +#include <stdbool.h> +#include <stdlib.h> +#include <sys/time.h> + +// Camera dependencies +#include "img_buffer.h" +#include "mm_lib2d.h" + + +#define ENABLE_OUTPUT_DUMP 1 +#define ALIGN4K 4032 +#define ALIGN(a, b) (((a) + (b)) & ~(b)) + + +/** DUMP_TO_FILE: + * @filename: file name + * @p_addr: address of the buffer + * @len: buffer length + * + * dump the image to the file + **/ +#define DUMP_TO_FILE(filename, p_addr, len) ({ \ + size_t rc = 0; \ + FILE *fp = fopen(filename, "w+"); \ + if (fp) { \ + rc = fwrite(p_addr, 1, len, fp); \ + printf(" ] written size %zu \n", __LINE__, len); \ + fclose(fp); \ + } else { \ + printf(" ] open %s failed \n", __LINE__, filename); \ + } \ +}) + +/** DUMP_TO_FILE2: + * @filename: file name + * @p_addr: address of the buffer + * @len: buffer length + * + * dump the image to the file if the memory is non-contiguous + **/ +#define DUMP_TO_FILE2(filename, p_addr1, len1, p_addr2, len2) ({ \ + size_t rc = 0; \ + FILE *fp = fopen(filename, "w+"); \ + if (fp) { \ + rc = fwrite(p_addr1, 1, len1, fp); \ + rc = fwrite(p_addr2, 1, len2, fp); \ + printf(" ] written %zu %zu \n", __LINE__, len1, len2); \ + fclose(fp); \ + } else { \ + printf(" ] open %s failed \n", __LINE__, filename); \ + } \ +}) + +/** img_lib_buffert + * @ptr: handle to the imglib library + * @img_buffer_get: function pointer to img_buffer_get + * @img_buffer_release: function pointer to img_buffer_release + * @img_buffer_cacheops: function pointer to img_buffer_cacheops +**/ +typedef struct { + void *ptr; + int (*img_buffer_get)(img_buf_type_t type, int heapid, int8_t cached, int length, + img_mem_handle_t *p_handle); + int (*img_buffer_release)(img_mem_handle_t *p_handle); + int (*img_buffer_cacheops)(img_mem_handle_t *p_handle, img_cache_ops_t ops, + img_mem_alloc_type_t mem_alloc_type); +} img_lib_buffert; + +/** input_yuv_data + * @filename: input test filename + * @format: format of the input yuv frame + * @wdith: wdith of the input yuv frame + * @height: height of the input yuv frame + * @stride: stride of the input yuv frame + * @offset: offset to the yuv data in the input file +**/ +typedef struct input_yuv_data_t { + char filename[512]; + cam_format_t format; + int32_t wdith; + int32_t height; + int32_t stride; + int32_t offset; +} input_yuv_data; + +input_yuv_data input_nv21[] = { + {"sample0_768x512.yuv", CAM_FORMAT_YUV_420_NV21, 768, 512, 768, 0}, + {"sample1_3200x2400.yuv", CAM_FORMAT_YUV_420_NV21, 3200, 2400, 3200, 0}, + {"sample2_1920x1080.yuv", CAM_FORMAT_YUV_420_NV21, 1920, 1080, 1920, 0}, + {"sample3_3200x2400.yuv", CAM_FORMAT_YUV_420_NV21, 3200, 2400, 3200, 0}, + {"sample4_4208x3120.yuv", CAM_FORMAT_YUV_420_NV21, 4208, 3120, 4208, 0}, + {"sample5_1984x2592.yuv", CAM_FORMAT_YUV_420_NV21, 1984, 2592, 1984, 0}, + {"sample6_4000_3000.yuv", CAM_FORMAT_YUV_420_NV21, 4000, 3000, 4000, 0}, + {"sample7_3200_2400.yuv", CAM_FORMAT_YUV_420_NV21, 3200, 2400, 3200, 0}, + {"sample8_3008_4000.yuv", CAM_FORMAT_YUV_420_NV21, 3008, 4000, 3008, 0}, + {"sample9_5312x2988.yuv", CAM_FORMAT_YUV_420_NV21, 5312, 2988, 5312, 0}, + {"sample10_4128x3096.yuv", CAM_FORMAT_YUV_420_NV21, 4128, 3096, 4128, 0}, + {"sample11_4208x3120.yuv", CAM_FORMAT_YUV_420_NV21, 4208, 3120, 4208, 0}, + {"sample12_3200x2400.yuv", CAM_FORMAT_YUV_420_NV21, 3200, 2400, 3200, 0}, + {"sample13_width_1080_height_1440_stride_1088.yuv", CAM_FORMAT_YUV_420_NV21, 1080, 1440, 1088, 0}, + {"sample14_width_1080_height_1920_stride_1088.yuv", CAM_FORMAT_YUV_420_NV21, 1080, 1920, 1088, 0}, + {"sample15_width_1944_height_2592_stride_1984.yuv", CAM_FORMAT_YUV_420_NV21, 1944, 2592, 1984, 0}, + {"sample16_width_3000_height_4000_stride_3008.yuv", CAM_FORMAT_YUV_420_NV21, 3000, 4000, 3008, 0}, + {"sample17_width_3120_height_4208_stride_3136.yuv", CAM_FORMAT_YUV_420_NV21, 3120, 4208, 3136, 0}, + {"sample18_width_3200_height_2400_stride_3200.yuv", CAM_FORMAT_YUV_420_NV21, 3200, 2400, 3200, 0}, + {"sample19_width_1944_height_2592_stride_1984.yuv", CAM_FORMAT_YUV_420_NV21, 1944, 2592, 1984, 0}, +}; + +// assuming buffer format is always ARGB +void lib2d_dump_tga(void *addr, cam_format_t format, int width, + int height, int stride, char *fname) +{ + int i, j; + FILE *f; + unsigned char *pb = (unsigned char *)addr; + uint32_t *pd = (uint32_t *)addr; + int bpp = 32; + + f = fopen(fname, "wb"); + if (f) { + // header + fprintf(f, "%c%c%c%c", 0, 0, 2, 0); + fprintf(f, "%c%c%c%c", 0, 0, 0, 0); + fprintf(f, "%c%c%c%c", 0, 0, 0, 0); + fprintf(f, "%c%c%c%c", width & 0xff, width >> 8, height & 0xff, height >> 8); + fprintf(f, "%c%c", bpp, 32); + + for (i = 0; i < height; i++) { + for (j = 0; j < width; j++) { + fprintf(f, "%c%c%c%c", + pd[(i*stride>>2)+j] & 0xff, // b + (pd[(i*stride>>2)+j] >> 8) & 0xff, // g + (pd[(i*stride>>2)+j] >> 16) & 0xff, // r + (pd[(i*stride>>2)+j] >> 24) & 0xff); // a + } + } + fclose(f); + } +} + +/** + * Function: lib2d_test_client_cb + * + * Description: Callback that is called on completion of requested job. + * + * Input parameters: + * userdata - App userdata + * jobid - job id that is finished execution + * + * Return values: + * MM_LIB2D_SUCCESS + * MM_LIB2D_ERR_GENERAL + * + * Notes: none + **/ +lib2d_error lib2d_test_client_cb(void *userdata, int jobid) +{ + printf("%s %d, jobid=%d \n", __LINE__, jobid); + return MM_LIB2D_SUCCESS; +} + +/** + * Function: lib2d_test_load_input_yuv_data + * + * Description: Loads yuv data from input file. + * + * Input parameters: + * fileName - input yuv filename + * offset - offset to the yuv data in the input file + * y_size - y plane size in input yuv file + * crcb_size - crcb plane size in input yuv file + * crcb_offset - crcb offset in the memory at + * which crcb data need to be loaded + * addr - y plane memory address where y plane + * data need to be loaded. + * + * Return values: + * MM_LIB2D_SUCCESS + * MM_LIB2D_ERR_GENERAL + * + * Notes: none + **/ +lib2d_error lib2d_test_load_input_yuv_data(char *fileName, int offset, + int32_t y_size, int32_t crcb_size, int32_t crcb_offset, + void *addr) +{ + size_t i; + FILE *fp = 0; + void *y_ptr = addr; + void *crcb_ptr = (uint8_t *)addr + crcb_offset; + + printf("y_ptr=%p, crcb_ptr=%p \n", y_ptr, crcb_ptr); + + fp = fopen(fileName, "rb"); + if(fp) { + if(offset) { + fseek(fp, offset, SEEK_SET); + } + i = fread(y_ptr, 1, y_size, fp); + i = fread(crcb_ptr, 1, crcb_size, fp); + + fclose( fp ); + } else { + printf("failed to open file %s \n", fileName); + return MM_LIB2D_ERR_GENERAL; + } + + return MM_LIB2D_SUCCESS; +} + +/** + * Function: lib2d_test_load_input_yuv_data + * + * Description: Loads yuv data from input file. + * + * Input parameters: + * fileName - input yuv filename + * offset - offset to the yuv data in the input file + * input_yuv_stride - y plane stride in input yuv file + * y_plane_stride - y plane stride in buffer memory + * height - height of yuv image + * crcb_offset - crcb offset in the memory at + * which crcb data need to be loaded + * addr - y plane memory address where y plane + * data need to be loaded. + * + * Return values: + * MM_LIB2D_SUCCESS + * MM_LIB2D_ERR_GENERAL + * + * Notes: none + **/ +lib2d_error lib2d_test_load_input_yuv_data_linebyline(char *fileName, + int offset, int32_t input_yuv_stride, int32_t y_plane_stride, + int32_t height, int32_t crcb_offset, void *addr) +{ + size_t i; + FILE *fp = 0; + void *y_ptr = addr; + void *crcb_ptr = (uint8_t *)addr + crcb_offset; + + printf("y_ptr=%p, crcb_ptr=%p \n", y_ptr, crcb_ptr); + + fp = fopen(fileName, "rb"); + if(fp) { + if(offset) { + fseek(fp, offset, SEEK_SET); + } + if (input_yuv_stride == y_plane_stride) { + //load y plane + i = fread(y_ptr, 1, (input_yuv_stride * height), fp); + // load UV plane + i = fread(crcb_ptr, 1, (input_yuv_stride * height / 2), fp); + } else { + int line = 0; + // load Y plane + for (line = 0;line < height; line++) { + i = fread(y_ptr, 1, input_yuv_stride, fp); + y_ptr = (void *)((uint8_t *)y_ptr + y_plane_stride); + } + for (line = 0;line < height; line++) { + i = fread(crcb_ptr, 1, input_yuv_stride, fp); + crcb_ptr = (void *)((uint8_t *)crcb_ptr + y_plane_stride); + } + } + + fclose( fp ); + } else { + printf("failed to open file %s \n", fileName); + return MM_LIB2D_ERR_GENERAL; + } + + return MM_LIB2D_SUCCESS; +} + +/** + * Function: main + * + * Description: main function for execution + * + * Input parameters: + * argc - no.of input arguments + * argv - list of arguments + * + * Return values: + * 0 on success + * -1 on failure + * + * Notes: none + **/ +int main(int32_t argc, const char * argv[]) +{ + void *lib2d_handle = NULL; + lib2d_error lib2d_err = MM_LIB2D_SUCCESS; + mm_lib2d_buffer src_buffer = {0}; + mm_lib2d_buffer dst_buffer = {0}; + int8_t ret = IMG_SUCCESS; + int32_t width = 0; + int32_t height = 0; + int32_t input_yuv_stride = 0; + int32_t stride = 0; + int32_t y_plane_stride = 0; + int32_t crcb_plane_stride = 0; + int32_t y_plane_size = 0; + int32_t y_plane_size_align = 0; + int32_t crcb_plane_size = 0; + int32_t yuv_size = 0; + int32_t rgb_size = 0; + img_mem_handle_t m_yuv_memHandle = { 0 }; + img_mem_handle_t m_rgb_memHandle = { 0 }; + char filename_in[512] = { 0 }; + char filename_out[512] = { 0 }; + char filename_raw[512] = { 0 }; + int32_t offset = 0; + unsigned int total_tests = 1; + cam_format_t format = CAM_FORMAT_YUV_420_NV21; + unsigned int index; + const char *filename; + + // Open Imglib library and get the function pointers for + // buffer allocation, free, cacheops + img_lib_buffert img_lib; + img_lib.ptr = dlopen("libmmcamera_imglib.so", RTLD_NOW); + if (!img_lib.ptr) { + printf("%s ERROR: couldn't dlopen libmmcamera_imglib.so: %s", + dlerror()); + return -1; + } + + /* Get function pointer for functions to allocate ion memory */ + *(void **)&img_lib.img_buffer_get = + dlsym(img_lib.ptr, "img_buffer_get"); + *(void **)&img_lib.img_buffer_release = + dlsym(img_lib.ptr, "img_buffer_release"); + *(void **)&img_lib.img_buffer_cacheops = + dlsym(img_lib.ptr, "img_buffer_cacheops"); + + /* Validate function pointers */ + if ((img_lib.img_buffer_get == NULL) || + (img_lib.img_buffer_release == NULL) || + (img_lib.img_buffer_cacheops == NULL)) { + printf(" ERROR mapping symbols from libmmcamera_imglib.so"); + dlclose(img_lib.ptr); + return -1; + } + + lib2d_err = mm_lib2d_init(MM_LIB2D_SYNC_MODE, CAM_FORMAT_YUV_420_NV21, + CAM_FORMAT_8888_ARGB, &lib2d_handle); + if ((lib2d_err != MM_LIB2D_SUCCESS) || (lib2d_handle == NULL)) { + return -1; + } + + bool run_default = FALSE; + + if ( argc == 7) { + filename = argv[1]; + width = (uint32_t)atoi(argv[2]); + height = (uint32_t)atoi(argv[3]); + input_yuv_stride = (uint32_t)atoi(argv[4]); + offset = (uint32_t)atoi(argv[5]); + format = (uint32_t)atoi(argv[6]); + run_default = TRUE; + printf("Running user provided conversion \n"); + } + else { + total_tests = sizeof(input_nv21)/sizeof(input_yuv_data); + printf("usage: <binary> <filname> <width> <height> " + "<stride> <offset> <format> \n"); + } + + for (index = 0; index < total_tests; index++) + { + if(run_default == FALSE) { + filename = input_nv21[index].filename; + width = input_nv21[index].wdith; + height = input_nv21[index].height; + input_yuv_stride = input_nv21[index].stride; + offset = input_nv21[index].offset; + format = input_nv21[index].format; + } + + snprintf(filename_in, 512, "/data/lib2d/input/%s", filename); + snprintf(filename_out, 512, "/data/lib2d/output/%s.tga", filename); + snprintf(filename_raw, 512, "/data/lib2d/output/%s.rgba", filename); + + printf("-----------------Running test=%d/%d------------------------- \n", + index+1, total_tests); + printf("filename=%s, full path=%s, width=%d, height=%d, stride=%d \n", + filename, filename_in, width, height, stride); + + // Allocate NV12 buffer + y_plane_stride = ALIGN(width, 32); + y_plane_size = y_plane_stride * height; + y_plane_size_align = ALIGN(y_plane_size, ALIGN4K); + crcb_plane_stride = y_plane_stride; + crcb_plane_size = crcb_plane_stride * height / 2; + yuv_size = y_plane_size_align + crcb_plane_size; + ret = img_lib.img_buffer_get(IMG_BUFFER_ION_IOMMU, -1, TRUE, + yuv_size, &m_yuv_memHandle); + if (ret != IMG_SUCCESS) { + printf(" ] Error, img buf get failed \n"); + goto deinit; + } + + printf("%s %d yuv buffer properties : w=%d, h=%d, y_stride=%d, " + "crcb_stride=%d, y_size=%d, crcb_size=%d, yuv_size=%d, " + "crcb_offset=%d \n", + __LINE__, + width, height, y_plane_stride, crcb_plane_stride, y_plane_size, + crcb_plane_size, yuv_size, y_plane_size_align); + printf("%s %d yuv buffer properties : fd=%d, ptr=%p, size=%d \n", + __LINE__, m_yuv_memHandle.fd, m_yuv_memHandle.vaddr, + m_yuv_memHandle.length); + + // Allocate ARGB buffer + stride = width * 4; + stride = ALIGN(stride, 32); + rgb_size = stride * height; + ret = img_lib.img_buffer_get(IMG_BUFFER_ION_IOMMU, -1, TRUE, + rgb_size, &m_rgb_memHandle); + if (ret != IMG_SUCCESS) { + printf(" ] Error, img buf get failed"); + img_lib.img_buffer_release(&m_yuv_memHandle); + goto deinit; + } + + printf("%s %d rgb buffer properties : w=%d, h=%d, stride=%d, size=%d \n", + __LINE__, width, height, stride, rgb_size); + printf("%s %d rgb buffer properties : fd=%d, ptr=%p, size=%d \n", + __LINE__, m_rgb_memHandle.fd, m_rgb_memHandle.vaddr, + m_rgb_memHandle.length); + +#if 0 + lib2d_err = lib2d_test_load_input_yuv_data(filename_in, offset, + (input_yuv_stride * height), (input_yuv_stride * height / 2), y_plane_size_align, + m_yuv_memHandle.vaddr); + if (lib2d_err != MM_LIB2D_SUCCESS) { + printf(" ] Error loading the input buffer \n"); + goto release; + } +#else + lib2d_err = lib2d_test_load_input_yuv_data_linebyline(filename_in, offset, + input_yuv_stride, y_plane_stride,height, y_plane_size_align, + m_yuv_memHandle.vaddr); + if (lib2d_err != MM_LIB2D_SUCCESS) { + printf(" ] Error loading the input buffer \n"); + goto release; + } +#endif + // Setup source buffer + src_buffer.buffer_type = MM_LIB2D_BUFFER_TYPE_YUV; + src_buffer.yuv_buffer.fd = m_yuv_memHandle.fd; + src_buffer.yuv_buffer.format = format; + src_buffer.yuv_buffer.width = width; + src_buffer.yuv_buffer.height = height; + src_buffer.yuv_buffer.plane0 = m_yuv_memHandle.vaddr; + src_buffer.yuv_buffer.stride0 = y_plane_stride; + src_buffer.yuv_buffer.plane1 = (int8_t *)m_yuv_memHandle.vaddr + + y_plane_size_align; + src_buffer.yuv_buffer.stride1 = crcb_plane_stride; + + // Setup dst buffer + dst_buffer.buffer_type = MM_LIB2D_BUFFER_TYPE_RGB; + dst_buffer.rgb_buffer.fd = m_rgb_memHandle.fd; + dst_buffer.rgb_buffer.format = CAM_FORMAT_8888_ARGB; + dst_buffer.rgb_buffer.width = width; + dst_buffer.rgb_buffer.height = height; + dst_buffer.rgb_buffer.buffer = m_rgb_memHandle.vaddr; + dst_buffer.rgb_buffer.stride = stride; + + img_lib.img_buffer_cacheops(&m_yuv_memHandle, + IMG_CACHE_CLEAN_INV, IMG_INTERNAL); + + lib2d_err = mm_lib2d_start_job(lib2d_handle, &src_buffer, &dst_buffer, + index, NULL, lib2d_test_client_cb, 0); + if (lib2d_err != MM_LIB2D_SUCCESS) { + printf(" ] Error in mm_lib2d_start_job \n"); + goto release; + } + + img_lib.img_buffer_cacheops(&m_rgb_memHandle, + IMG_CACHE_CLEAN_INV, IMG_INTERNAL); + +#ifdef ENABLE_OUTPUT_DUMP + // Dump output files + // snprintf(filename_in, 512, "/data/lib2d/output/%s", filename); + // DUMP_TO_FILE2(filename_in, src_buffer.yuv_buffer.plane0, y_plane_size, src_buffer.yuv_buffer.plane1, crcb_plane_size); + // DUMP_TO_FILE(filename_raw, dst_buffer.rgb_buffer.buffer, rgb_size); + printf("Dumping output file %s \n", filename_out); + lib2d_dump_tga(dst_buffer.rgb_buffer.buffer, 1, + width, height, stride, filename_out); +#endif + + img_lib.img_buffer_release(&m_rgb_memHandle); + img_lib.img_buffer_release(&m_yuv_memHandle); + } + + mm_lib2d_deinit(lib2d_handle); + + return 0; + +release: + img_lib.img_buffer_release(&m_rgb_memHandle); + img_lib.img_buffer_release(&m_yuv_memHandle); +deinit: + mm_lib2d_deinit(lib2d_handle); + printf("%s %d some error happened, tests completed = %d/%d \n", + __LINE__, index - 1, total_tests); + return -1; +} + + |