1 /* Copyright (c) 2012-2014, The Linux Foundation. All rights reserved. 2 * 3 * Redistribution and use in source and binary forms, with or without 4 * modification, are permitted provided that the following conditions are 5 * met: 6 * * Redistributions of source code must retain the above copyright 7 * notice, this list of conditions and the following disclaimer. 8 * * Redistributions in binary form must reproduce the above 9 * copyright notice, this list of conditions and the following 10 * disclaimer in the documentation and/or other materials provided 11 * with the distribution. 12 * * Neither the name of The Linux Foundation nor the names of its 13 * contributors may be used to endorse or promote products derived 14 * from this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 23 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 25 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 26 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 * 28 */ 29 30 #ifndef MM_JPEG_H_ 31 #define MM_JPEG_H_ 32 33 #include <cam_semaphore.h> 34 #include "mm_jpeg_interface.h" 35 #include "cam_list.h" 36 #include "OMX_Types.h" 37 #include "OMX_Index.h" 38 #include "OMX_Core.h" 39 #include "OMX_Component.h" 40 #include "QOMX_JpegExtensions.h" 41 #include "mm_jpeg_ionbuf.h" 42 43 #define MM_JPEG_MAX_THREADS 30 44 #define MM_JPEG_CIRQ_SIZE 30 45 #define MM_JPEG_MAX_SESSION 10 46 #define MAX_EXIF_TABLE_ENTRIES 50 47 #define MAX_JPEG_SIZE 20000000 48 #define MAX_OMX_HANDLES (5) 49 #define ASPECT_TOLERANCE 0.001 50 51 52 /** mm_jpeg_abort_state_t: 53 * @MM_JPEG_ABORT_NONE: Abort is not issued 54 * @MM_JPEG_ABORT_INIT: Abort is issued from the client 55 * @MM_JPEG_ABORT_DONE: Abort is completed 56 * 57 * State representing the abort state 58 **/ 59 typedef enum { 60 MM_JPEG_ABORT_NONE, 61 MM_JPEG_ABORT_INIT, 62 MM_JPEG_ABORT_DONE, 63 } mm_jpeg_abort_state_t; 64 65 66 /* define max num of supported concurrent jpeg jobs by OMX engine. 67 * Current, only one per time */ 68 #define NUM_MAX_JPEG_CNCURRENT_JOBS 2 69 70 #define JOB_ID_MAGICVAL 0x1 71 #define JOB_HIST_MAX 10000 72 73 /** DUMP_TO_FILE: 74 * @filename: file name 75 * @p_addr: address of the buffer 76 * @len: buffer length 77 * 78 * dump the image to the file 79 **/ 80 #define DUMP_TO_FILE(filename, p_addr, len) ({ \ 81 size_t rc = 0; \ 82 FILE *fp = fopen(filename, "w+"); \ 83 if (fp) { \ 84 rc = fwrite(p_addr, 1, len, fp); \ 85 CDBG_ERROR("%s:%d] written size %zu", __func__, __LINE__, len); \ 86 fclose(fp); \ 87 } else { \ 88 CDBG_ERROR("%s:%d] open %s failed", __func__, __LINE__, filename); \ 89 } \ 90 }) 91 92 /** DUMP_TO_FILE2: 93 * @filename: file name 94 * @p_addr: address of the buffer 95 * @len: buffer length 96 * 97 * dump the image to the file if the memory is non-contiguous 98 **/ 99 #define DUMP_TO_FILE2(filename, p_addr1, len1, paddr2, len2) ({ \ 100 size_t rc = 0; \ 101 FILE *fp = fopen(filename, "w+"); \ 102 if (fp) { \ 103 rc = fwrite(p_addr1, 1, len1, fp); \ 104 rc = fwrite(p_addr2, 1, len2, fp); \ 105 CDBG_ERROR("%s:%d] written %zu %zu", __func__, __LINE__, len1, len2); \ 106 fclose(fp); \ 107 } else { \ 108 CDBG_ERROR("%s:%d] open %s failed", __func__, __LINE__, filename); \ 109 } \ 110 }) 111 112 /** MM_JPEG_CHK_ABORT: 113 * @p: client pointer 114 * @ret: return value 115 * @label: label to jump to 116 * 117 * check the abort failure 118 **/ 119 #define MM_JPEG_CHK_ABORT(p, ret, label) ({ \ 120 if (MM_JPEG_ABORT_INIT == p->abort_state) { \ 121 CDBG_ERROR("%s:%d] jpeg abort", __func__, __LINE__); \ 122 ret = OMX_ErrorNone; \ 123 goto label; \ 124 } \ 125 }) 126 127 #define GET_CLIENT_IDX(x) ((x) & 0xff) 128 #define GET_SESSION_IDX(x) (((x) >> 8) & 0xff) 129 #define GET_JOB_IDX(x) (((x) >> 16) & 0xff) 130 131 typedef struct { 132 union { 133 int i_data[MM_JPEG_CIRQ_SIZE]; 134 void *p_data[MM_JPEG_CIRQ_SIZE]; 135 }; 136 int front; 137 int rear; 138 int count; 139 pthread_mutex_t lock; 140 } mm_jpeg_cirq_t; 141 142 /** cirq_reset: 143 * 144 * Arguments: 145 * @q: circular queue 146 * 147 * Return: 148 * none 149 * 150 * Description: 151 * Resets the circular queue 152 * 153 **/ 154 static inline void cirq_reset(mm_jpeg_cirq_t *q) 155 { 156 q->front = 0; 157 q->rear = 0; 158 q->count = 0; 159 pthread_mutex_init(&q->lock, NULL); 160 } 161 162 /** cirq_empty: 163 * 164 * Arguments: 165 * @q: circular queue 166 * 167 * Return: 168 * none 169 * 170 * Description: 171 * check if the curcular queue is empty 172 * 173 **/ 174 #define cirq_empty(q) (q->count == 0) 175 176 /** cirq_full: 177 * 178 * Arguments: 179 * @q: circular queue 180 * 181 * Return: 182 * none 183 * 184 * Description: 185 * check if the curcular queue is full 186 * 187 **/ 188 #define cirq_full(q) (q->count == MM_JPEG_CIRQ_SIZE) 189 190 /** cirq_enqueue: 191 * 192 * Arguments: 193 * @q: circular queue 194 * @data: data to be inserted 195 * 196 * Return: 197 * true/false 198 * 199 * Description: 200 * enqueue an element into circular queue 201 * 202 **/ 203 #define cirq_enqueue(q, type, data) ({ \ 204 int rc = 0; \ 205 pthread_mutex_lock(&q->lock); \ 206 if (cirq_full(q)) { \ 207 rc = -1; \ 208 } else { \ 209 q->type[q->rear] = data; \ 210 q->rear = (q->rear + 1) % MM_JPEG_CIRQ_SIZE; \ 211 q->count++; \ 212 } \ 213 pthread_mutex_unlock(&q->lock); \ 214 rc; \ 215 }) 216 217 /** cirq_dequeue: 218 * 219 * Arguments: 220 * @q: circular queue 221 * @data: data to be popped 222 * 223 * Return: 224 * true/false 225 * 226 * Description: 227 * dequeue an element from the circular queue 228 * 229 **/ 230 #define cirq_dequeue(q, type, data) ({ \ 231 int rc = 0; \ 232 pthread_mutex_lock(&q->lock); \ 233 if (cirq_empty(q)) { \ 234 pthread_mutex_unlock(&q->lock); \ 235 rc = -1; \ 236 } else { \ 237 data = q->type[q->front]; \ 238 q->count--; \ 239 } \ 240 pthread_mutex_unlock(&q->lock); \ 241 rc; \ 242 }) 243 244 245 typedef union { 246 uint32_t u32; 247 void* p; 248 } mm_jpeg_q_data_t; 249 250 typedef struct { 251 struct cam_list list; 252 mm_jpeg_q_data_t data; 253 } mm_jpeg_q_node_t; 254 255 typedef struct { 256 mm_jpeg_q_node_t head; /* dummy head */ 257 uint32_t size; 258 pthread_mutex_t lock; 259 } mm_jpeg_queue_t; 260 261 typedef enum { 262 MM_JPEG_CMD_TYPE_JOB, /* job cmd */ 263 MM_JPEG_CMD_TYPE_EXIT, /* EXIT cmd for exiting jobMgr thread */ 264 MM_JPEG_CMD_TYPE_DECODE_JOB, 265 MM_JPEG_CMD_TYPE_MAX 266 } mm_jpeg_cmd_type_t; 267 268 typedef struct mm_jpeg_job_session { 269 uint32_t client_hdl; /* client handler */ 270 uint32_t jobId; /* job ID */ 271 uint32_t sessionId; /* session ID */ 272 mm_jpeg_encode_params_t params; /* encode params */ 273 mm_jpeg_decode_params_t dec_params; /* encode params */ 274 mm_jpeg_encode_job_t encode_job; /* job description */ 275 mm_jpeg_decode_job_t decode_job; 276 pthread_t encode_pid; /* encode thread handler*/ 277 278 void *jpeg_obj; /* ptr to mm_jpeg_obj */ 279 jpeg_job_status_t job_status; /* job status */ 280 281 int state_change_pending; /* flag to indicate if state change is pending */ 282 OMX_ERRORTYPE error_flag; /* variable to indicate error during encoding */ 283 mm_jpeg_abort_state_t abort_state; /* variable to indicate abort during encoding */ 284 285 /* OMX related */ 286 OMX_HANDLETYPE omx_handle; /* handle to omx engine */ 287 OMX_CALLBACKTYPE omx_callbacks; /* callbacks to omx engine */ 288 289 /* buffer headers */ 290 OMX_BUFFERHEADERTYPE *p_in_omx_buf[MM_JPEG_MAX_BUF]; 291 OMX_BUFFERHEADERTYPE *p_in_omx_thumb_buf[MM_JPEG_MAX_BUF]; 292 OMX_BUFFERHEADERTYPE *p_out_omx_buf[MM_JPEG_MAX_BUF]; 293 294 OMX_PARAM_PORTDEFINITIONTYPE inputPort; 295 OMX_PARAM_PORTDEFINITIONTYPE outputPort; 296 OMX_PARAM_PORTDEFINITIONTYPE inputTmbPort; 297 298 /* event locks */ 299 pthread_mutex_t lock; 300 pthread_cond_t cond; 301 302 QEXIF_INFO_DATA exif_info_local[MAX_EXIF_TABLE_ENTRIES]; //all exif tags for JPEG encoder 303 int exif_count_local; 304 305 mm_jpeg_cirq_t cb_q; 306 int32_t ebd_count; 307 int32_t fbd_count; 308 309 /* this flag represents whether the job is active */ 310 OMX_BOOL active; 311 312 /* this flag indicates if the configration is complete */ 313 OMX_BOOL config; 314 315 /* job history count to generate unique id */ 316 unsigned int job_hist; 317 318 OMX_BOOL encoding; 319 320 buffer_t work_buffer; 321 322 OMX_EVENTTYPE omxEvent; 323 int event_pending; 324 325 uint8_t *meta_enc_key; 326 size_t meta_enc_keylen; 327 328 struct mm_jpeg_job_session *next_session; 329 330 uint32_t curr_out_buf_idx; 331 332 uint32_t num_omx_sessions; 333 OMX_BOOL auto_out_buf; 334 335 mm_jpeg_queue_t *session_handle_q; 336 mm_jpeg_queue_t *out_buf_q; 337 338 int thumb_from_main; 339 uint32_t job_index; 340 } mm_jpeg_job_session_t; 341 342 typedef struct { 343 mm_jpeg_encode_job_t encode_job; 344 uint32_t job_id; 345 uint32_t client_handle; 346 } mm_jpeg_encode_job_info_t; 347 348 typedef struct { 349 mm_jpeg_decode_job_t decode_job; 350 uint32_t job_id; 351 uint32_t client_handle; 352 } mm_jpeg_decode_job_info_t; 353 354 typedef struct { 355 mm_jpeg_cmd_type_t type; 356 union { 357 mm_jpeg_encode_job_info_t enc_info; 358 mm_jpeg_decode_job_info_t dec_info; 359 }; 360 } mm_jpeg_job_q_node_t; 361 362 typedef struct { 363 uint8_t is_used; /* flag: if is a valid client */ 364 uint32_t client_handle; /* client handle */ 365 mm_jpeg_job_session_t session[MM_JPEG_MAX_SESSION]; 366 pthread_mutex_t lock; /* job lock */ 367 } mm_jpeg_client_t; 368 369 typedef struct { 370 pthread_t pid; /* job cmd thread ID */ 371 cam_semaphore_t job_sem; /* semaphore for job cmd thread */ 372 mm_jpeg_queue_t job_queue; /* queue for job to do */ 373 } mm_jpeg_job_cmd_thread_t; 374 375 #define MAX_JPEG_CLIENT_NUM 8 376 typedef struct mm_jpeg_obj_t { 377 /* ClientMgr */ 378 int num_clients; /* num of clients */ 379 mm_jpeg_client_t clnt_mgr[MAX_JPEG_CLIENT_NUM]; /* client manager */ 380 381 /* JobMkr */ 382 pthread_mutex_t job_lock; /* job lock */ 383 mm_jpeg_job_cmd_thread_t job_mgr; /* job mgr thread including todo_q*/ 384 mm_jpeg_queue_t ongoing_job_q; /* queue for ongoing jobs */ 385 buffer_t ionBuffer[MM_JPEG_CONCURRENT_SESSIONS_COUNT]; 386 387 388 /* Max pic dimension for work buf calc*/ 389 uint32_t max_pic_w; 390 uint32_t max_pic_h; 391 #ifdef LOAD_ADSP_RPC_LIB 392 void *adsprpc_lib_handle; 393 #endif 394 395 uint32_t work_buf_cnt; 396 397 uint32_t num_sessions; 398 399 } mm_jpeg_obj; 400 401 /** mm_jpeg_pending_func_t: 402 * 403 * Intermediate function for transition change 404 **/ 405 typedef OMX_ERRORTYPE (*mm_jpeg_transition_func_t)(void *); 406 407 extern int32_t mm_jpeg_init(mm_jpeg_obj *my_obj); 408 extern int32_t mm_jpeg_deinit(mm_jpeg_obj *my_obj); 409 extern uint32_t mm_jpeg_new_client(mm_jpeg_obj *my_obj); 410 extern int32_t mm_jpeg_start_job(mm_jpeg_obj *my_obj, 411 mm_jpeg_job_t* job, 412 uint32_t* jobId); 413 extern int32_t mm_jpeg_abort_job(mm_jpeg_obj *my_obj, 414 uint32_t jobId); 415 extern int32_t mm_jpeg_close(mm_jpeg_obj *my_obj, 416 uint32_t client_hdl); 417 extern int32_t mm_jpeg_create_session(mm_jpeg_obj *my_obj, 418 uint32_t client_hdl, 419 mm_jpeg_encode_params_t *p_params, 420 uint32_t* p_session_id); 421 extern int32_t mm_jpeg_destroy_session_by_id(mm_jpeg_obj *my_obj, 422 uint32_t session_id); 423 424 extern int32_t mm_jpegdec_init(mm_jpeg_obj *my_obj); 425 extern int32_t mm_jpegdec_deinit(mm_jpeg_obj *my_obj); 426 extern int32_t mm_jpeg_jobmgr_thread_release(mm_jpeg_obj * my_obj); 427 extern int32_t mm_jpeg_jobmgr_thread_launch(mm_jpeg_obj *my_obj); 428 extern int32_t mm_jpegdec_start_decode_job(mm_jpeg_obj *my_obj, 429 mm_jpeg_job_t* job, 430 uint32_t* jobId); 431 432 extern int32_t mm_jpegdec_create_session(mm_jpeg_obj *my_obj, 433 uint32_t client_hdl, 434 mm_jpeg_decode_params_t *p_params, 435 uint32_t* p_session_id); 436 437 extern int32_t mm_jpegdec_destroy_session_by_id(mm_jpeg_obj *my_obj, 438 uint32_t session_id); 439 440 extern int32_t mm_jpegdec_abort_job(mm_jpeg_obj *my_obj, 441 uint32_t jobId); 442 443 int32_t mm_jpegdec_process_decoding_job(mm_jpeg_obj *my_obj, 444 mm_jpeg_job_q_node_t* job_node); 445 446 /* utiltity fucntion declared in mm-camera-inteface2.c 447 * and need be used by mm-camera and below*/ 448 uint32_t mm_jpeg_util_generate_handler(uint8_t index); 449 uint8_t mm_jpeg_util_get_index_by_handler(uint32_t handler); 450 451 /* basic queue functions */ 452 extern int32_t mm_jpeg_queue_init(mm_jpeg_queue_t* queue); 453 extern int32_t mm_jpeg_queue_enq(mm_jpeg_queue_t* queue, 454 mm_jpeg_q_data_t data); 455 extern int32_t mm_jpeg_queue_enq_head(mm_jpeg_queue_t* queue, 456 mm_jpeg_q_data_t data); 457 extern mm_jpeg_q_data_t mm_jpeg_queue_deq(mm_jpeg_queue_t* queue); 458 extern int32_t mm_jpeg_queue_deinit(mm_jpeg_queue_t* queue); 459 extern int32_t mm_jpeg_queue_flush(mm_jpeg_queue_t* queue); 460 extern uint32_t mm_jpeg_queue_get_size(mm_jpeg_queue_t* queue); 461 extern mm_jpeg_q_data_t mm_jpeg_queue_peek(mm_jpeg_queue_t* queue); 462 extern int32_t addExifEntry(QOMX_EXIF_INFO *p_exif_info, exif_tag_id_t tagid, 463 exif_tag_type_t type, uint32_t count, void *data); 464 extern int32_t releaseExifEntry(QEXIF_INFO_DATA *p_exif_data); 465 extern int process_meta_data(metadata_buffer_t *p_meta, 466 QOMX_EXIF_INFO *exif_info, mm_jpeg_exif_params_t *p_cam3a_params, 467 cam_hal_version_t hal_version); 468 469 OMX_ERRORTYPE mm_jpeg_session_change_state(mm_jpeg_job_session_t* p_session, 470 OMX_STATETYPE new_state, 471 mm_jpeg_transition_func_t p_exec); 472 473 int map_jpeg_format(mm_jpeg_color_format color_fmt); 474 475 OMX_BOOL mm_jpeg_session_abort(mm_jpeg_job_session_t *p_session); 476 /** 477 * 478 * special queue functions for job queue 479 **/ 480 mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_client_id( 481 mm_jpeg_queue_t* queue, uint32_t client_hdl); 482 mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_job_id( 483 mm_jpeg_queue_t* queue, uint32_t job_id); 484 mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_by_session_id( 485 mm_jpeg_queue_t* queue, uint32_t session_id); 486 mm_jpeg_job_q_node_t* mm_jpeg_queue_remove_job_unlk( 487 mm_jpeg_queue_t* queue, uint32_t job_id); 488 489 490 /** mm_jpeg_queue_func_t: 491 * 492 * Intermediate function for queue operation 493 **/ 494 typedef void (*mm_jpeg_queue_func_t)(void *); 495 496 /** mm_jpeg_exif_flash_mode: 497 * 498 * Exif flash mode values 499 **/ 500 typedef enum { 501 MM_JPEG_EXIF_FLASH_MODE_ON = 0x1, 502 MM_JPEG_EXIF_FLASH_MODE_OFF = 0x2, 503 MM_JPEG_EXIF_FLASH_MODE_AUTO = 0x3, 504 MM_JPEG_EXIF_FLASH_MODE_MAX 505 } mm_jpeg_exif_flash_mode; 506 507 #endif /* MM_JPEG_H_ */ 508 509 510
