1/* 2Copyright (c) 2011-2012, The Linux Foundation. All rights reserved. 3 4Redistribution and use in source and binary forms, with or without 5modification, are permitted provided that the following conditions are 6met: 7 * Redistributions of source code must retain the above copyright 8 notice, this list of conditions and the following disclaimer. 9 * Redistributions in binary form must reproduce the above 10 copyright notice, this list of conditions and the following 11 disclaimer in the documentation and/or other materials provided 12 with the distribution. 13 * Neither the name of The Linux Foundation nor the names of its 14 contributors may be used to endorse or promote products derived 15 from this software without specific prior written permission. 16 17THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 18WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 20ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 21BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 22CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 24BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 25WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 26OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 27IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28*/ 29 30#ifndef __MM_CAMERA_H__ 31#define __MM_CAMERA_H__ 32 33#include <sys/poll.h> 34#include "mm_camera_interface.h" 35#include "cam_list.h" 36 37/********************************************************************************** 38* Data structure declare 39***********************************************************************************/ 40/* num of streams allowed in a channel obj */ 41#define MM_CAMEAR_STRAEM_NUM_MAX 8 42/* num of channels allowed in a camera obj */ 43#define MM_CAMERA_CHANNEL_MAX 1 44/* num of callbacks allowed for an event type */ 45#define MM_CAMERA_EVT_ENTRY_MAX 4 46/* num of data callbacks allowed in a stream obj */ 47#define MM_CAMERA_STREAM_BUF_CB_MAX 4 48/* num of data poll threads allowed in a channel obj */ 49#define MM_CAMERA_CHANNEL_POLL_THREAD_MAX 1 50 51#define MM_CAMERA_DEV_NAME_LEN 32 52#define MM_CAMERA_DEV_OPEN_TRIES 2 53#define MM_CAMERA_DEV_OPEN_RETRY_SLEEP 20 54 55struct mm_channel; 56struct mm_stream; 57struct mm_camera_obj; 58 59/* common use */ 60typedef struct { 61 struct cam_list list; 62 void* data; 63} mm_camera_q_node_t; 64 65typedef struct { 66 mm_camera_q_node_t head; /* dummy head */ 67 uint32_t size; 68 pthread_mutex_t lock; 69} mm_camera_queue_t; 70 71typedef enum 72{ 73 MM_CAMERA_ASYNC_CMD_TYPE_STOP, /* async stop */ 74 MM_CAMERA_ASYNC_CMD_TYPE_MAX 75} mm_camera_async_cmd_type_t; 76 77typedef struct { 78 struct mm_channel* ch_obj; 79 uint8_t num_streams; 80 uint32_t stream_ids[MM_CAMEAR_STRAEM_NUM_MAX]; 81} mm_camera_async_stop_cmd_t; 82 83typedef struct { 84 mm_camera_async_cmd_type_t cmd_type; 85 union { 86 mm_camera_async_stop_cmd_t stop_cmd; 87 } u; 88} mm_camera_async_cmd_t; 89 90typedef enum 91{ 92 MM_CAMERA_CMD_TYPE_DATA_CB, /* dataB CMD */ 93 MM_CAMERA_CMD_TYPE_EVT_CB, /* evtCB CMD */ 94 MM_CAMERA_CMD_TYPE_ASYNC_CB, /* asyncCB CMD */ 95 MM_CAMERA_CMD_TYPE_EXIT, /* EXIT */ 96 MM_CAMERA_CMD_TYPE_REQ_DATA_CB,/* request data */ 97 MM_CAMERA_CMD_TYPE_MAX 98} mm_camera_cmdcb_type_t; 99 100typedef struct { 101 uint32_t stream_id; 102 uint32_t frame_idx; 103 uint8_t need_pp; /* flag if pp needed on this buf */ 104 mm_camera_buf_def_t *buf; /* ref to buf */ 105} mm_camera_buf_info_t; 106 107typedef struct { 108 mm_camera_cmdcb_type_t cmd_type; 109 union { 110 mm_camera_buf_info_t buf; /* frame buf if dataCB */ 111 mm_camera_event_t evt; /* evt if evtCB */ 112 mm_camera_async_cmd_t async; /* async cmd */ 113 } u; 114} mm_camera_cmdcb_t; 115 116typedef void (*mm_camera_cmd_cb_t)(mm_camera_cmdcb_t * cmd_cb, void* user_data); 117 118typedef struct { 119 mm_camera_queue_t cmd_queue; /* cmd queue (queuing dataCB, asyncCB, or exitCMD) */ 120 pthread_t cmd_pid; /* cmd thread ID */ 121 sem_t cmd_sem; /* semaphore for cmd thread */ 122 mm_camera_cmd_cb_t cb; /* cb for cmd */ 123 void* user_data; /* user_data for cb */ 124} mm_camera_cmd_thread_t; 125 126typedef enum { 127 MM_CAMERA_POLL_TYPE_EVT, 128 MM_CAMERA_POLL_TYPE_CH, 129 MM_CAMERA_POLL_TYPE_MAX 130} mm_camera_poll_thread_type_t; 131 132/* function ptr defined for poll notify CB, 133 * registered at poll thread with poll fd */ 134typedef void (*mm_camera_poll_notify_t)(void *user_data); 135 136typedef struct { 137 int32_t fd; 138 mm_camera_poll_notify_t notify_cb; 139 uint32_t handler; 140 void* user_data; 141} mm_camera_poll_entry_t; 142 143typedef struct { 144 mm_camera_poll_thread_type_t poll_type; 145 /* array to store poll fd and cb info 146 * for MM_CAMERA_POLL_TYPE_EVT, only index 0 is valid; 147 * for MM_CAMERA_POLL_TYPE_CH, depends on valid stream fd */ 148 mm_camera_poll_entry_t poll_entries[MM_CAMEAR_STRAEM_NUM_MAX]; 149 int32_t pfds[2]; 150 pthread_t pid; 151 int32_t state; 152 int timeoutms; 153 uint32_t cmd; 154 struct pollfd poll_fds[MM_CAMEAR_STRAEM_NUM_MAX+1]; 155 uint8_t num_fds; 156 pthread_mutex_t mutex; 157 pthread_cond_t cond_v; 158 int32_t status; 159 //void *my_obj; 160} mm_camera_poll_thread_t; 161 162/* mm_stream */ 163typedef enum { 164 MM_STREAM_STATE_NOTUSED = 0, /* not used */ 165 MM_STREAM_STATE_INITED, /* inited */ 166 MM_STREAM_STATE_ACQUIRED, /* acquired, fd opened */ 167 MM_STREAM_STATE_CFG, /* fmt & dim configured */ 168 MM_STREAM_STATE_BUFFED, /* buf allocated */ 169 MM_STREAM_STATE_REG, /* buf regged, stream off */ 170 MM_STREAM_STATE_ACTIVE_STREAM_ON, /* active with stream on */ 171 MM_STREAM_STATE_ACTIVE_STREAM_OFF, /* active with stream off */ 172 MM_STREAM_STATE_MAX 173} mm_stream_state_type_t; 174 175typedef enum { 176 MM_STREAM_EVT_ACQUIRE, 177 MM_STREAM_EVT_RELEASE, 178 MM_STREAM_EVT_SET_FMT, 179 MM_STREAM_EVT_GET_BUF, 180 MM_STREAM_EVT_PUT_BUF, 181 MM_STREAM_EVT_REG_BUF, 182 MM_STREAM_EVT_UNREG_BUF, 183 MM_STREAM_EVT_START, 184 MM_STREAM_EVT_STOP, 185 MM_STREAM_EVT_QBUF, 186 MM_STREAM_EVT_SET_PARM, 187 MM_STREAM_EVT_GET_PARM, 188 MM_STREAM_EVT_MAX 189} mm_stream_evt_type_t; 190 191typedef struct { 192 mm_camera_buf_notify_t cb; 193 void *user_data; 194 /* cb_count = -1: infinite 195 * cb_count > 0: register only for required times */ 196 int8_t cb_count; 197} mm_stream_data_cb_t; 198 199typedef struct { 200 /* buf reference count */ 201 uint8_t buf_refcnt; 202 203 /* This flag is to indicate if after allocation, 204 * the corresponding buf needs to qbuf into kernel 205 * (e.g. for preview usecase, display needs to hold two bufs, 206 * so no need to qbuf these two bufs initially) */ 207 uint8_t initial_reg_flag; 208 209 /* indicate if buf is in kernel(1) or client(0) */ 210 uint8_t in_kernel; 211} mm_stream_buf_status_t; 212 213typedef struct mm_stream { 214 uint32_t my_hdl; 215 uint32_t inst_hdl; 216 int32_t fd; 217 mm_stream_state_type_t state; 218 219 /* ext_image_mode used as id for stream obj */ 220 uint32_t ext_image_mode; 221 222 /* sensor index used */ 223 uint32_t sensor_idx; 224 225 mm_camera_image_fmt_t fmt; 226 227 mm_camera_cmd_thread_t cmd_thread; 228 229 /* dataCB registered on this stream obj */ 230 pthread_mutex_t cb_lock; /* cb lock to protect buf_cb */ 231 mm_stream_data_cb_t buf_cb[MM_CAMERA_STREAM_BUF_CB_MAX]; 232 233 /* stream buffer management */ 234 pthread_mutex_t buf_lock; 235 uint8_t buf_num; /* num of buffers allocated */ 236 mm_camera_buf_def_t* buf; /* ptr to buf array */ 237 mm_stream_buf_status_t* buf_status; /* ptr to buf status array */ 238 239 /* reference to parent channel_obj */ 240 struct mm_channel* ch_obj; 241 242 uint8_t is_bundled; /* flag if stream is bundled */ 243 uint8_t is_pp_needed; /* flag if need to do post processing, set when streamon */ 244 uint8_t is_local_buf; /* flag if buf is local copy, no need to qbuf to kernel */ 245 uint8_t hal_requested_num_bufs; 246 uint8_t need_stream_on; /* flag if stream need streamon when start */ 247 248 mm_camera_frame_len_offset frame_offset; /*Stream buffer offset information*/ 249} mm_stream_t; 250 251/* mm_channel */ 252typedef enum { 253 MM_CHANNEL_STATE_NOTUSED = 0, /* not used */ 254 MM_CHANNEL_STATE_STOPPED, /* stopped */ 255 MM_CHANNEL_STATE_ACTIVE, /* active, at least one stream active */ 256 MM_CHANNEL_STATE_PAUSED, /* paused */ 257 MM_CHANNEL_STATE_MAX 258} mm_channel_state_type_t; 259 260typedef enum { 261 MM_CHANNEL_EVT_ADD_STREAM, 262 MM_CHANNEL_EVT_DEL_STREAM, 263 MM_CHANNEL_EVT_START_STREAM, 264 MM_CHANNEL_EVT_STOP_STREAM, 265 MM_CHANNEL_EVT_TEARDOWN_STREAM, 266 MM_CHANNEL_EVT_CONFIG_STREAM, 267 MM_CHANNEL_EVT_PAUSE, 268 MM_CHANNEL_EVT_RESUME, 269 MM_CHANNEL_EVT_INIT_BUNDLE, 270 MM_CHANNEL_EVT_DESTROY_BUNDLE, 271 MM_CHANNEL_EVT_REQUEST_SUPER_BUF, 272 MM_CHANNEL_EVT_CANCEL_REQUEST_SUPER_BUF, 273 MM_CHANNEL_EVT_START_FOCUS, 274 MM_CHANNEL_EVT_ABORT_FOCUS, 275 MM_CHANNEL_EVT_PREPARE_SNAPSHOT, 276 MM_CHANNEL_EVT_SET_STREAM_PARM, 277 MM_CHANNEL_EVT_GET_STREAM_PARM, 278 MM_CHANNEL_EVT_DELETE, 279 MM_CHANNEL_EVT_MAX 280} mm_channel_evt_type_t; 281 282typedef struct { 283 mm_camera_buf_notify_t buf_cb; 284 void *user_data; 285 uint32_t ext_image_mode; 286 uint32_t sensor_idx; 287} mm_evt_paylod_add_stream_t; 288 289typedef struct { 290 uint32_t stream_id; 291 mm_camera_stream_config_t *config; 292} mm_evt_paylod_config_stream_t; 293 294typedef struct { 295 mm_camera_stream_parm_t parm_type; 296 void *value; 297} mm_evt_paylod_stream_parm_t; 298 299typedef struct { 300 mm_camera_buf_notify_t super_frame_notify_cb; 301 void *user_data; 302 mm_camera_bundle_attr_t *attr; 303 uint8_t num_streams; 304 uint32_t *stream_ids; 305} mm_evt_payload_bundle_stream_t; 306 307typedef struct { 308 uint8_t num_streams; 309 uint32_t *stream_ids; 310} mm_evt_payload_start_stream_t; 311 312typedef struct { 313 uint8_t num_streams; 314 uint32_t *stream_ids; 315} mm_evt_payload_stop_stream_t; 316 317typedef struct { 318 uint32_t sensor_idx; 319 uint32_t focus_mode; 320} mm_evt_payload_start_focus_t; 321 322typedef struct { 323 uint8_t num_of_bufs; 324 mm_camera_buf_info_t super_buf[MM_CAMEAR_MAX_STRAEM_BUNDLE]; 325 uint8_t matched; 326} mm_channel_queue_node_t; 327 328typedef struct { 329 mm_camera_queue_t que; 330 uint8_t num_streams; 331 /* container for bundled stream handlers */ 332 uint32_t bundled_streams[MM_CAMEAR_MAX_STRAEM_BUNDLE]; 333 mm_camera_bundle_attr_t attr; 334 uint32_t expected_frame_id; 335 uint32_t match_cnt; 336} mm_channel_queue_t; 337 338typedef struct { 339 /* queue to store bundled super buffers */ 340 mm_channel_queue_t superbuf_queue; 341 mm_camera_buf_notify_t super_buf_notify_cb; 342 void *user_data; 343} mm_channel_bundle_t; 344 345typedef struct mm_channel { 346 uint32_t my_hdl; 347 mm_channel_state_type_t state; 348 pthread_mutex_t ch_lock; /* channel lock */ 349 350 /* stream bundle info in the channel */ 351 mm_channel_bundle_t bundle; 352 353 /* num of pending suferbuffers */ 354 uint32_t pending_cnt; 355 uint32_t pending_pp_cnt; /*pending cnt for post processing frames */ 356 357 /* cmd thread for superbuffer dataCB and async stop*/ 358 mm_camera_cmd_thread_t cmd_thread; 359 360 /* data poll thread 361 * currently one data poll thread per channel 362 * could extended to support one data poll thread per stream in the channel */ 363 mm_camera_poll_thread_t poll_thread[MM_CAMERA_CHANNEL_POLL_THREAD_MAX]; 364 365 /* container for all streams in channel 366 * stream is indexed by ext_image_mode */ 367 mm_stream_t streams[MM_CAMEAR_STRAEM_NUM_MAX]; 368 369 /* reference to parent cam_obj */ 370 struct mm_camera_obj* cam_obj; 371} mm_channel_t; 372 373/* struct to store information about pp cookie*/ 374typedef struct { 375 uint32_t cam_hdl; 376 uint32_t ch_hdl; 377 uint32_t stream_hdl; 378 mm_channel_queue_node_t* super_buf; 379} mm_channel_pp_info_t; 380 381/* mm_camera */ 382typedef struct { 383 mm_camera_event_notify_t evt_cb; 384 void *user_data; 385} mm_camera_evt_entry_t; 386 387typedef struct { 388 mm_camera_evt_entry_t evt[MM_CAMERA_EVT_ENTRY_MAX]; 389 /* reg_count <=0: infinite 390 * reg_count > 0: register only for required times */ 391 int reg_count; 392} mm_camera_evt_obj_t; 393 394typedef struct mm_camera_obj { 395 uint32_t my_hdl; 396 int ref_count; 397 int32_t ctrl_fd; 398 int32_t ds_fd; /* domain socket fd */ 399 cam_prop_t properties; 400 mm_camera_2nd_sensor_t second_sensor; /*second sensor info */ 401 pthread_mutex_t cam_lock; 402 pthread_mutex_t cb_lock; /* lock for evt cb */ 403 mm_channel_t ch[MM_CAMERA_CHANNEL_MAX]; 404 mm_camera_evt_obj_t evt[MM_CAMERA_EVT_TYPE_MAX]; 405 uint32_t evt_type_mask; 406 mm_camear_mem_vtbl_t *mem_vtbl; /* vtable for memory management */ 407 mm_camera_poll_thread_t evt_poll_thread; /* evt poll thread */ 408 mm_camera_cmd_thread_t evt_thread; /* thread for evt CB */ 409 mm_camera_cmd_thread_t async_cmd_thread; /* thread for async cmd */ 410 mm_camera_vtbl_t vtbl; 411 412 /* some local variables */ 413 uint32_t snap_burst_num_by_user; 414 camera_mode_t current_mode; 415 uint8_t need_pp; 416 uint32_t op_mode; 417 cam_ctrl_dimension_t dim; 418} mm_camera_obj_t; 419 420typedef struct { 421 mm_camera_info_t camera[MSM_MAX_CAMERA_SENSORS]; 422 int8_t num_cam; 423 char video_dev_name[MSM_MAX_CAMERA_SENSORS][MM_CAMERA_DEV_NAME_LEN]; 424 mm_camera_obj_t *cam_obj[MSM_MAX_CAMERA_SENSORS]; 425} mm_camera_ctrl_t; 426 427/********************************************************************************** 428* external function declare 429***********************************************************************************/ 430/* utility functions */ 431/* set int32_t value */ 432extern int32_t mm_camera_util_s_ctrl(int32_t fd, 433 uint32_t id, 434 int32_t value); 435 436extern int32_t mm_camera_util_private_s_ctrl( int32_t fd, 437 uint32_t id, void* value); 438 439/* get int32_t value */ 440extern int32_t mm_camera_util_g_ctrl(int32_t fd, 441 uint32_t id,int32_t *value); 442 443/* send msg throught domain socket for fd mapping */ 444extern int32_t mm_camera_util_sendmsg(mm_camera_obj_t *my_obj, 445 void *msg, 446 uint32_t buf_size, 447 int sendfd); 448 449/* mm-camera */ 450extern int32_t mm_camera_open(mm_camera_obj_t *my_obj); 451extern int32_t mm_camera_close(mm_camera_obj_t *my_obj); 452extern uint8_t mm_camera_is_event_supported(mm_camera_obj_t *my_obj, 453 mm_camera_event_type_t evt_type); 454extern int32_t mm_camera_register_event_notify(mm_camera_obj_t *my_obj, 455 mm_camera_event_notify_t evt_cb, 456 void * user_data, 457 mm_camera_event_type_t evt_type); 458extern int32_t mm_camera_qbuf(mm_camera_obj_t *my_obj, 459 uint32_t ch_id, 460 mm_camera_buf_def_t *buf); 461extern mm_camera_2nd_sensor_t * mm_camera_query_2nd_sensor_info(mm_camera_obj_t *my_obj); 462extern int32_t mm_camera_sync(mm_camera_obj_t *my_obj); 463extern int32_t mm_camera_is_parm_supported(mm_camera_obj_t *my_obj, 464 mm_camera_parm_type_t parm_type, 465 uint8_t *support_set_parm, 466 uint8_t *support_get_parm); 467extern int32_t mm_camera_set_parm(mm_camera_obj_t *my_obj, 468 mm_camera_parm_type_t parm_type, 469 void* p_value); 470extern int32_t mm_camera_get_parm(mm_camera_obj_t *my_obj, 471 mm_camera_parm_type_t parm_type, 472 void* p_value); 473extern uint32_t mm_camera_add_channel(mm_camera_obj_t *my_obj); 474extern void mm_camera_del_channel(mm_camera_obj_t *my_obj, 475 uint32_t ch_id); 476extern uint32_t mm_camera_add_stream(mm_camera_obj_t *my_obj, 477 uint32_t ch_id, 478 mm_camera_buf_notify_t buf_cb, void *user_data, 479 uint32_t ext_image_mode, uint32_t sensor_idx); 480extern int32_t mm_camera_del_stream(mm_camera_obj_t *my_obj, 481 uint32_t ch_id, 482 uint32_t stream_id); 483extern int32_t mm_camera_config_stream(mm_camera_obj_t *my_obj, 484 uint32_t ch_id, 485 uint32_t stream_id, 486 mm_camera_stream_config_t *config); 487extern int32_t mm_camera_bundle_streams(mm_camera_obj_t *my_obj, 488 uint32_t ch_id, 489 mm_camera_buf_notify_t super_frame_notify_cb, 490 void *user_data, 491 mm_camera_bundle_attr_t *attr, 492 uint8_t num_streams, 493 uint32_t *stream_ids); 494extern int32_t mm_camera_destroy_bundle(mm_camera_obj_t *my_obj, 495 uint32_t ch_id); 496extern int32_t mm_camera_start_streams(mm_camera_obj_t *my_obj, 497 uint32_t ch_id, 498 uint8_t num_streams, 499 uint32_t *stream_ids); 500extern int32_t mm_camera_stop_streams(mm_camera_obj_t *my_obj, 501 uint32_t ch_id, 502 uint8_t num_streams, 503 uint32_t *stream_ids); 504extern int32_t mm_camera_async_teardown_streams(mm_camera_obj_t *my_obj, 505 uint32_t ch_id, 506 uint8_t num_streams, 507 uint32_t *stream_ids); 508extern int32_t mm_camera_request_super_buf(mm_camera_obj_t *my_obj, 509 uint32_t ch_id); 510extern int32_t mm_camera_cancel_super_buf_request(mm_camera_obj_t *my_obj, 511 uint32_t ch_id); 512extern int32_t mm_camera_start_focus(mm_camera_obj_t *my_obj, 513 uint32_t ch_id, 514 uint32_t sensor_idx, 515 uint32_t focus_mode); 516extern int32_t mm_camera_abort_focus(mm_camera_obj_t *my_obj, 517 uint32_t ch_id, 518 uint32_t sensor_idx); 519extern int32_t mm_camera_prepare_snapshot(mm_camera_obj_t *my_obj, 520 uint32_t ch_id, 521 uint32_t sensor_idx); 522extern int32_t mm_camera_set_stream_parm(mm_camera_obj_t *my_obj, 523 uint32_t ch_id, 524 uint32_t s_id, 525 mm_camera_stream_parm_t parm_type, 526 void* p_value); 527 528extern int32_t mm_camera_get_stream_parm(mm_camera_obj_t *my_obj, 529 uint32_t ch_id, 530 uint32_t s_id, 531 mm_camera_stream_parm_t parm_type, 532 void* p_value); 533 534extern int32_t mm_camera_register_event_notify_internal( 535 mm_camera_obj_t *my_obj, 536 mm_camera_event_notify_t evt_cb, 537 void * user_data, 538 mm_camera_event_type_t evt_type); 539extern int32_t mm_camera_map_buf(mm_camera_obj_t *my_obj, 540 int ext_mode, 541 int idx, 542 int fd, 543 uint32_t size); 544extern int32_t mm_camera_unmap_buf(mm_camera_obj_t *my_obj, 545 int ext_mode, 546 int idx); 547extern int32_t mm_camera_send_ch_event(mm_camera_obj_t *my_obj, 548 uint32_t ch_id, 549 uint32_t stream_id, 550 mm_camera_ch_event_type_t evt); 551 552 553/* mm_channel */ 554extern int32_t mm_channel_fsm_fn(mm_channel_t *my_obj, 555 mm_channel_evt_type_t evt, 556 void * in_val, 557 void * out_val); 558 559/* qbuf is a special case that not going through state machine. 560 * This is to avoid deadlock when trying to aquire ch_lock, 561 * from the context of dataCB, but async stop is holding ch_lock */ 562extern int32_t mm_channel_qbuf(mm_channel_t *my_obj, 563 mm_camera_buf_def_t *buf); 564 565/* Allow other stream to register dataCB at certain stream. 566 * This is for use case of video sized live snapshot, 567 * because snapshot stream need register one time CB at video stream. 568 * ext_image_mode and sensor_idx are used to identify the destinate stream 569 * to be register with dataCB. */ 570extern int32_t mm_channel_reg_stream_cb(mm_channel_t *my_obj, 571 mm_stream_data_cb_t *cb, 572 uint32_t ext_image_mode, 573 uint32_t sensor_idx); 574 575/* mm_stream */ 576extern int32_t mm_stream_fsm_fn(mm_stream_t *my_obj, 577 mm_stream_evt_type_t evt, 578 void * in_val, 579 void * out_val); 580/* Allow other stream to register dataCB at certain stream. 581 * This is for use case of video sized live snapshot, 582 * because snapshot stream need register one time CB at video stream. 583 * ext_image_mode and sensor_idx are used to identify the destinate stream 584 * to be register with dataCB. */ 585extern int32_t mm_stream_reg_buf_cb(mm_stream_t *my_obj, 586 mm_stream_data_cb_t *val); 587 588/* utiltity fucntion declared in mm-camera-inteface2.c 589 * and need be used by mm-camera and below*/ 590uint32_t mm_camera_util_generate_handler(uint8_t index); 591const char * mm_camera_util_get_dev_name(uint32_t cam_handler); 592uint8_t mm_camera_util_get_index_by_handler(uint32_t handler); 593 594/* queue functions */ 595extern int32_t mm_camera_queue_init(mm_camera_queue_t* queue); 596extern int32_t mm_camera_queue_enq(mm_camera_queue_t* queue, void* node); 597extern void* mm_camera_queue_deq(mm_camera_queue_t* queue); 598extern int32_t mm_camera_queue_deinit(mm_camera_queue_t* queue); 599extern int32_t mm_camera_queue_flush(mm_camera_queue_t* queue); 600 601/* poll/cmd thread functions */ 602extern int32_t mm_camera_poll_thread_launch( 603 mm_camera_poll_thread_t * poll_cb, 604 mm_camera_poll_thread_type_t poll_type); 605extern int32_t mm_camera_poll_thread_release(mm_camera_poll_thread_t *poll_cb); 606extern int32_t mm_camera_poll_thread_add_poll_fd( 607 mm_camera_poll_thread_t * poll_cb, 608 uint32_t handler, 609 int32_t fd, 610 mm_camera_poll_notify_t nofity_cb, 611 void *userdata); 612extern int32_t mm_camera_poll_thread_del_poll_fd( 613 mm_camera_poll_thread_t * poll_cb, 614 uint32_t handler); 615extern int32_t mm_camera_cmd_thread_launch( 616 mm_camera_cmd_thread_t * cmd_thread, 617 mm_camera_cmd_cb_t cb, 618 void* user_data); 619extern int32_t mm_camera_cmd_thread_release(mm_camera_cmd_thread_t * cmd_thread); 620 621#endif /* __MM_CAMERA_H__ */ 622