mm_camera.h revision 6f83d735d8e3b918da42e6b559fcd0efb78133e5
1/* Copyright (c) 2012-2013, 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_CAMERA_H__ 31#define __MM_CAMERA_H__ 32 33#include <cam_semaphore.h> 34 35#include "mm_camera_interface.h" 36 37/********************************************************************************** 38* Data structure declare 39***********************************************************************************/ 40/* num of callbacks allowed for an event type */ 41#define MM_CAMERA_EVT_ENTRY_MAX 4 42/* num of data callbacks allowed in a stream obj */ 43#define MM_CAMERA_STREAM_BUF_CB_MAX 4 44/* num of data poll threads allowed in a channel obj */ 45#define MM_CAMERA_CHANNEL_POLL_THREAD_MAX 1 46 47#define MM_CAMERA_DEV_NAME_LEN 32 48#define MM_CAMERA_DEV_OPEN_TRIES 2 49#define MM_CAMERA_DEV_OPEN_RETRY_SLEEP 20 50 51#ifndef TRUE 52#define TRUE 1 53#endif 54 55#ifndef FALSE 56#define FALSE 0 57#endif 58 59struct mm_channel; 60struct mm_stream; 61struct mm_camera_obj; 62 63typedef enum 64{ 65 MM_CAMERA_CMD_TYPE_DATA_CB, /* dataB CMD */ 66 MM_CAMERA_CMD_TYPE_EVT_CB, /* evtCB CMD */ 67 MM_CAMERA_CMD_TYPE_EXIT, /* EXIT */ 68 MM_CAMERA_CMD_TYPE_REQ_DATA_CB,/* request data */ 69 MM_CAMERA_CMD_TYPE_SUPER_BUF_DATA_CB, /* superbuf dataB CMD */ 70 MM_CAMERA_CMD_TYPE_FLUSH_QUEUE, /* flush queue */ 71 MM_CAMERA_CMD_TYPE_MAX 72} mm_camera_cmdcb_type_t; 73 74typedef struct { 75 uint32_t stream_id; 76 uint32_t frame_idx; 77 mm_camera_buf_def_t *buf; /* ref to buf */ 78} mm_camera_buf_info_t; 79 80typedef struct { 81 uint32_t num_buf_requested; 82} mm_camera_req_buf_t; 83 84typedef struct { 85 mm_camera_cmdcb_type_t cmd_type; 86 union { 87 mm_camera_buf_info_t buf; /* frame buf if dataCB */ 88 mm_camera_event_t evt; /* evt if evtCB */ 89 mm_camera_super_buf_t superbuf; /* superbuf if superbuf dataCB*/ 90 mm_camera_req_buf_t req_buf; /* num of buf requested */ 91 uint32_t frame_idx; /* frame idx boundary for flush superbuf queue*/ 92 } u; 93} mm_camera_cmdcb_t; 94 95typedef void (*mm_camera_cmd_cb_t)(mm_camera_cmdcb_t * cmd_cb, void* user_data); 96 97typedef struct { 98 cam_queue_t cmd_queue; /* cmd queue (queuing dataCB, asyncCB, or exitCMD) */ 99 pthread_t cmd_pid; /* cmd thread ID */ 100 cam_semaphore_t cmd_sem; /* semaphore for cmd thread */ 101 mm_camera_cmd_cb_t cb; /* cb for cmd */ 102 void* user_data; /* user_data for cb */ 103} mm_camera_cmd_thread_t; 104 105typedef enum { 106 MM_CAMERA_POLL_TYPE_EVT, 107 MM_CAMERA_POLL_TYPE_DATA, 108 MM_CAMERA_POLL_TYPE_MAX 109} mm_camera_poll_thread_type_t; 110 111/* function ptr defined for poll notify CB, 112 * registered at poll thread with poll fd */ 113typedef void (*mm_camera_poll_notify_t)(void *user_data); 114 115typedef struct { 116 int32_t fd; 117 mm_camera_poll_notify_t notify_cb; 118 uint32_t handler; 119 void* user_data; 120} mm_camera_poll_entry_t; 121 122typedef struct { 123 mm_camera_poll_thread_type_t poll_type; 124 /* array to store poll fd and cb info 125 * for MM_CAMERA_POLL_TYPE_EVT, only index 0 is valid; 126 * for MM_CAMERA_POLL_TYPE_DATA, depends on valid stream fd */ 127 mm_camera_poll_entry_t poll_entries[MAX_STREAM_NUM_IN_BUNDLE]; 128 int32_t pfds[2]; 129 pthread_t pid; 130 int32_t state; 131 int timeoutms; 132 uint32_t cmd; 133 struct pollfd poll_fds[MAX_STREAM_NUM_IN_BUNDLE + 1]; 134 uint8_t num_fds; 135 pthread_mutex_t mutex; 136 pthread_cond_t cond_v; 137 int32_t status; 138 //void *my_obj; 139} mm_camera_poll_thread_t; 140 141/* mm_stream */ 142typedef enum { 143 MM_STREAM_STATE_NOTUSED = 0, /* not used */ 144 MM_STREAM_STATE_INITED, /* inited */ 145 MM_STREAM_STATE_ACQUIRED, /* acquired, fd opened */ 146 MM_STREAM_STATE_CFG, /* fmt & dim configured */ 147 MM_STREAM_STATE_BUFFED, /* buf allocated */ 148 MM_STREAM_STATE_REG, /* buf regged, stream off */ 149 MM_STREAM_STATE_ACTIVE, /* active */ 150 MM_STREAM_STATE_MAX 151} mm_stream_state_type_t; 152 153typedef enum { 154 MM_STREAM_EVT_ACQUIRE, 155 MM_STREAM_EVT_RELEASE, 156 MM_STREAM_EVT_SET_FMT, 157 MM_STREAM_EVT_GET_BUF, 158 MM_STREAM_EVT_PUT_BUF, 159 MM_STREAM_EVT_REG_BUF, 160 MM_STREAM_EVT_UNREG_BUF, 161 MM_STREAM_EVT_START, 162 MM_STREAM_EVT_STOP, 163 MM_STREAM_EVT_QBUF, 164 MM_STREAM_EVT_SET_PARM, 165 MM_STREAM_EVT_GET_PARM, 166 MM_STREAM_EVT_DO_ACTION, 167 MM_STREAM_EVT_MAX 168} mm_stream_evt_type_t; 169 170typedef struct { 171 mm_camera_buf_notify_t cb; 172 void *user_data; 173 /* cb_count = -1: infinite 174 * cb_count > 0: register only for required times */ 175 int8_t cb_count; 176} mm_stream_data_cb_t; 177 178typedef struct { 179 /* buf reference count */ 180 uint8_t buf_refcnt; 181 182 /* This flag is to indicate if after allocation, 183 * the corresponding buf needs to qbuf into kernel 184 * (e.g. for preview usecase, display needs to hold two bufs, 185 * so no need to qbuf these two bufs initially) */ 186 uint8_t initial_reg_flag; 187 188 /* indicate if buf is in kernel(1) or client(0) */ 189 uint8_t in_kernel; 190} mm_stream_buf_status_t; 191 192typedef struct mm_stream { 193 uint32_t my_hdl; /* local stream id */ 194 uint32_t server_stream_id; /* stream id from server */ 195 int32_t fd; 196 mm_stream_state_type_t state; 197 198 /* stream info*/ 199 cam_stream_info_t *stream_info; 200 201 /* padding info */ 202 cam_padding_info_t padding_info; 203 204 /* offset */ 205 cam_frame_len_offset_t frame_offset; 206 207 mm_camera_cmd_thread_t cmd_thread; 208 209 /* dataCB registered on this stream obj */ 210 pthread_mutex_t cb_lock; /* cb lock to protect buf_cb */ 211 mm_stream_data_cb_t buf_cb[MM_CAMERA_STREAM_BUF_CB_MAX]; 212 213 /* stream buffer management */ 214 pthread_mutex_t buf_lock; 215 uint8_t buf_num; /* num of buffers allocated */ 216 mm_camera_buf_def_t* buf; /* ptr to buf array */ 217 mm_stream_buf_status_t* buf_status; /* ptr to buf status array */ 218 219 /* reference to parent channel_obj */ 220 struct mm_channel* ch_obj; 221 222 uint8_t is_bundled; /* flag if stream is bundled */ 223 224 mm_camera_stream_mem_vtbl_t mem_vtbl; /* mem ops tbl */ 225} mm_stream_t; 226 227/* mm_channel */ 228typedef enum { 229 MM_CHANNEL_STATE_NOTUSED = 0, /* not used */ 230 MM_CHANNEL_STATE_STOPPED, /* stopped */ 231 MM_CHANNEL_STATE_ACTIVE, /* active, at least one stream active */ 232 MM_CHANNEL_STATE_PAUSED, /* paused */ 233 MM_CHANNEL_STATE_MAX 234} mm_channel_state_type_t; 235 236typedef enum { 237 MM_CHANNEL_EVT_ADD_STREAM, 238 MM_CHANNEL_EVT_DEL_STREAM, 239 MM_CHANNEL_EVT_CONFIG_STREAM, 240 MM_CHANNEL_EVT_GET_BUNDLE_INFO, 241 MM_CHANNEL_EVT_START, 242 MM_CHANNEL_EVT_STOP, 243 MM_CHANNEL_EVT_PAUSE, 244 MM_CHANNEL_EVT_RESUME, 245 MM_CHANNEL_EVT_REQUEST_SUPER_BUF, 246 MM_CHANNEL_EVT_CANCEL_REQUEST_SUPER_BUF, 247 MM_CHANNEL_EVT_FLUSH_SUPER_BUF_QUEUE, 248 MM_CHANNEL_EVT_MAP_STREAM_BUF, 249 MM_CHANNEL_EVT_UNMAP_STREAM_BUF, 250 MM_CHANNEL_EVT_SET_STREAM_PARM, 251 MM_CHANNEL_EVT_GET_STREAM_PARM, 252 MM_CHANNEL_EVT_DO_STREAM_ACTION, 253 MM_CHANNEL_EVT_DELETE, 254} mm_channel_evt_type_t; 255 256typedef struct { 257 uint32_t stream_id; 258 mm_camera_stream_config_t *config; 259} mm_evt_paylod_config_stream_t; 260 261typedef struct { 262 uint32_t stream_id; 263 cam_stream_parm_buffer_t *parms; 264} mm_evt_paylod_set_get_stream_parms_t; 265 266typedef struct { 267 uint32_t stream_id; 268 void *actions; 269} mm_evt_paylod_do_stream_action_t; 270 271typedef struct { 272 uint32_t stream_id; 273 uint8_t buf_type; 274 uint32_t buf_idx; 275 int32_t plane_idx; 276 int fd; 277 uint32_t size; 278} mm_evt_paylod_map_stream_buf_t; 279 280typedef struct { 281 uint32_t stream_id; 282 uint8_t buf_type; 283 uint32_t buf_idx; 284 int32_t plane_idx; 285} mm_evt_paylod_unmap_stream_buf_t; 286 287typedef struct { 288 uint8_t num_of_bufs; 289 mm_camera_buf_info_t super_buf[MAX_STREAM_NUM_IN_BUNDLE]; 290 uint8_t matched; 291 uint32_t frame_idx; 292} mm_channel_queue_node_t; 293 294typedef struct { 295 cam_queue_t que; 296 uint8_t num_streams; 297 /* container for bundled stream handlers */ 298 uint32_t bundled_streams[MAX_STREAM_NUM_IN_BUNDLE]; 299 mm_camera_channel_attr_t attr; 300 uint32_t expected_frame_id; 301 uint32_t match_cnt; 302} mm_channel_queue_t; 303 304typedef struct { 305 uint8_t is_active; /* flag to indicate if bundle is valid */ 306 /* queue to store bundled super buffers */ 307 mm_channel_queue_t superbuf_queue; 308 mm_camera_buf_notify_t super_buf_notify_cb; 309 void *user_data; 310} mm_channel_bundle_t; 311 312typedef struct mm_channel { 313 uint32_t my_hdl; 314 mm_channel_state_type_t state; 315 pthread_mutex_t ch_lock; /* channel lock */ 316 317 /* stream bundle info in the channel */ 318 mm_channel_bundle_t bundle; 319 320 /* num of pending suferbuffers */ 321 uint32_t pending_cnt; 322 323 /* cmd thread for superbuffer dataCB and async stop*/ 324 mm_camera_cmd_thread_t cmd_thread; 325 326 /* cb thread for sending data cb */ 327 mm_camera_cmd_thread_t cb_thread; 328 329 /* data poll thread 330 * currently one data poll thread per channel 331 * could extended to support one data poll thread per stream in the channel */ 332 mm_camera_poll_thread_t poll_thread[MM_CAMERA_CHANNEL_POLL_THREAD_MAX]; 333 334 /* container for all streams in channel */ 335 mm_stream_t streams[MAX_STREAM_NUM_IN_BUNDLE]; 336 337 /* reference to parent cam_obj */ 338 struct mm_camera_obj* cam_obj; 339} mm_channel_t; 340 341/* struct to store information about pp cookie*/ 342typedef struct { 343 uint32_t cam_hdl; 344 uint32_t ch_hdl; 345 uint32_t stream_hdl; 346 mm_channel_queue_node_t* super_buf; 347} mm_channel_pp_info_t; 348 349/* mm_camera */ 350typedef struct { 351 mm_camera_event_notify_t evt_cb; 352 void *user_data; 353} mm_camera_evt_entry_t; 354 355typedef struct { 356 mm_camera_evt_entry_t evt[MM_CAMERA_EVT_ENTRY_MAX]; 357 /* reg_count <=0: infinite 358 * reg_count > 0: register only for required times */ 359 int reg_count; 360} mm_camera_evt_obj_t; 361 362typedef struct mm_camera_obj { 363 uint32_t my_hdl; 364 int ref_count; 365 int32_t ctrl_fd; 366 int32_t ds_fd; /* domain socket fd */ 367 pthread_mutex_t cam_lock; 368 pthread_mutex_t cb_lock; /* lock for evt cb */ 369 mm_channel_t ch[MM_CAMERA_CHANNEL_MAX]; 370 mm_camera_evt_obj_t evt; 371 mm_camera_poll_thread_t evt_poll_thread; /* evt poll thread */ 372 mm_camera_cmd_thread_t evt_thread; /* thread for evt CB */ 373 mm_camera_vtbl_t vtbl; 374 375 pthread_mutex_t evt_lock; 376 pthread_cond_t evt_cond; 377 mm_camera_event_t evt_rcvd; 378} mm_camera_obj_t; 379 380typedef struct { 381 int8_t num_cam; 382 char video_dev_name[MM_CAMERA_MAX_NUM_SENSORS][MM_CAMERA_DEV_NAME_LEN]; 383 mm_camera_obj_t *cam_obj[MM_CAMERA_MAX_NUM_SENSORS]; 384} mm_camera_ctrl_t; 385 386/********************************************************************************** 387* external function declare 388***********************************************************************************/ 389/* utility functions */ 390/* set int32_t value */ 391extern int32_t mm_camera_util_s_ctrl(int32_t fd, 392 uint32_t id, 393 int32_t *value); 394 395/* get int32_t value */ 396extern int32_t mm_camera_util_g_ctrl(int32_t fd, 397 uint32_t id, 398 int32_t *value); 399 400/* send msg throught domain socket for fd mapping */ 401extern int32_t mm_camera_util_sendmsg(mm_camera_obj_t *my_obj, 402 void *msg, 403 uint32_t buf_size, 404 int sendfd); 405/* Check if hardware target is A family */ 406uint8_t mm_camera_util_chip_is_a_family(void); 407 408/* mm-camera */ 409extern int32_t mm_camera_open(mm_camera_obj_t *my_obj); 410extern int32_t mm_camera_close(mm_camera_obj_t *my_obj); 411extern int32_t mm_camera_register_event_notify(mm_camera_obj_t *my_obj, 412 mm_camera_event_notify_t evt_cb, 413 void * user_data); 414extern int32_t mm_camera_qbuf(mm_camera_obj_t *my_obj, 415 uint32_t ch_id, 416 mm_camera_buf_def_t *buf); 417extern int32_t mm_camera_query_capability(mm_camera_obj_t *my_obj); 418extern int32_t mm_camera_set_parms(mm_camera_obj_t *my_obj, 419 parm_buffer_t *parms); 420extern int32_t mm_camera_get_parms(mm_camera_obj_t *my_obj, 421 parm_buffer_t *parms); 422extern int32_t mm_camera_map_buf(mm_camera_obj_t *my_obj, 423 uint8_t buf_type, 424 int fd, 425 uint32_t size); 426extern int32_t mm_camera_unmap_buf(mm_camera_obj_t *my_obj, 427 uint8_t buf_type); 428extern int32_t mm_camera_do_auto_focus(mm_camera_obj_t *my_obj); 429extern int32_t mm_camera_cancel_auto_focus(mm_camera_obj_t *my_obj); 430extern int32_t mm_camera_prepare_snapshot(mm_camera_obj_t *my_obj, 431 int32_t do_af_flag); 432extern int32_t mm_camera_start_zsl_snapshot(mm_camera_obj_t *my_obj); 433extern int32_t mm_camera_stop_zsl_snapshot(mm_camera_obj_t *my_obj); 434extern uint32_t mm_camera_add_channel(mm_camera_obj_t *my_obj, 435 mm_camera_channel_attr_t *attr, 436 mm_camera_buf_notify_t channel_cb, 437 void *userdata); 438extern int32_t mm_camera_del_channel(mm_camera_obj_t *my_obj, 439 uint32_t ch_id); 440extern int32_t mm_camera_get_bundle_info(mm_camera_obj_t *my_obj, 441 uint32_t ch_id, 442 cam_bundle_config_t *bundle_info); 443extern uint32_t mm_camera_add_stream(mm_camera_obj_t *my_obj, 444 uint32_t ch_id); 445extern int32_t mm_camera_del_stream(mm_camera_obj_t *my_obj, 446 uint32_t ch_id, 447 uint32_t stream_id); 448extern int32_t mm_camera_config_stream(mm_camera_obj_t *my_obj, 449 uint32_t ch_id, 450 uint32_t stream_id, 451 mm_camera_stream_config_t *config); 452extern int32_t mm_camera_start_channel(mm_camera_obj_t *my_obj, 453 uint32_t ch_id); 454extern int32_t mm_camera_stop_channel(mm_camera_obj_t *my_obj, 455 uint32_t ch_id); 456extern int32_t mm_camera_request_super_buf(mm_camera_obj_t *my_obj, 457 uint32_t ch_id, 458 uint32_t num_buf_requested); 459extern int32_t mm_camera_cancel_super_buf_request(mm_camera_obj_t *my_obj, 460 uint32_t ch_id); 461extern int32_t mm_camera_flush_super_buf_queue(mm_camera_obj_t *my_obj, 462 uint32_t ch_id, 463 uint32_t frame_idx); 464extern int32_t mm_camera_set_stream_parms(mm_camera_obj_t *my_obj, 465 uint32_t ch_id, 466 uint32_t s_id, 467 cam_stream_parm_buffer_t *parms); 468extern int32_t mm_camera_get_stream_parms(mm_camera_obj_t *my_obj, 469 uint32_t ch_id, 470 uint32_t s_id, 471 cam_stream_parm_buffer_t *parms); 472extern int32_t mm_camera_register_event_notify_internal(mm_camera_obj_t *my_obj, 473 mm_camera_event_notify_t evt_cb, 474 void * user_data); 475extern int32_t mm_camera_map_stream_buf(mm_camera_obj_t *my_obj, 476 uint32_t ch_id, 477 uint32_t stream_id, 478 uint8_t buf_type, 479 uint32_t buf_idx, 480 int32_t plane_idx, 481 int fd, 482 uint32_t size); 483extern int32_t mm_camera_unmap_stream_buf(mm_camera_obj_t *my_obj, 484 uint32_t ch_id, 485 uint32_t stream_id, 486 uint8_t buf_type, 487 uint32_t buf_idx, 488 int32_t plane_idx); 489extern int32_t mm_camera_do_stream_action(mm_camera_obj_t *my_obj, 490 uint32_t ch_id, 491 uint32_t stream_id, 492 void *actions); 493 494/* mm_channel */ 495extern int32_t mm_channel_fsm_fn(mm_channel_t *my_obj, 496 mm_channel_evt_type_t evt, 497 void * in_val, 498 void * out_val); 499extern int32_t mm_channel_init(mm_channel_t *my_obj, 500 mm_camera_channel_attr_t *attr, 501 mm_camera_buf_notify_t channel_cb, 502 void *userdata); 503/* qbuf is a special case that not going through state machine. 504 * This is to avoid deadlock when trying to aquire ch_lock, 505 * from the context of dataCB, but async stop is holding ch_lock */ 506extern int32_t mm_channel_qbuf(mm_channel_t *my_obj, 507 mm_camera_buf_def_t *buf); 508 509/* mm_stream */ 510extern int32_t mm_stream_fsm_fn(mm_stream_t *my_obj, 511 mm_stream_evt_type_t evt, 512 void * in_val, 513 void * out_val); 514/* Allow other stream to register dataCB at certain stream. 515 * This is for use case of video sized live snapshot, 516 * because snapshot stream need register one time CB at video stream. 517 * ext_image_mode and sensor_idx are used to identify the destinate stream 518 * to be register with dataCB. */ 519extern int32_t mm_stream_reg_buf_cb(mm_stream_t *my_obj, 520 mm_stream_data_cb_t *val); 521extern int32_t mm_stream_map_buf(mm_stream_t *my_obj, 522 uint8_t buf_type, 523 uint32_t frame_idx, 524 int32_t plane_idx, 525 int fd, 526 uint32_t size); 527extern int32_t mm_stream_unmap_buf(mm_stream_t *my_obj, 528 uint8_t buf_type, 529 uint32_t frame_idx, 530 int32_t plane_idx); 531 532 533/* utiltity fucntion declared in mm-camera-inteface2.c 534 * and need be used by mm-camera and below*/ 535uint32_t mm_camera_util_generate_handler(uint8_t index); 536const char * mm_camera_util_get_dev_name(uint32_t cam_handler); 537uint8_t mm_camera_util_get_index_by_handler(uint32_t handler); 538 539/* poll/cmd thread functions */ 540extern int32_t mm_camera_poll_thread_launch( 541 mm_camera_poll_thread_t * poll_cb, 542 mm_camera_poll_thread_type_t poll_type); 543extern int32_t mm_camera_poll_thread_release(mm_camera_poll_thread_t *poll_cb); 544extern int32_t mm_camera_poll_thread_add_poll_fd( 545 mm_camera_poll_thread_t * poll_cb, 546 uint32_t handler, 547 int32_t fd, 548 mm_camera_poll_notify_t nofity_cb, 549 void *userdata); 550extern int32_t mm_camera_poll_thread_del_poll_fd( 551 mm_camera_poll_thread_t * poll_cb, 552 uint32_t handler); 553extern int32_t mm_camera_cmd_thread_launch( 554 mm_camera_cmd_thread_t * cmd_thread, 555 mm_camera_cmd_cb_t cb, 556 void* user_data); 557extern int32_t mm_camera_cmd_thread_release(mm_camera_cmd_thread_t * cmd_thread); 558 559#endif /* __MM_CAMERA_H__ */ 560