/* 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 #include #include #include // 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: " " \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; }