| /* 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; |
| } |
| |
| |
