From 6616278131edd80a12545085e06ee6b0e0a0a788 Mon Sep 17 00:00:00 2001 From: Prateek Chaubey Date: Sun, 7 Jan 2018 20:55:14 +0530 Subject: msm8996-common: zuk: Import OSS Camera HAL Tag: LA.HB.1.3.2-32600-8x96.0 Signed-off-by: Davide Garberi --- .../QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg.h | 539 +++++++++++++++++++++ .../stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h | 55 +++ .../stack/mm-jpeg-interface/inc/mm_jpeg_inlines.h | 127 +++++ .../stack/mm-jpeg-interface/inc/mm_jpeg_ionbuf.h | 105 ++++ .../stack/mm-jpeg-interface/inc/mm_jpeg_mpo.h | 45 ++ 5 files changed, 871 insertions(+) create mode 100644 camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg.h create mode 100644 camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h create mode 100644 camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_inlines.h create mode 100644 camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_ionbuf.h create mode 100644 camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_mpo.h (limited to 'camera/QCamera2/stack/mm-jpeg-interface/inc') diff --git a/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg.h b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg.h new file mode 100644 index 0000000..885a4b8 --- /dev/null +++ b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg.h @@ -0,0 +1,539 @@ +/* Copyright (c) 2012-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. + * + */ + +#ifndef MM_JPEG_H_ +#define MM_JPEG_H_ + +// OpenMAX dependencies +#include "OMX_Types.h" +#include "OMX_Index.h" +#include "OMX_Core.h" +#include "OMX_Component.h" +#include "QOMX_JpegExtensions.h" + +// JPEG dependencies +#include "mm_jpeg_interface.h" +#include "mm_jpeg_ionbuf.h" + +// Camera dependencies +#include "cam_list.h" +#include "cam_semaphore.h" + +#define MM_JPEG_MAX_THREADS 30 +#define MM_JPEG_CIRQ_SIZE 30 +#define MM_JPEG_MAX_SESSION 10 +#define MAX_EXIF_TABLE_ENTRIES 50 +#define MAX_JPEG_SIZE 20000000 +#define MAX_OMX_HANDLES (5) +// Thumbnail src and dest aspect ratio diffrence tolerance +#define ASPECT_TOLERANCE 0.001 + + +/** mm_jpeg_abort_state_t: + * @MM_JPEG_ABORT_NONE: Abort is not issued + * @MM_JPEG_ABORT_INIT: Abort is issued from the client + * @MM_JPEG_ABORT_DONE: Abort is completed + * + * State representing the abort state + **/ +typedef enum { + MM_JPEG_ABORT_NONE, + MM_JPEG_ABORT_INIT, + MM_JPEG_ABORT_DONE, +} mm_jpeg_abort_state_t; + + +/* define max num of supported concurrent jpeg jobs by OMX engine. + * Current, only one per time */ +#define NUM_MAX_JPEG_CNCURRENT_JOBS 2 + +#define JOB_ID_MAGICVAL 0x1 +#define JOB_HIST_MAX 10000 + +/** 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); \ + LOGE("written size %zu", len); \ + fclose(fp); \ + } else { \ + LOGE("open %s failed", 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, paddr2, 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); \ + LOGE("written %zu %zu", len1, len2); \ + fclose(fp); \ + } else { \ + LOGE("open %s failed", filename); \ + } \ +}) + +/** MM_JPEG_CHK_ABORT: + * @p: client pointer + * @ret: return value + * @label: label to jump to + * + * check the abort failure + **/ +#define MM_JPEG_CHK_ABORT(p, ret, label) ({ \ + if (MM_JPEG_ABORT_INIT == p->abort_state) { \ + LOGE("jpeg abort"); \ + ret = OMX_ErrorNone; \ + goto label; \ + } \ +}) + +#define GET_CLIENT_IDX(x) ((x) & 0xff) +#define GET_SESSION_IDX(x) (((x) >> 8) & 0xff) +#define GET_JOB_IDX(x) (((x) >> 16) & 0xff) + +typedef struct { + union { + int i_data[MM_JPEG_CIRQ_SIZE]; + void *p_data[MM_JPEG_CIRQ_SIZE]; + }; + int front; + int rear; + int count; + pthread_mutex_t lock; +} mm_jpeg_cirq_t; + +/** cirq_reset: + * + * Arguments: + * @q: circular queue + * + * Return: + * none + * + * Description: + * Resets the circular queue + * + **/ +static inline void cirq_reset(mm_jpeg_cirq_t *q) +{ + q->front = 0; + q->rear = 0; + q->count = 0; + pthread_mutex_init(&q->lock, NULL); +} + +/** cirq_empty: + * + * Arguments: + * @q: circular queue + * + * Return: + * none + * + * Description: + * check if the curcular queue is empty + * + **/ +#define cirq_empty(q) (q->count == 0) + +/** cirq_full: + * + * Arguments: + * @q: circular queue + * + * Return: + * none + * + * Description: + * check if the curcular queue is full + * + **/ +#define cirq_full(q) (q->count == MM_JPEG_CIRQ_SIZE) + +/** cirq_enqueue: + * + * Arguments: + * @q: circular queue + * @data: data to be inserted + * + * Return: + * true/false + * + * Description: + * enqueue an element into circular queue + * + **/ +#define cirq_enqueue(q, type, data) ({ \ + int rc = 0; \ + pthread_mutex_lock(&q->lock); \ + if (cirq_full(q)) { \ + rc = -1; \ + } else { \ + q->type[q->rear] = data; \ + q->rear = (q->rear + 1) % MM_JPEG_CIRQ_SIZE; \ + q->count++; \ + } \ + pthread_mutex_unlock(&q->lock); \ + rc; \ +}) + +/** cirq_dequeue: + * + * Arguments: + * @q: circular queue + * @data: data to be popped + * + * Return: + * true/false + * + * Description: + * dequeue an element from the circular queue + * + **/ +#define cirq_dequeue(q, type, data) ({ \ + int rc = 0; \ + pthread_mutex_lock(&q->lock); \ + if (cirq_empty(q)) { \ + pthread_mutex_unlock(&q->lock); \ + rc = -1; \ + } else { \ + data = q->type[q->front]; \ + q->count--; \ + } \ + pthread_mutex_unlock(&q->lock); \ + rc; \ +}) + + +typedef union { + uint32_t u32; + void* p; +} mm_jpeg_q_data_t; + + typedef struct { + struct cam_list list; + mm_jpeg_q_data_t data; +} mm_jpeg_q_node_t; + +typedef struct { + mm_jpeg_q_node_t head; /* dummy head */ + uint32_t size; + pthread_mutex_t lock; +} mm_jpeg_queue_t; + +typedef enum { + MM_JPEG_CMD_TYPE_JOB, /* job cmd */ + MM_JPEG_CMD_TYPE_EXIT, /* EXIT cmd for exiting jobMgr thread */ + MM_JPEG_CMD_TYPE_DECODE_JOB, + MM_JPEG_CMD_TYPE_MAX +} mm_jpeg_cmd_type_t; + +typedef struct mm_jpeg_job_session { + uint32_t client_hdl; /* client handler */ + uint32_t jobId; /* job ID */ + uint32_t sessionId; /* session ID */ + mm_jpeg_encode_params_t params; /* encode params */ + mm_jpeg_decode_params_t dec_params; /* encode params */ + mm_jpeg_encode_job_t encode_job; /* job description */ + mm_jpeg_decode_job_t decode_job; + pthread_t encode_pid; /* encode thread handler*/ + + void *jpeg_obj; /* ptr to mm_jpeg_obj */ + jpeg_job_status_t job_status; /* job status */ + + int state_change_pending; /* flag to indicate if state change is pending */ + OMX_ERRORTYPE error_flag; /* variable to indicate error during encoding */ + mm_jpeg_abort_state_t abort_state; /* variable to indicate abort during encoding */ + + /* OMX related */ + OMX_HANDLETYPE omx_handle; /* handle to omx engine */ + OMX_CALLBACKTYPE omx_callbacks; /* callbacks to omx engine */ + + /* buffer headers */ + OMX_BUFFERHEADERTYPE *p_in_omx_buf[MM_JPEG_MAX_BUF]; + OMX_BUFFERHEADERTYPE *p_in_omx_thumb_buf[MM_JPEG_MAX_BUF]; + OMX_BUFFERHEADERTYPE *p_out_omx_buf[MM_JPEG_MAX_BUF]; + OMX_BUFFERHEADERTYPE *p_in_rot_omx_buf[MM_JPEG_MAX_BUF]; + OMX_BUFFERHEADERTYPE *p_in_rot_omx_thumb_buf[MM_JPEG_MAX_BUF]; + + OMX_PARAM_PORTDEFINITIONTYPE inputPort; + OMX_PARAM_PORTDEFINITIONTYPE outputPort; + OMX_PARAM_PORTDEFINITIONTYPE inputTmbPort; + + /* event locks */ + pthread_mutex_t lock; + pthread_cond_t cond; + + QEXIF_INFO_DATA exif_info_local[MAX_EXIF_TABLE_ENTRIES]; //all exif tags for JPEG encoder + int exif_count_local; + + mm_jpeg_cirq_t cb_q; + int32_t ebd_count; + int32_t fbd_count; + + /* this flag represents whether the job is active */ + OMX_BOOL active; + + /* this flag indicates if the configration is complete */ + OMX_BOOL config; + + /* job history count to generate unique id */ + unsigned int job_hist; + + OMX_BOOL encoding; + + buffer_t work_buffer; + /* src rotate ion bufs */ + buffer_t src_rot_ion_buffer[MM_JPEG_MAX_BUF]; + + OMX_EVENTTYPE omxEvent; + int event_pending; + + uint8_t *meta_enc_key; + size_t meta_enc_keylen; + + struct mm_jpeg_job_session *next_session; + + uint32_t curr_out_buf_idx; + + uint32_t num_omx_sessions; + OMX_BOOL auto_out_buf; + + mm_jpeg_queue_t *session_handle_q; + mm_jpeg_queue_t *out_buf_q; + + int thumb_from_main; + uint32_t job_index; + + /* lib2d rotation flag*/ + uint32_t lib2d_rotation_flag; + + /* num of buf for input src rotation */ + uint32_t num_src_rot_bufs; + + /* src rotate img bufs */ + mm_jpeg_buf_t src_rot_main_buf[MM_JPEG_MAX_BUF]; + + /* lib2d handle*/ + void *lib2d_handle; +} mm_jpeg_job_session_t; + +typedef struct { + mm_jpeg_encode_job_t encode_job; + uint32_t job_id; + uint32_t client_handle; +} mm_jpeg_encode_job_info_t; + +typedef struct { + mm_jpeg_decode_job_t decode_job; + uint32_t job_id; + uint32_t client_handle; +} mm_jpeg_decode_job_info_t; + +typedef struct { + mm_jpeg_cmd_type_t type; + union { + mm_jpeg_encode_job_info_t enc_info; + mm_jpeg_decode_job_info_t dec_info; + }; +} mm_jpeg_job_q_node_t; + +typedef struct { + uint8_t is_used; /* flag: if is a valid client */ + uint32_t client_handle; /* client handle */ + mm_jpeg_job_session_t session[MM_JPEG_MAX_SESSION]; + pthread_mutex_t lock; /* job lock */ +} mm_jpeg_client_t; + +typedef struct { + pthread_t pid; /* job cmd thread ID */ + cam_semaphore_t job_sem; /* semaphore for job cmd thread */ + mm_jpeg_queue_t job_queue; /* queue for job to do */ +} mm_jpeg_job_cmd_thread_t; + +#define MAX_JPEG_CLIENT_NUM 8 +typedef struct mm_jpeg_obj_t { + /* ClientMgr */ + int num_clients; /* num of clients */ + mm_jpeg_client_t clnt_mgr[MAX_JPEG_CLIENT_NUM]; /* client manager */ + + /* JobMkr */ + pthread_mutex_t job_lock; /* job lock */ + mm_jpeg_job_cmd_thread_t job_mgr; /* job mgr thread including todo_q*/ + mm_jpeg_queue_t ongoing_job_q; /* queue for ongoing jobs */ + buffer_t ionBuffer[MM_JPEG_CONCURRENT_SESSIONS_COUNT]; + + + /* Max pic dimension for work buf calc*/ + uint32_t max_pic_w; + uint32_t max_pic_h; +#ifdef LOAD_ADSP_RPC_LIB + void *adsprpc_lib_handle; +#endif + + uint32_t work_buf_cnt; + + uint32_t num_sessions; + uint32_t reuse_reproc_buffer; + + cam_jpeg_metadata_t *jpeg_metadata; + + /* Pointer to the session in progress*/ + mm_jpeg_job_session_t *p_session_inprogress; + + // dummy OMX handle + OMX_HANDLETYPE dummy_handle; +} mm_jpeg_obj; + +/** mm_jpeg_pending_func_t: + * + * Intermediate function for transition change + **/ +typedef OMX_ERRORTYPE (*mm_jpeg_transition_func_t)(void *); + +extern int32_t mm_jpeg_init(mm_jpeg_obj *my_obj); +extern int32_t mm_jpeg_deinit(mm_jpeg_obj *my_obj); +extern uint32_t mm_jpeg_new_client(mm_jpeg_obj *my_obj); +extern int32_t mm_jpeg_start_job(mm_jpeg_obj *my_obj, + mm_jpeg_job_t* job, + uint32_t* jobId); +extern int32_t mm_jpeg_abort_job(mm_jpeg_obj *my_obj, + uint32_t jobId); +extern int32_t mm_jpeg_close(mm_jpeg_obj *my_obj, + uint32_t client_hdl); +extern int32_t mm_jpeg_create_session(mm_jpeg_obj *my_obj, + uint32_t client_hdl, + mm_jpeg_encode_params_t *p_params, + uint32_t* p_session_id); +extern int32_t mm_jpeg_destroy_session_by_id(mm_jpeg_obj *my_obj, + uint32_t session_id); + +extern int32_t mm_jpegdec_init(mm_jpeg_obj *my_obj); +extern int32_t mm_jpegdec_deinit(mm_jpeg_obj *my_obj); +extern int32_t mm_jpeg_jobmgr_thread_release(mm_jpeg_obj * my_obj); +extern int32_t mm_jpeg_jobmgr_thread_launch(mm_jpeg_obj *my_obj); +extern int32_t mm_jpegdec_start_decode_job(mm_jpeg_obj *my_obj, + mm_jpeg_job_t* job, + uint32_t* jobId); + +extern int32_t mm_jpegdec_create_session(mm_jpeg_obj *my_obj, + uint32_t client_hdl, + mm_jpeg_decode_params_t *p_params, + uint32_t* p_session_id); + +extern int32_t mm_jpegdec_destroy_session_by_id(mm_jpeg_obj *my_obj, + uint32_t session_id); + +extern int32_t mm_jpegdec_abort_job(mm_jpeg_obj *my_obj, + uint32_t jobId); + +int32_t mm_jpegdec_process_decoding_job(mm_jpeg_obj *my_obj, + mm_jpeg_job_q_node_t* job_node); + +/* utiltity fucntion declared in mm-camera-inteface2.c + * and need be used by mm-camera and below*/ +uint32_t mm_jpeg_util_generate_handler(uint8_t index); +uint8_t mm_jpeg_util_get_index_by_handler(uint32_t handler); + +/* basic queue functions */ +extern int32_t mm_jpeg_queue_init(mm_jpeg_queue_t* queue); +extern int32_t mm_jpeg_queue_enq(mm_jpeg_queue_t* queue, + mm_jpeg_q_data_t data); +extern int32_t mm_jpeg_queue_enq_head(mm_jpeg_queue_t* queue, + mm_jpeg_q_data_t data); +extern mm_jpeg_q_data_t mm_jpeg_queue_deq(mm_jpeg_queue_t* queue); +extern int32_t mm_jpeg_queue_deinit(mm_jpeg_queue_t* queue); +extern int32_t mm_jpeg_queue_flush(mm_jpeg_queue_t* queue); +extern uint32_t mm_jpeg_queue_get_size(mm_jpeg_queue_t* queue); +extern mm_jpeg_q_data_t mm_jpeg_queue_peek(mm_jpeg_queue_t* queue); +extern int32_t addExifEntry(QOMX_EXIF_INFO *p_exif_info, exif_tag_id_t tagid, + exif_tag_type_t type, uint32_t count, void *data); +extern int32_t releaseExifEntry(QEXIF_INFO_DATA *p_exif_data); +extern int process_meta_data(metadata_buffer_t *p_meta, + QOMX_EXIF_INFO *exif_info, mm_jpeg_exif_params_t *p_cam3a_params, + cam_hal_version_t hal_version); + +OMX_ERRORTYPE mm_jpeg_session_change_state(mm_jpeg_job_session_t* p_session, + OMX_STATETYPE new_state, + mm_jpeg_transition_func_t p_exec); + +int map_jpeg_format(mm_jpeg_color_format color_fmt); + +OMX_BOOL mm_jpeg_session_abort(mm_jpeg_job_session_t *p_session); +/** + * + * special queue functions for job queue + **/ +mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_client_id( + mm_jpeg_queue_t* queue, uint32_t client_hdl); +mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_job_id( + mm_jpeg_queue_t* queue, uint32_t job_id); +mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_session_id( + mm_jpeg_queue_t* queue, uint32_t session_id); +mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_unlk( + mm_jpeg_queue_t* queue, uint32_t job_id); + + +/** mm_jpeg_queue_func_t: + * + * Intermediate function for queue operation + **/ +typedef void (*mm_jpeg_queue_func_t)(void *); + +/** mm_jpeg_exif_flash_mode: + * + * Exif flash mode values + **/ +typedef enum { + MM_JPEG_EXIF_FLASH_MODE_ON = 0x1, + MM_JPEG_EXIF_FLASH_MODE_OFF = 0x2, + MM_JPEG_EXIF_FLASH_MODE_AUTO = 0x3, + MM_JPEG_EXIF_FLASH_MODE_MAX +} mm_jpeg_exif_flash_mode; + +#endif /* MM_JPEG_H_ */ + + diff --git a/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h new file mode 100644 index 0000000..2269537 --- /dev/null +++ b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_dbg.h @@ -0,0 +1,55 @@ +/* Copyright (c) 2012-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. + * + */ + +#ifndef __MM_JPEG_DBG_H__ +#define __MM_JPEG_DBG_H__ + +#ifdef QCAMERA_REDEFINE_LOG +#define CAM_MODULE CAM_JPEG_MODULE +#include "mm_camera_dbg.h" +#endif + +extern volatile uint32_t gKpiDebugLevel; + +#ifndef KPI_DEBUG +#define KPI_DEBUG +#define ATRACE_TAG ATRACE_TAG_CAMERA +#include + +#define KPI_APT 1 +#define KPI_DBG 2 + +#define KPI_ATRACE_INT(name,val) ({\ +if (gKpiDebugLevel >= KPI_APT) { \ + atrace_int(ATRACE_TAG, name, val); \ +}\ +}) + +#endif +#endif /* __MM_JPEG_DBG_H__ */ diff --git a/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_inlines.h b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_inlines.h new file mode 100644 index 0000000..d2ca63d --- /dev/null +++ b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_inlines.h @@ -0,0 +1,127 @@ +/* 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. + * + */ + +#ifndef MM_JPEG_INLINES_H_ +#define MM_JPEG_INLINES_H_ + +// JPEG dependencies +#include "mm_jpeg.h" + +/** mm_jpeg_get_session: + * + * Arguments: + * @my_obj: jpeg object + * @client_idx: client index + * + * Return: + * job index + * + * Description: + * Get job index by client id + * + **/ +static inline mm_jpeg_job_session_t *mm_jpeg_get_session(mm_jpeg_obj *my_obj, uint32_t job_id) +{ + mm_jpeg_job_session_t *p_session = NULL; + int client_idx = GET_CLIENT_IDX(job_id); + int session_idx= GET_SESSION_IDX(job_id); + + LOGD("client_idx %d session_idx %d", + client_idx, session_idx); + if ((session_idx >= MM_JPEG_MAX_SESSION) || + (client_idx >= MAX_JPEG_CLIENT_NUM)) { + LOGE("invalid job id %x", + job_id); + return NULL; + } + pthread_mutex_lock(&my_obj->clnt_mgr[client_idx].lock); + p_session = &my_obj->clnt_mgr[client_idx].session[session_idx]; + pthread_mutex_unlock(&my_obj->clnt_mgr[client_idx].lock); + return p_session; +} + +/** mm_jpeg_get_job_idx: + * + * Arguments: + * @my_obj: jpeg object + * @client_idx: client index + * + * Return: + * job index + * + * Description: + * Get job index by client id + * + **/ +static inline int mm_jpeg_get_new_session_idx(mm_jpeg_obj *my_obj, int client_idx, + mm_jpeg_job_session_t **pp_session) +{ + int i = 0; + int index = -1; + for (i = 0; i < MM_JPEG_MAX_SESSION; i++) { + pthread_mutex_lock(&my_obj->clnt_mgr[client_idx].lock); + if (!my_obj->clnt_mgr[client_idx].session[i].active) { + *pp_session = &my_obj->clnt_mgr[client_idx].session[i]; + my_obj->clnt_mgr[client_idx].session[i].active = OMX_TRUE; + index = i; + pthread_mutex_unlock(&my_obj->clnt_mgr[client_idx].lock); + break; + } + pthread_mutex_unlock(&my_obj->clnt_mgr[client_idx].lock); + } + return index; +} + +/** mm_jpeg_get_job_idx: + * + * Arguments: + * @my_obj: jpeg object + * @client_idx: client index + * + * Return: + * job index + * + * Description: + * Get job index by client id + * + **/ +static inline void mm_jpeg_remove_session_idx(mm_jpeg_obj *my_obj, uint32_t job_id) +{ + int client_idx = GET_CLIENT_IDX(job_id); + int session_idx= GET_SESSION_IDX(job_id); + LOGD("client_idx %d session_idx %d", + client_idx, session_idx); + pthread_mutex_lock(&my_obj->clnt_mgr[client_idx].lock); + my_obj->clnt_mgr[client_idx].session[session_idx].active = OMX_FALSE; + pthread_mutex_unlock(&my_obj->clnt_mgr[client_idx].lock); +} + + + +#endif /* MM_JPEG_INLINES_H_ */ diff --git a/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_ionbuf.h b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_ionbuf.h new file mode 100644 index 0000000..96b70d9 --- /dev/null +++ b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_ionbuf.h @@ -0,0 +1,105 @@ +/* Copyright (c) 2013-2014, 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. + * + */ + +#ifndef __MM_JPEG_IONBUF_H__ +#define __MM_JPEG_IONBUF_H__ + +// System dependencies +#include + +// JPEG dependencies +#include "mm_jpeg_dbg.h" + +typedef struct { + struct ion_fd_data ion_info_fd; + struct ion_allocation_data alloc; + int p_pmem_fd; + size_t size; + int ion_fd; + uint8_t *addr; +} buffer_t; + +/** buffer_allocate: + * + * Arguments: + * @p_buffer: ION buffer + * + * Return: + * buffer address + * + * Description: + * allocates ION buffer + * + **/ +void* buffer_allocate(buffer_t *p_buffer, int cached); + +/** buffer_deallocate: + * + * Arguments: + * @p_buffer: ION buffer + * + * Return: + * error val + * + * Description: + * deallocates ION buffer + * + **/ +int buffer_deallocate(buffer_t *p_buffer); + +/** buffer_invalidate: + * + * Arguments: + * @p_buffer: ION buffer + * + * Return: + * error val + * + * Description: + * Invalidates the cached buffer + * + **/ +int buffer_invalidate(buffer_t *p_buffer); + +/** buffer_clean: + * + * Arguments: + * @p_buffer: ION buffer + * + * Return: + * error val + * + * Description: + * clean the cached buffer + * + **/ +int buffer_clean(buffer_t *p_buffer); + +#endif + diff --git a/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_mpo.h b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_mpo.h new file mode 100644 index 0000000..6e8424c --- /dev/null +++ b/camera/QCamera2/stack/mm-jpeg-interface/inc/mm_jpeg_mpo.h @@ -0,0 +1,45 @@ +/* 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. + * + */ + +#ifndef MM_JPEG_MPO_H_ +#define MM_JPEG_MPO_H_ + +// JPEG dependencies +#include "mm_jpeg_interface.h" +#include "qmpo.h" + +#define TRUE 1 +#define FALSE 0 + +extern int mm_jpeg_mpo_compose(mm_jpeg_mpo_info_t *mpo_info); + +extern int get_mpo_size(mm_jpeg_output_t jpeg_buffer[MM_JPEG_MAX_MPO_IMAGES], + int num_of_images); + +#endif -- cgit v1.2.3