diff options
Diffstat (limited to 'camera/QCamera2/stack/mm-jpeg-interface/test')
3 files changed, 1342 insertions, 0 deletions
diff --git a/camera/QCamera2/stack/mm-jpeg-interface/test/Android.mk b/camera/QCamera2/stack/mm-jpeg-interface/test/Android.mk new file mode 100644 index 0000000..b42636c --- /dev/null +++ b/camera/QCamera2/stack/mm-jpeg-interface/test/Android.mk @@ -0,0 +1,87 @@ +#encoder int test +OLD_LOCAL_PATH := $(LOCAL_PATH) +MM_JPEG_TEST_PATH := $(call my-dir) + +include $(LOCAL_PATH)/../../common.mk +include $(CLEAR_VARS) +LOCAL_PATH := $(MM_JPEG_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 + +# System header file path prefix +LOCAL_CFLAGS += -DSYSTEM_HEADER_PREFIX=sys + +OMX_HEADER_DIR := frameworks/native/include/media/openmax +OMX_CORE_DIR := hardware/qcom/camera/mm-image-codec + +LOCAL_C_INCLUDES := $(MM_JPEG_TEST_PATH) +LOCAL_C_INCLUDES += $(MM_JPEG_TEST_PATH)/../inc +LOCAL_C_INCLUDES += $(MM_JPEG_TEST_PATH)/../../common +LOCAL_C_INCLUDES += $(MM_JPEG_TEST_PATH)/../../mm-camera-interface/inc +LOCAL_C_INCLUDES += $(OMX_HEADER_DIR) +LOCAL_C_INCLUDES += $(OMX_CORE_DIR)/qexif +LOCAL_C_INCLUDES += $(OMX_CORE_DIR)/qomx_core + +LOCAL_C_INCLUDES+= $(kernel_includes) +LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) + +LOCAL_SRC_FILES := mm_jpeg_test.c + +LOCAL_32_BIT_ONLY := $(BOARD_QTI_CAMERA_32BIT_ONLY) +LOCAL_MODULE := mm-jpeg-interface-test +LOCAL_PRELINK_MODULE := false +LOCAL_SHARED_LIBRARIES := libcutils libdl libmmjpeg_interface + +include $(BUILD_EXECUTABLE) + + + +#decoder int test + +include $(CLEAR_VARS) +LOCAL_PATH := $(MM_JPEG_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 + +# System header file path prefix +LOCAL_CFLAGS += -DSYSTEM_HEADER_PREFIX=sys + +OMX_HEADER_DIR := frameworks/native/include/media/openmax +OMX_CORE_DIR := hardware/qcom/camera/mm-image-codec + +LOCAL_C_INCLUDES := $(MM_JPEG_TEST_PATH) +LOCAL_C_INCLUDES += $(MM_JPEG_TEST_PATH)/../inc +LOCAL_C_INCLUDES += $(MM_JPEG_TEST_PATH)/../../common +LOCAL_C_INCLUDES += $(MM_JPEG_TEST_PATH)/../../mm-camera-interface/inc +LOCAL_C_INCLUDES += $(OMX_HEADER_DIR) +LOCAL_C_INCLUDES += $(OMX_CORE_DIR)/qexif +LOCAL_C_INCLUDES += $(OMX_CORE_DIR)/qomx_core + +LOCAL_C_INCLUDES+= $(kernel_includes) +LOCAL_ADDITIONAL_DEPENDENCIES := $(common_deps) + +LOCAL_SRC_FILES := mm_jpegdec_test.c + +LOCAL_32_BIT_ONLY := $(BOARD_QTI_CAMERA_32BIT_ONLY) +LOCAL_MODULE := mm-jpegdec-interface-test +LOCAL_PRELINK_MODULE := false +LOCAL_SHARED_LIBRARIES := libcutils libdl libmmjpeg_interface + +include $(BUILD_EXECUTABLE) + +LOCAL_PATH := $(OLD_LOCAL_PATH)
\ No newline at end of file diff --git a/camera/QCamera2/stack/mm-jpeg-interface/test/mm_jpeg_test.c b/camera/QCamera2/stack/mm-jpeg-interface/test/mm_jpeg_test.c new file mode 100644 index 0000000..b1ddafc --- /dev/null +++ b/camera/QCamera2/stack/mm-jpeg-interface/test/mm_jpeg_test.c @@ -0,0 +1,776 @@ +/* Copyright (c) 2013-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 <pthread.h> +#include <stdlib.h> +#define TIME_H <SYSTEM_HEADER_PREFIX/time.h> +#include TIME_H + +// JPEG dependencies +#include "mm_jpeg_interface.h" +#include "mm_jpeg_ionbuf.h" + +// Camera dependencies +#include "mm_camera_dbg.h" + +#define MAX_NUM_BUFS (12) +#define MAX_NUM_CLIENT (8) + +/** 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) ({ \ + FILE *fp = fopen(filename, "w+"); \ + if (fp) { \ + fwrite(p_addr, 1, len, fp); \ + fclose(fp); \ + } else { \ + LOGE("cannot dump image"); \ + } \ +}) + +static uint32_t g_count = 1U, g_i; + +typedef struct { + mm_jpeg_color_format fmt; + cam_rational_type_t mult; + const char *str; +} mm_jpeg_intf_test_colfmt_t; + +typedef struct { + char *filename; + int width; + int height; + char *out_filename; + uint32_t burst_mode; + uint32_t min_out_bufs; + mm_jpeg_intf_test_colfmt_t col_fmt; + uint32_t encode_thumbnail; + int tmb_width; + int tmb_height; + int main_quality; + int thumb_quality; + char *qtable_luma_file; + char *qtable_chroma_file; + int client_cnt; +} jpeg_test_input_t; + +/* Static constants */ +/* default Luma Qtable */ +uint8_t DEFAULT_QTABLE_0[QUANT_SIZE] = { + 16, 11, 10, 16, 24, 40, 51, 61, + 12, 12, 14, 19, 26, 58, 60, 55, + 14, 13, 16, 24, 40, 57, 69, 56, + 14, 17, 22, 29, 51, 87, 80, 62, + 18, 22, 37, 56, 68, 109, 103, 77, + 24, 35, 55, 64, 81, 104, 113, 92, + 49, 64, 78, 87, 103, 121, 120, 101, + 72, 92, 95, 98, 112, 100, 103, 99 +}; + +/* default Chroma Qtable */ +uint8_t DEFAULT_QTABLE_1[QUANT_SIZE] = { + 17, 18, 24, 47, 99, 99, 99, 99, + 18, 21, 26, 66, 99, 99, 99, 99, + 24, 26, 56, 99, 99, 99, 99, 99, + 47, 66, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99, + 99, 99, 99, 99, 99, 99, 99, 99 +}; + +typedef struct { + char *filename[MAX_NUM_BUFS]; + int width; + int height; + char *out_filename[MAX_NUM_BUFS]; + pthread_mutex_t lock; + pthread_cond_t cond; + pthread_t thread_id; + buffer_t input[MAX_NUM_BUFS]; + buffer_t output[MAX_NUM_BUFS]; + int use_ion; + uint32_t handle; + mm_jpeg_ops_t ops; + uint32_t job_id[MAX_NUM_BUFS]; + mm_jpeg_encode_params_t params; + mm_jpeg_job_t job; + uint32_t session_id; + uint32_t num_bufs; + uint32_t min_out_bufs; + size_t buf_filled_len[MAX_NUM_BUFS]; + mm_dimension pic_size; + int ret; + int clinet_id; +} mm_jpeg_intf_test_t; + + + +static const mm_jpeg_intf_test_colfmt_t color_formats[] = +{ + { MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2, {3, 2}, "YCRCBLP_H2V2" }, + { MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2, {3, 2}, "YCBCRLP_H2V2" }, + { MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1, {2, 1}, "YCRCBLP_H2V1" }, + { MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1, {2, 1}, "YCBCRLP_H2V1" }, + { MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V2, {2, 1}, "YCRCBLP_H1V2" }, + { MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V2, {2, 1}, "YCBCRLP_H1V2" }, + { MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V1, {3, 1}, "YCRCBLP_H1V1" }, + { MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V1, {3, 1}, "YCBCRLP_H1V1" } +}; + +static jpeg_test_input_t jpeg_input[] = { + { QCAMERA_DUMP_FRM_LOCATION"test_1.yuv", 4000, 3008, QCAMERA_DUMP_FRM_LOCATION"test_1.jpg", 0, 0, + { MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2, {3, 2}, "YCRCBLP_H2V2" }, + 0, 320, 240, 80, 80, NULL, NULL, 1} +}; + +static void mm_jpeg_encode_callback(jpeg_job_status_t status, + uint32_t client_hdl, + uint32_t jobId, + mm_jpeg_output_t *p_output, + void *userData) +{ + mm_jpeg_intf_test_t *p_obj = (mm_jpeg_intf_test_t *)userData; + + pthread_mutex_lock(&p_obj->lock); + + if (status == JPEG_JOB_STATUS_ERROR) { + LOGE("Encode error"); + } else { + int i = 0; + for (i = 0; p_obj->job_id[i] && (jobId != p_obj->job_id[i]); i++) + ; + if (!p_obj->job_id[i]) { + LOGE("Cannot find job ID!!!"); + goto error; + } + LOGE("Encode success addr %p len %zu idx %d", + p_output->buf_vaddr, p_output->buf_filled_len, i); + + p_obj->buf_filled_len[i] = p_output->buf_filled_len; + if (p_obj->min_out_bufs) { + LOGE("Saving file%s addr %p len %zu", + p_obj->out_filename[i], + p_output->buf_vaddr, p_output->buf_filled_len); + DUMP_TO_FILE(p_obj->out_filename[i], p_output->buf_vaddr, + p_output->buf_filled_len); + } + } + g_i++; + +error: + + if (g_i >= g_count) { + LOGE("Signal the thread"); + pthread_cond_signal(&p_obj->cond); + } + pthread_mutex_unlock(&p_obj->lock); +} + +int mm_jpeg_test_alloc(buffer_t *p_buffer, int use_pmem) +{ + int ret = 0; + /*Allocate buffers*/ + if (use_pmem) { + p_buffer->addr = (uint8_t *)buffer_allocate(p_buffer, 0); + if (NULL == p_buffer->addr) { + LOGE("Error"); + return -1; + } + } else { + /* Allocate heap memory */ + p_buffer->addr = (uint8_t *)malloc(p_buffer->size); + if (NULL == p_buffer->addr) { + LOGE("Error"); + return -1; + } + } + return ret; +} + +void mm_jpeg_test_free(buffer_t *p_buffer) +{ + if (p_buffer->addr == NULL) + return; + + if (p_buffer->p_pmem_fd >= 0) + buffer_deallocate(p_buffer); + else + free(p_buffer->addr); + + memset(p_buffer, 0x0, sizeof(buffer_t)); +} + +int mm_jpeg_test_read(mm_jpeg_intf_test_t *p_obj, uint32_t idx) +{ + FILE *fp = NULL; + size_t file_size = 0; + fp = fopen(p_obj->filename[idx], "rb"); + if (!fp) { + LOGE("error"); + return -1; + } + fseek(fp, 0, SEEK_END); + file_size = (size_t)ftell(fp); + fseek(fp, 0, SEEK_SET); + LOGE("input file size is %zu buf_size %zu", + file_size, p_obj->input[idx].size); + + if (p_obj->input[idx].size > file_size) { + LOGE("error"); + fclose(fp); + return -1; + } + fread(p_obj->input[idx].addr, 1, p_obj->input[idx].size, fp); + fclose(fp); + return 0; +} + +/** mm_jpeg_test_read_qtable: + * + * Arguments: + * @filename: Qtable filename + * @chroma_flag: Flag indicating chroma qtable + * + * Return: + * 0 success, failure otherwise + * + * Description: + * Reads qtable from file and sets it in appropriate qtable + * based on flag. + **/ +int mm_jpeg_test_read_qtable(const char *filename, bool chroma_flag) +{ + FILE *fp = NULL; + int i; + + if (filename == NULL) + return 0; + + fp = fopen(filename, "r"); + if (!fp) { + LOGE("error cannot open file"); + return -1; + } + + if (chroma_flag) { + for (i = 0; i < QUANT_SIZE; i++) + fscanf(fp, "%hhu,", &DEFAULT_QTABLE_1[i]); + } else { + for (i = 0; i < QUANT_SIZE; i++) + fscanf(fp, "%hhu,", &DEFAULT_QTABLE_0[i]); + } + + fclose(fp); + return 0; +} + +static int encode_init(jpeg_test_input_t *p_input, mm_jpeg_intf_test_t *p_obj, + int client_id) +{ + int rc = -1; + size_t size = (size_t)(p_input->width * p_input->height); + mm_jpeg_encode_params_t *p_params = &p_obj->params; + mm_jpeg_encode_job_t *p_job_params = &p_obj->job.encode_job; + uint32_t i = 0; + uint32_t burst_mode = p_input->burst_mode; + jpeg_test_input_t *p_in = p_input; + + do { + p_obj->filename[i] = p_in->filename; + p_obj->width = p_input->width; + p_obj->height = p_input->height; + p_obj->out_filename[i] = p_in->out_filename; + p_obj->use_ion = 1; + p_obj->min_out_bufs = p_input->min_out_bufs; + + /* allocate buffers */ + p_obj->input[i].size = size * (size_t)p_input->col_fmt.mult.numerator / + (size_t)p_input->col_fmt.mult.denominator; + rc = mm_jpeg_test_alloc(&p_obj->input[i], p_obj->use_ion); + if (rc) { + LOGE("Error"); + return -1; + } + + + rc = mm_jpeg_test_read(p_obj, i); + if (rc) { + LOGE("Error, unable to read input image"); + return -1; + } + + mm_jpeg_test_read_qtable(p_input->qtable_luma_file, false); + if (rc) { + LOGE("Error, unable to read luma qtable"); + return -1; + } + + mm_jpeg_test_read_qtable(p_input->qtable_chroma_file, true); + if (rc) { + LOGE("Error, unable to read chrome qtable"); + return -1; + } + + /* src buffer config*/ + p_params->src_main_buf[i].buf_size = p_obj->input[i].size; + p_params->src_main_buf[i].buf_vaddr = p_obj->input[i].addr; + p_params->src_main_buf[i].fd = p_obj->input[i].p_pmem_fd; + p_params->src_main_buf[i].index = i; + p_params->src_main_buf[i].format = MM_JPEG_FMT_YUV; + p_params->src_main_buf[i].offset.mp[0].len = (uint32_t)size; + p_params->src_main_buf[i].offset.mp[0].stride = p_input->width; + p_params->src_main_buf[i].offset.mp[0].scanline = p_input->height; + p_params->src_main_buf[i].offset.mp[1].len = (uint32_t)(size >> 1); + + /* src buffer config*/ + p_params->src_thumb_buf[i].buf_size = p_obj->input[i].size; + p_params->src_thumb_buf[i].buf_vaddr = p_obj->input[i].addr; + p_params->src_thumb_buf[i].fd = p_obj->input[i].p_pmem_fd; + p_params->src_thumb_buf[i].index = i; + p_params->src_thumb_buf[i].format = MM_JPEG_FMT_YUV; + p_params->src_thumb_buf[i].offset.mp[0].len = (uint32_t)size; + p_params->src_thumb_buf[i].offset.mp[0].stride = p_input->width; + p_params->src_thumb_buf[i].offset.mp[0].scanline = p_input->height; + p_params->src_thumb_buf[i].offset.mp[1].len = (uint32_t)(size >> 1); + + + i++; + } while((++p_in)->filename); + + p_obj->num_bufs = i; + + pthread_mutex_init(&p_obj->lock, NULL); + pthread_cond_init(&p_obj->cond, NULL); + + + /* set encode parameters */ + p_params->jpeg_cb = mm_jpeg_encode_callback; + p_params->userdata = p_obj; + p_params->color_format = p_input->col_fmt.fmt; + p_params->thumb_color_format = p_input->col_fmt.fmt; + + if (p_obj->min_out_bufs) { + p_params->num_dst_bufs = 2; + } else { + p_params->num_dst_bufs = p_obj->num_bufs; + } + + for (i = 0; i < (uint32_t)p_params->num_dst_bufs; i++) { + p_obj->output[i].size = size * 3/2; + rc = mm_jpeg_test_alloc(&p_obj->output[i], 0); + if (rc) { + LOGE("Error"); + return -1; + } + /* dest buffer config */ + p_params->dest_buf[i].buf_size = p_obj->output[i].size; + p_params->dest_buf[i].buf_vaddr = p_obj->output[i].addr; + p_params->dest_buf[i].fd = p_obj->output[i].p_pmem_fd; + p_params->dest_buf[i].index = i; + } + + + p_params->num_src_bufs = p_obj->num_bufs; + p_params->num_tmb_bufs = 0; + g_count = p_params->num_src_bufs; + + p_params->encode_thumbnail = p_input->encode_thumbnail; + if (p_params->encode_thumbnail) { + p_params->num_tmb_bufs = p_obj->num_bufs; + } + p_params->quality = (uint32_t)p_input->main_quality; + p_params->thumb_quality = (uint32_t)p_input->thumb_quality; + + p_job_params->dst_index = 0; + p_job_params->src_index = 0; + p_job_params->rotation = 0; + + /* main dimension */ + p_job_params->main_dim.src_dim.width = p_obj->width; + p_job_params->main_dim.src_dim.height = p_obj->height; + p_job_params->main_dim.dst_dim.width = p_obj->width; + p_job_params->main_dim.dst_dim.height = p_obj->height; + p_job_params->main_dim.crop.top = 0; + p_job_params->main_dim.crop.left = 0; + p_job_params->main_dim.crop.width = p_obj->width; + p_job_params->main_dim.crop.height = p_obj->height; + + p_params->main_dim = p_job_params->main_dim; + + /* thumb dimension */ + p_job_params->thumb_dim.src_dim.width = p_obj->width; + p_job_params->thumb_dim.src_dim.height = p_obj->height; + p_job_params->thumb_dim.dst_dim.width = p_input->tmb_width; + p_job_params->thumb_dim.dst_dim.height = p_input->tmb_height; + p_job_params->thumb_dim.crop.top = 0; + p_job_params->thumb_dim.crop.left = 0; + p_job_params->thumb_dim.crop.width = 0; + p_job_params->thumb_dim.crop.height = 0; + + p_params->thumb_dim = p_job_params->thumb_dim; + + p_job_params->exif_info.numOfEntries = 0; + p_params->burst_mode = burst_mode; + + /* Qtable */ + p_job_params->qtable[0].eQuantizationTable = + OMX_IMAGE_QuantizationTableLuma; + p_job_params->qtable[1].eQuantizationTable = + OMX_IMAGE_QuantizationTableChroma; + p_job_params->qtable_set[0] = 1; + p_job_params->qtable_set[1] = 1; + + for (i = 0; i < QUANT_SIZE; i++) { + p_job_params->qtable[0].nQuantizationMatrix[i] = DEFAULT_QTABLE_0[i]; + p_job_params->qtable[1].nQuantizationMatrix[i] = DEFAULT_QTABLE_1[i]; + } + + p_obj->pic_size.w = (uint32_t)p_input->width; + p_obj->pic_size.h = (uint32_t)p_input->height; + + p_obj->clinet_id = client_id; + + return 0; +} + +static void *encode_test(void *data) +{ + int rc = 0; + mm_jpeg_intf_test_t *jpeg_obj = (mm_jpeg_intf_test_t *)data; + char file_name[64]; + + uint32_t i = 0; + jpeg_obj->handle = jpeg_open(&jpeg_obj->ops, NULL, jpeg_obj->pic_size, NULL); + if (jpeg_obj->handle == 0) { + LOGE("Error"); + jpeg_obj->ret = -1; + goto end; + } + + rc = jpeg_obj->ops.create_session(jpeg_obj->handle, &jpeg_obj->params, + &jpeg_obj->job.encode_job.session_id); + if (jpeg_obj->job.encode_job.session_id == 0) { + LOGE("Error"); + jpeg_obj->ret = -1; + goto end; + } + + for (i = 0; i < jpeg_obj->num_bufs; i++) { + jpeg_obj->job.job_type = JPEG_JOB_TYPE_ENCODE; + jpeg_obj->job.encode_job.src_index = (int32_t) i; + jpeg_obj->job.encode_job.dst_index = (int32_t) i; + jpeg_obj->job.encode_job.thumb_index = (uint32_t) i; + + if (jpeg_obj->params.burst_mode && jpeg_obj->min_out_bufs) { + jpeg_obj->job.encode_job.dst_index = -1; + } + + rc = jpeg_obj->ops.start_job(&jpeg_obj->job, &jpeg_obj->job_id[i]); + if (rc) { + LOGE("Error"); + jpeg_obj->ret = rc; + goto end; + } + } + jpeg_obj->job_id[i] = 0; + + /* + usleep(5); + jpeg_obj->ops.abort_job(jpeg_obj->job_id[0]); + */ + pthread_mutex_lock(&jpeg_obj->lock); + pthread_cond_wait(&jpeg_obj->cond, &jpeg_obj->lock); + pthread_mutex_unlock(&jpeg_obj->lock); + + jpeg_obj->ops.destroy_session(jpeg_obj->job.encode_job.session_id); + jpeg_obj->ops.close(jpeg_obj->handle); + +end: + for (i = 0; i < jpeg_obj->num_bufs; i++) { + if (!jpeg_obj->min_out_bufs) { + // Save output files + LOGE("Saving file%s addr %p len %zu", + jpeg_obj->out_filename[i], + jpeg_obj->output[i].addr, jpeg_obj->buf_filled_len[i]); + + snprintf(file_name, sizeof(file_name), "%s_%d.jpg", + jpeg_obj->out_filename[i], jpeg_obj->clinet_id); + fprintf(stderr, "Output file for client %d = %s\n", + jpeg_obj->clinet_id, file_name); + + DUMP_TO_FILE(file_name, jpeg_obj->output[i].addr, + jpeg_obj->buf_filled_len[i]); + } + mm_jpeg_test_free(&jpeg_obj->input[i]); + mm_jpeg_test_free(&jpeg_obj->output[i]); + } + return NULL; +} + +#define MAX_FILE_CNT (20) +static int mm_jpeg_test_get_input(int argc, char *argv[], + jpeg_test_input_t *p_test) +{ + int c; + size_t in_file_cnt = 0, out_file_cnt = 0, i; + int idx = 0; + jpeg_test_input_t *p_test_base = p_test; + + char *in_files[MAX_FILE_CNT]; + char *out_files[MAX_FILE_CNT]; + + while ((c = getopt(argc, argv, "-I:O:W:H:F:BTx:y:Q:J:K:C:q:")) != -1) { + switch (c) { + case 'B': + fprintf(stderr, "%-25s\n", "Using burst mode"); + p_test->burst_mode = 1; + break; + case 'I': + for (idx = optind - 1; idx < argc; idx++) { + if (argv[idx][0] == '-') { + break; + } + in_files[in_file_cnt++] = argv[idx]; + } + optind = idx -1; + + break; + case 'O': + for (idx = optind - 1; idx < argc; idx++) { + if (argv[idx][0] == '-') { + break; + } + out_files[out_file_cnt++] = argv[idx]; + } + optind = idx -1; + + break; + case 'W': + p_test->width = atoi(optarg); + fprintf(stderr, "%-25s%d\n", "Width: ", p_test->width); + break; + case 'H': + p_test->height = atoi(optarg); + fprintf(stderr, "%-25s%d\n", "Height: ", p_test->height); + break; + case 'F': + p_test->col_fmt = color_formats[atoi(optarg)]; + fprintf(stderr, "%-25s%s\n", "Format: ", p_test->col_fmt.str); + break; + case 'M': + p_test->min_out_bufs = 1; + fprintf(stderr, "%-25s\n", "Using minimum number of output buffers"); + break; + case 'T': + p_test->encode_thumbnail = 1; + fprintf(stderr, "%-25s\n", "Encode thumbnail"); + break; + case 'x': + p_test->tmb_width = atoi(optarg); + fprintf(stderr, "%-25s%d\n", "Tmb Width: ", p_test->tmb_width); + break; + case 'y': + p_test->tmb_height = atoi(optarg); + fprintf(stderr, "%-25s%d\n", "Tmb Height: ", p_test->tmb_height); + break; + case 'Q': + p_test->main_quality = atoi(optarg); + fprintf(stderr, "%-25s%d\n", "Main quality: ", p_test->main_quality); + break; + case 'q': + p_test->thumb_quality = atoi(optarg); + fprintf(stderr, "%-25s%d\n", "Thumb quality: ", p_test->thumb_quality); + break; + case 'J': + p_test->qtable_luma_file = optarg; + fprintf(stderr, "%-25s%s\n", "Qtable luma path", + p_test->qtable_luma_file); + break; + case 'K': + p_test->qtable_chroma_file = optarg; + fprintf(stderr, "%-25s%s\n", "Qtable chroma path", + p_test->qtable_chroma_file); + break; + case 'C': + p_test->client_cnt = atoi(optarg); + fprintf(stderr, "%-25s%d\n", "Number of clients ", + p_test->client_cnt); + default:; + } + } + fprintf(stderr, "Infiles: %zu Outfiles: %zu\n", in_file_cnt, out_file_cnt); + + if (p_test->client_cnt > MAX_NUM_CLIENT) { + fprintf(stderr, "Clients requested exceeds max limit %d\n", + MAX_NUM_CLIENT); + return 1; + } + if (in_file_cnt > out_file_cnt) { + fprintf(stderr, "%-25s\n", "Insufficient number of output files!"); + return 1; + } + + // Discard the extra out files + out_file_cnt = in_file_cnt; + + p_test = realloc(p_test, (in_file_cnt + 1) * sizeof(*p_test)); + if (!p_test) { + LOGE("Error"); + return 1; + } + memset(p_test+1, 0, (in_file_cnt) * sizeof(*p_test)); + + for (i = 0; i < in_file_cnt; i++, p_test++) { + memcpy(p_test, p_test_base, sizeof(*p_test)); + p_test->filename = in_files[i]; + p_test->out_filename = out_files[i]; + fprintf(stderr, "Inf: %s Outf: %s\n", in_files[i], out_files[i]); + } + + return 0; +} + +static void mm_jpeg_test_print_usage() +{ + fprintf(stderr, "Usage: program_name [options]\n"); + fprintf(stderr, "Mandatory options:\n"); + fprintf(stderr, " -I FILE1 [FILE2] [FILEN]\tList of input files\n"); + fprintf(stderr, " -O FILE1 [FILE2] [FILEN]\tList of output files\n"); + fprintf(stderr, " -W WIDTH\t\tOutput image width\n"); + fprintf(stderr, " -H HEIGHT\t\tOutput image height\n"); + fprintf(stderr, " -F \t\tColor format: \n"); + fprintf(stderr, "\t\t\t\t%s (0), %s (1), %s (2) %s (3)\n" + "\t\t\t\t%s (4), %s (5), %s (6) %s (7)\n ", + color_formats[0].str, color_formats[1].str, + color_formats[2].str, color_formats[3].str, + color_formats[4].str, color_formats[5].str, + color_formats[6].str, color_formats[7].str); + fprintf(stderr, "Optional:\n"); + fprintf(stderr, " -T \t\Encode thumbnail\n"); + fprintf(stderr, " -x TMB_WIDTH\t\tThumbnail width\n"); + fprintf(stderr, " -y TMB_HEIGHT\t\tThumbnail height\n"); + fprintf(stderr, " -Q MAIN_QUALITY\t\tMain image quality\n"); + fprintf(stderr, " -q TMB_QUALITY\t\tThumbnail image quality\n"); + fprintf(stderr, " -B \t\tBurst mode. Utilize both encoder engines on" + "supported targets\n"); + fprintf(stderr, " -M \t\tUse minimum number of output buffers \n"); + fprintf(stderr, " -J \t\tLuma QTable filename. Comma separated 8x8" + " matrix\n"); + fprintf(stderr, " -K \t\tChroma QTable filename. Comma separated" + " 8x8 matrix\n"); + fprintf(stderr, " -C \t\tNumber of clients to run in parllel\n"); + fprintf(stderr, "\n"); +} + +/** main: + * + * Arguments: + * @argc + * @argv + * + * Return: + * 0 or -ve values + * + * Description: + * main function + * + **/ +int main(int argc, char* argv[]) +{ + jpeg_test_input_t *p_test_input; + mm_jpeg_intf_test_t client[MAX_NUM_CLIENT]; + int ret = 0; + int i = 0; + int thread_cnt = 0; + + if (argc > 1) { + p_test_input = calloc(2, sizeof(*p_test_input)); + if (!p_test_input) { + LOGE("Error"); + goto exit; + } + memcpy(p_test_input, &jpeg_input[0], sizeof(*p_test_input)); + ret = mm_jpeg_test_get_input(argc, argv, p_test_input); + if (ret) { + LOGE("Error"); + goto exit; + } + } else { + mm_jpeg_test_print_usage(); + return 1; + } + + for (i = 0; i < p_test_input->client_cnt; i++) { + memset(&client[i], 0x0, sizeof(mm_jpeg_intf_test_t)); + ret = encode_init(p_test_input, &client[i], i); + if (ret) { + LOGE("Error"); + return -1; + } + + ret = pthread_create(&client[i].thread_id, NULL, encode_test, + &client[i]); + if (ret != 0) { + fprintf(stderr, "Error in thread creation\n"); + break; + } + } + + thread_cnt = i; + for (i = 0; i < thread_cnt; i++) { + pthread_join(client[i].thread_id, NULL); + } + +exit: + for (i = 0; i < thread_cnt; i++) { + if (!client[i].ret) { + fprintf(stderr, "%-25s %d %s\n", "Client", i, "Success!"); + } else { + fprintf(stderr, "%-25s %d %s\n", "Client", i, "Fail!"); + } + } + + if (argc > 1) { + if (p_test_input) { + free(p_test_input); + p_test_input = NULL; + } + } + + return ret; +} + + diff --git a/camera/QCamera2/stack/mm-jpeg-interface/test/mm_jpegdec_test.c b/camera/QCamera2/stack/mm-jpeg-interface/test/mm_jpegdec_test.c new file mode 100644 index 0000000..beb62f5 --- /dev/null +++ b/camera/QCamera2/stack/mm-jpeg-interface/test/mm_jpegdec_test.c @@ -0,0 +1,479 @@ +/* Copyright (c) 2013-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 <pthread.h> +#include <stdlib.h> +#define TIME_H <SYSTEM_HEADER_PREFIX/time.h> +#include TIME_H + +// JPEG dependencies +#include "mm_jpeg_interface.h" +#include "mm_jpeg_ionbuf.h" + +// Camera dependencies +#include "mm_camera_dbg.h" + +#define MIN(a,b) (((a) < (b)) ? (a) : (b)) +#define MAX(a,b) (((a) > (b)) ? (a) : (b)) +#define CLAMP(x, min, max) MIN(MAX((x), (min)), (max)) + +#define TIME_IN_US(r) ((uint64_t)r.tv_sec * 1000000LL + (uint64_t)r.tv_usec) +struct timeval dtime[2]; + + +/** 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); \ + fclose(fp); \ + } else { \ + LOGE("cannot dump image"); \ + } \ +}) + +static int g_count = 1, g_i; + +typedef struct { + char *filename; + int width; + int height; + char *out_filename; + int format; +} jpeg_test_input_t; + +typedef struct { + char *filename; + int width; + int height; + char *out_filename; + pthread_mutex_t lock; + pthread_cond_t cond; + buffer_t input; + buffer_t output; + int use_ion; + uint32_t handle; + mm_jpegdec_ops_t ops; + uint32_t job_id[5]; + mm_jpeg_decode_params_t params; + mm_jpeg_job_t job; + uint32_t session_id; +} mm_jpegdec_intf_test_t; + +typedef struct { + char *format_str; + int eColorFormat; +} mm_jpegdec_col_fmt_t; + +#define ARR_SZ(a) (sizeof(a)/sizeof(a[0])) + +static const mm_jpegdec_col_fmt_t col_formats[] = +{ + { "YCRCBLP_H2V2", (int)MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2 }, + { "YCBCRLP_H2V2", (int)MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2 }, + { "YCRCBLP_H2V1", (int)MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1 }, + { "YCBCRLP_H2V1", (int)MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1 }, + { "YCRCBLP_H1V2", (int)MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V2 }, + { "YCBCRLP_H1V2", (int)MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V2 }, + { "YCRCBLP_H1V1", (int)MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V1 }, + { "YCBCRLP_H1V1", (int)MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V1 } +}; + +static void mm_jpegdec_decode_callback(jpeg_job_status_t status, + uint32_t client_hdl, + uint32_t jobId, + mm_jpeg_output_t *p_output, + void *userData) +{ + mm_jpegdec_intf_test_t *p_obj = (mm_jpegdec_intf_test_t *)userData; + + if (status == JPEG_JOB_STATUS_ERROR) { + LOGE("Decode error"); + } else { + gettimeofday(&dtime[1], NULL); + LOGE("Decode time %llu ms", + ((TIME_IN_US(dtime[1]) - TIME_IN_US(dtime[0]))/1000)); + + LOGE("Decode success file%s addr %p len %zu", + p_obj->out_filename, + p_output->buf_vaddr, p_output->buf_filled_len); + DUMP_TO_FILE(p_obj->out_filename, p_output->buf_vaddr, p_output->buf_filled_len); + } + g_i++; + if (g_i >= g_count) { + LOGE("Signal the thread"); + pthread_cond_signal(&p_obj->cond); + } +} + +int mm_jpegdec_test_alloc(buffer_t *p_buffer, int use_pmem) +{ + int ret = 0; + /*Allocate buffers*/ + if (use_pmem) { + p_buffer->addr = (uint8_t *)buffer_allocate(p_buffer, 0); + if (NULL == p_buffer->addr) { + LOGE("Error"); + return -1; + } + } else { + /* Allocate heap memory */ + p_buffer->addr = (uint8_t *)malloc(p_buffer->size); + if (NULL == p_buffer->addr) { + LOGE("Error"); + return -1; + } + } + return ret; +} + +void mm_jpegdec_test_free(buffer_t *p_buffer) +{ + if (p_buffer->addr == NULL) + return; + + if (p_buffer->p_pmem_fd >= 0) + buffer_deallocate(p_buffer); + else + free(p_buffer->addr); + + memset(p_buffer, 0x0, sizeof(buffer_t)); +} + +int mm_jpegdec_test_read(mm_jpegdec_intf_test_t *p_obj) +{ + int rc = 0; + FILE *fp = NULL; + size_t file_size = 0; + fp = fopen(p_obj->filename, "rb"); + if (!fp) { + LOGE("error"); + return -1; + } + fseek(fp, 0, SEEK_END); + file_size = (size_t)ftell(fp); + fseek(fp, 0, SEEK_SET); + + LOGE("input file size is %zu", + file_size); + + p_obj->input.size = file_size; + + /* allocate buffers */ + rc = mm_jpegdec_test_alloc(&p_obj->input, p_obj->use_ion); + if (rc) { + LOGE("Error"); + return -1; + } + + fread(p_obj->input.addr, 1, p_obj->input.size, fp); + fclose(fp); + return 0; +} + +void chromaScale(mm_jpeg_color_format format, double *cScale) +{ + double scale; + + switch(format) { + case MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V2: + case MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V2: + scale = 1.5; + break; + case MM_JPEG_COLOR_FORMAT_YCRCBLP_H2V1: + case MM_JPEG_COLOR_FORMAT_YCBCRLP_H2V1: + case MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V2: + case MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V2: + scale = 2.0; + break; + case MM_JPEG_COLOR_FORMAT_YCRCBLP_H1V1: + case MM_JPEG_COLOR_FORMAT_YCBCRLP_H1V1: + scale = 3.0; + break; + case MM_JPEG_COLOR_FORMAT_MONOCHROME: + scale = 1.0; + break; + default: + scale = 0; + LOGE("color format Error"); + } + + *cScale = scale; +} + +static int decode_init(jpeg_test_input_t *p_input, mm_jpegdec_intf_test_t *p_obj) +{ + int rc = -1; + size_t size = (size_t)(CEILING16(p_input->width) * CEILING16(p_input->height)); + double cScale; + mm_jpeg_decode_params_t *p_params = &p_obj->params; + mm_jpeg_decode_job_t *p_job_params = &p_obj->job.decode_job; + + p_obj->filename = p_input->filename; + p_obj->width = p_input->width; + p_obj->height = p_input->height; + p_obj->out_filename = p_input->out_filename; + p_obj->use_ion = 1; + + pthread_mutex_init(&p_obj->lock, NULL); + pthread_cond_init(&p_obj->cond, NULL); + + chromaScale(p_input->format, &cScale); + p_obj->output.size = (size_t)((double)size * cScale); + rc = mm_jpegdec_test_alloc(&p_obj->output, p_obj->use_ion); + if (rc) { + LOGE("Error"); + return -1; + } + + rc = mm_jpegdec_test_read(p_obj); + if (rc) { + LOGE("Error"); + return -1; + } + + /* set encode parameters */ + p_params->jpeg_cb = mm_jpegdec_decode_callback; + p_params->userdata = p_obj; + p_params->color_format = p_input->format; + + /* dest buffer config */ + p_params->dest_buf[0].buf_size = p_obj->output.size; + p_params->dest_buf[0].buf_vaddr = p_obj->output.addr; + p_params->dest_buf[0].fd = p_obj->output.p_pmem_fd; + p_params->dest_buf[0].format = MM_JPEG_FMT_YUV; + p_params->dest_buf[0].offset.mp[0].len = (uint32_t)size; + p_params->dest_buf[0].offset.mp[1].len = + (uint32_t)((double)size * (cScale - 1.0)); + p_params->dest_buf[0].offset.mp[0].stride = CEILING16(p_input->width); + p_params->dest_buf[0].offset.mp[0].scanline = CEILING16(p_input->height); + p_params->dest_buf[0].offset.mp[1].stride = CEILING16(p_input->width); + p_params->dest_buf[0].offset.mp[1].scanline = CEILING16(p_input->height); + p_params->dest_buf[0].index = 0; + p_params->num_dst_bufs = 1; + + /* src buffer config*/ + p_params->src_main_buf[0].buf_size = p_obj->input.size; + p_params->src_main_buf[0].buf_vaddr = p_obj->input.addr; + p_params->src_main_buf[0].fd = p_obj->input.p_pmem_fd; + p_params->src_main_buf[0].index = 0; + p_params->src_main_buf[0].format = MM_JPEG_FMT_BITSTREAM; + /* + p_params->src_main_buf[0].offset.mp[0].len = size; + p_params->src_main_buf[0].offset.mp[1].len = size >> 1; + */ + p_params->num_src_bufs = 1; + + p_job_params->dst_index = 0; + p_job_params->src_index = 0; + p_job_params->rotation = 0; + + /* main dimension */ + p_job_params->main_dim.src_dim.width = p_obj->width; + p_job_params->main_dim.src_dim.height = p_obj->height; + p_job_params->main_dim.dst_dim.width = p_obj->width; + p_job_params->main_dim.dst_dim.height = p_obj->height; + p_job_params->main_dim.crop.top = 0; + p_job_params->main_dim.crop.left = 0; + p_job_params->main_dim.crop.width = p_obj->width; + p_job_params->main_dim.crop.height = p_obj->height; + + + return 0; +} + +void omx_test_dec_print_usage() +{ + fprintf(stderr, "Usage: program_name [options]\n"); + fprintf(stderr, "Mandatory options:\n"); + fprintf(stderr, " -I FILE\t\tPath to the input file.\n"); + fprintf(stderr, " -O FILE\t\tPath for the output file.\n"); + fprintf(stderr, " -W WIDTH\t\tOutput image width\n"); + fprintf(stderr, " -H HEIGHT\t\tOutput image height\n"); + fprintf(stderr, "Optional:\n"); + fprintf(stderr, " -F FORMAT\t\tDefault image format:\n"); + fprintf(stderr, "\t\t\t\t%s (0), %s (1), %s (2) %s (3)\n" + "%s (4), %s (5), %s (6) %s (7)\n", + col_formats[0].format_str, col_formats[1].format_str, + col_formats[2].format_str, col_formats[3].format_str, + col_formats[4].format_str, col_formats[5].format_str, + col_formats[6].format_str, col_formats[7].format_str + ); + + fprintf(stderr, "\n"); +} + +static int mm_jpegdec_test_get_input(int argc, char *argv[], + jpeg_test_input_t *p_test) +{ + int c; + + while ((c = getopt(argc, argv, "I:O:W:H:F:")) != -1) { + switch (c) { + case 'O': + p_test->out_filename = optarg; + fprintf(stderr, "%-25s%s\n", "Output image path", + p_test->out_filename); + break; + case 'I': + p_test->filename = optarg; + fprintf(stderr, "%-25s%s\n", "Input image path", p_test->filename); + break; + case 'W': + p_test->width = atoi(optarg); + fprintf(stderr, "%-25s%d\n", "Default width", p_test->width); + break; + case 'H': + p_test->height = atoi(optarg); + fprintf(stderr, "%-25s%d\n", "Default height", p_test->height); + break; + case 'F': { + int format = 0; + format = atoi(optarg); + int num_formats = ARR_SZ(col_formats); + format = CLAMP(format, 0, num_formats); + p_test->format = col_formats[format].eColorFormat; + fprintf(stderr, "%-25s%s\n", "Default image format", + col_formats[format].format_str); + break; + } + default:; + } + } + if (!p_test->filename || !p_test->filename || !p_test->width || + !p_test->height) { + fprintf(stderr, "Missing required arguments.\n"); + omx_test_dec_print_usage(); + return -1; + } + return 0; +} + +static int decode_test(jpeg_test_input_t *p_input) +{ + int rc = 0; + mm_jpegdec_intf_test_t jpeg_obj; + int i = 0; + + memset(&jpeg_obj, 0x0, sizeof(jpeg_obj)); + rc = decode_init(p_input, &jpeg_obj); + if (rc) { + LOGE("Error"); + return -1; + } + + jpeg_obj.handle = jpegdec_open(&jpeg_obj.ops); + if (jpeg_obj.handle == 0) { + LOGE("Error"); + goto end; + } + + rc = jpeg_obj.ops.create_session(jpeg_obj.handle, &jpeg_obj.params, + &jpeg_obj.job.decode_job.session_id); + if (jpeg_obj.job.decode_job.session_id == 0) { + LOGE("Error"); + goto end; + } + + for (i = 0; i < g_count; i++) { + jpeg_obj.job.job_type = JPEG_JOB_TYPE_DECODE; + + LOGE("Starting decode job"); + gettimeofday(&dtime[0], NULL); + + fprintf(stderr, "Starting decode of %s into %s outw %d outh %d\n\n", + p_input->filename, p_input->out_filename, + p_input->width, p_input->height); + rc = jpeg_obj.ops.start_job(&jpeg_obj.job, &jpeg_obj.job_id[i]); + if (rc) { + LOGE("Error"); + goto end; + } + } + + /* + usleep(5); + jpeg_obj.ops.abort_job(jpeg_obj.job_id[0]); + */ + pthread_mutex_lock(&jpeg_obj.lock); + pthread_cond_wait(&jpeg_obj.cond, &jpeg_obj.lock); + pthread_mutex_unlock(&jpeg_obj.lock); + + fprintf(stderr, "Decode time %llu ms\n", + ((TIME_IN_US(dtime[1]) - TIME_IN_US(dtime[0]))/1000)); + + + jpeg_obj.ops.destroy_session(jpeg_obj.job.decode_job.session_id); + + jpeg_obj.ops.close(jpeg_obj.handle); + + +end: + mm_jpegdec_test_free(&jpeg_obj.input); + mm_jpegdec_test_free(&jpeg_obj.output); + return 0; +} + +/** main: + * + * Arguments: + * @argc + * @argv + * + * Return: + * 0 or -ve values + * + * Description: + * main function + * + **/ +int main(int argc, char* argv[]) +{ + jpeg_test_input_t dec_test_input; + int ret; + + memset(&dec_test_input, 0, sizeof(dec_test_input)); + ret = mm_jpegdec_test_get_input(argc, argv, &dec_test_input); + + if (ret) { + return -1; + } + + return decode_test(&dec_test_input); +} + + |