omx cam: add test app
[glsdk/omapdrmtest.git] / omx_cam / VisionCam.h
1 /* Copyright (C) 2012 Texas Instruments, Inc. All rights reserved */
3 #ifndef _VISION_CAM_H_
4 #define _VISION_CAM_H_
6 /** MAX_FACES_COUNT
7   *
8   * Maximum number of face coordinates
9   * that face detect algorithm can output.
10 */
11 const uint32_t MAX_FACES_COUNT = 35;
13 /** VCAM_NUM_BUFFERS
14   *
15   * The maximum number of buffers that
16   * VisionCam would be able to operate with.
17 */
18 const uint32_t VCAM_NUM_BUFFERS = 8;
20 #define VCAM_DO_IF_FAILED(ret, statement, action)   {\
21     ret = statement;\
22     if (STATUS_FAILED(ret)) { \
23         ERROR("ERROR: VCAM Failure %d in function %s on file:line %s:%u\n", ret, __FUNCTION__, __FILE__, __LINE__);\
24         action;\
25     }\
26 }
28 #define VCAM_BREAK_IF_FAILED(ret, statement)        VCAM_DO_IF_FAILED(ret, statement, break)
29 #define VCAM_RETURN_IF_FAILED(ret, statement)       VCAM_DO_IF_FAILED(ret, statement, return ret)
30 #define VCAM_CONTINUE_IF_FAILED(ret, statement)     VCAM_DO_IF_FAILED(ret, statement, continue)
31 #define VCAM_COMPLAIN_IF_FAILED(ret, statement)     VCAM_DO_IF_FAILED(ret, statement, )
32 #define VCAM_GOTO_IF_FAILED(ret, statement, label)  VCAM_DO_IF_FAILED(ret, statement, goto label)
34 #define TIME_PROFILE 0
36 /** @enum VisionCamCmd_e
37   *
38   * Enumeration containing the all valid commands
39   * that could be accepted by VisionCam.
40   * @see VisionCam::sendCommand().
41 */
42 typedef enum _vcam_cmds_e
43 {
44     VCAM_CMD_PREVIEW_START = 0, /**< Start preview command. */
45     VCAM_CMD_PREVIEW_STOP,      /**< Stop preview command. */
46     VCAM_EXTRA_DATA_START,      /**< Enable transfering of e certain image meta data type.
47                                   @see VisionCamExtraDataType_e.
48                                 */
50     VCAM_EXTRA_DATA_STOP,       /**< Disable transfering of e certain image meta data type.
51                                   @see VisionCamExtraDataType_e.
52                                 */
54     VCAM_CMD_LOCK_AWB,          /**< Lock of auto white balance coeficients. */
55     VCAM_CMD_LOCK_AE,           /**< Lock exposure */
56     VCAM_CMD_QUIT,              /**< */
57 #if TIME_PROFILE
58     VCAM_DUMP_TIMES,            /**< Performance measurment option. */
59 #endif
60     VCAM_CMD_FACE_DETECTION,    /**< Enable/Disable face detection algo.
61                                   @see bool
62                                 */
64     VCAM_CMD_FREEZE_AWB_PARAMS, /**< Freeze white balance parameters aliance.
65                                   Auto white balance algorithm continues to work but its output is not applied,
66                                   for a certain amount of time.
67                                   After this time expires WB parameter are immediately set to the most recent calculated.
68                                   A pointer to an unsigned integer representing a time in millseconds.
69                                   Minimum freeze time is 0 and maximum 10000.
70                                 */
72     VCAM_CMD_FREEZE_AGC_PARAMS, /**< Freeze exposure algorithm aliance.
73                                   Auto white balance alorythm continues to work but its output is not applied,
74                                   for a certain amount of time.
75                                   After this time expires WB parameter are imediately set so the most recent calculated.
76                                   A pointer to an unsigned integer representing a time in millseconds.
77                                   Minimum freeze time is 0 and maximum 10000.
78                                 */
80     VCAM_CMD_SET_CLIENT_NOTIFICATION_CALLBACK, /**< Set client notification handler.
81                                                  @see VisionCamClientNotifierCallback
82                                                 */
83     VCAM_CMD_PACK_FRAMES,       /**< Enables frame packing.
84                                     In cases when more than one frame sources are selected
85                                     (for example preiew and video port in OMX camera) this option ensures that
86                                     the frames from all sources will be passed to VisionCam client
87                                     in a single call to its preview callback.
88                                     @see VisionCamFramePack
89                                 */
91     VCAM_CMD_MAX
92 } VisionCamCmd_e;
94 /** @enum VisionCamParam_e
95 *
96 *   Enumeration listing possible camera parameters.
97 *   These values are passed to VisionCam::setParameter().
98 *   @see VisionCam::setParameter().
99 */
100 typedef enum _vcam_params_e
102     VCAM_PARAM_MIN = 0x7F000001,    /**< To avoid collisions with VisionCamCmd_e. */
104     VCAM_PARAM_DO_AUTOFOCUS,        /**< Start auto focus of a given type @see VisionCamFocusMode. */
105     VCAM_PARAM_DO_MANUALFOCUS,      /**< Start manual focus; a value representing
106                                          focal distance must be passed. */
108     VCAM_PARAM_CONTRAST,            /**< Set the contrast parameter; a value,
109                                          in the range of -100 to 100 must be passed. */
111     VCAM_PARAM_SHARPNESS,           /**< Set the sharpness parameter; a value,
112                                         in the range of -100 to 100 must be passed. */
114     VCAM_PARAM_BRIGHTNESS,          /**< Brighness parameter; a value,
115                                         in the range of 0 to 200 must be passed. */
117     VCAM_PARAM_SATURATION,          /**< Saturation parameter; a value,
118                                         in the range of -100 to 100 must be passed. */
120     VCAM_PARAM_HEIGHT,              /**< Preview frame height.
121                                         This will be applied before next start preview command.
122                                         If the buffers allocated, at the momonet of next preview start, are not
123                                         with corresponding dimensions, you might receive corrupted frames
124                                         or even memory corruptions may appear.
125                                         This option if not preffered since preview width and height are strongly dependent.
126                                         use VCAM_PARAM_RESOLUTION instead.
127                                         @see VCAM_PARAM_RESOLUTION .
128                                         */
130     VCAM_PARAM_WIDTH,               /**< Preview frame width.
131                                         This will be applied before next start preview command.
132                                         If the buffers allocated, at the momonet of next preview start, do not
133                                         have corresponding dimensions, you might receive corrupted frames
134                                         or even memory corruptions may appear.
135                                         This option isn't preffered since preview width and height are strongly dependent to each other.
136                                         use VCAM_PARAM_RESOLUTION instead.
137                                         @see VCAM_PARAM_RESOLUTION .
138                                         */
140     VCAM_PARAM_FPS_FIXED,           /**< Frame rate. */
142     VCAM_PARAM_FPS_VAR,             /**< Set the variable frame rate.
143                                         A pointer to a structure of type VisionCamVarFramerateType must be passed
144                                         to specify minimum and maximum fps.
145                                         Variable frame rate means that fps is constantly recalculated
146                                         according to current light conditions.
147                                         @see VisionCamVarFramerateType .
148                                     */
150     VCAM_PARAM_COLOR_SPACE_FOURCC,  /**< Color space that will be used.
151                                         This should match the color space option,
152                                         passed to buffer allocating API.
153                                         @see _fourcc
154                                     */
156     VCAM_PARAM_NAME,                /**< When the input video is read from a file, this is the file name */
158     VCAM_PARAM_FLICKER,             /**< Set flicker avoiding parameter.
159                                         @see VisionCamFlickerType .
160                                     */
162     VCAM_PARAM_CROP,                /**< Crop option for preview frame.
163                                         @see VisionCamRectType .
164                                     */
165     VCAM_PARAM_CAP_MODE,            /**< Camera operating mode.
166                                         different operating modes provide different camera functionalities.
167                                         @see VisionCamCaptureMode .
168                                     */
170     VCAM_PARAM_SENSOR_SELECT,       /**< Active camera.
171                                         This can be done either during preview or when preview is stopped.
172                                         @see VisionCamSensorSelection.
173                                         Where :
174                                         primary sensor: the sensor at the back of the device.
175                                         secondary sensor: the sensor at the front of the device (user facing sensor).
176                                         stereo sensor: in case of stereo camera presence;
177                                         this corresponds to the couple of sensors located at the same side.
178                                     */
180     VCAM_PARAM_EXPOSURE_COMPENSATION, /**< EV compensation measured in ISOs.*/
182     VCAM_PARAM_RESOLUTION,          /**< Preview resolution.
183                                         This requires preview stop and reallocating the image buffers.
184                                         If preview is running: VisionCam::setParameter() retuns -EBADE.
185                                         A pointer to a value of VisionCamResolIdex type must be passed.
186                                         @see VisionCamResolIdex
187                                         @see VisionCamResolutions
188                                         @see VisionCamResType
189                                     */
191     VCAM_PARAM_MANUAL_EXPOSURE,     /**< Manual exposure time.
192                                         This affects the frame rate.
193                                         A pointer to an unsigned integer value must be passed.
194                                         This value must be in the range of 30 to 100
195                                         and represents the exposition time in milliseconds for each frame.
196                                     */
198     VCAM_PARAM_AWB_MODE,            /**< White balance mode.
199                                         @see VisionCamWhiteBalType.
200                                     */
202     VCAM_PARAM_COLOR_TEMP,          /**< Color temperature in Kelvins. */
204     VCAM_PARAM_EXPOSURE_ISO,        /**< Exposure ISO.
205                                         An unsigned integer value, in the range of 100 to 800, must be passed.
206                                     */
208     VCAM_PARAM_WB_COLOR_GAINS,      /**< White balance color gain manual control.
209                                         Refers to the color channels of a non-sompressed image.
210                                         This is specific setting, valid only in gesture operating modes:
211                                         VCAM_GESTURE_MODE and VCAM_STEREO_GEST_MODE (@see VisionCamCaptureMode).
212                                         @see VisionCamWhiteBalGains.
213                                         @note This functionallity might not be enabled for some devices.
214                                     */
216     VCAM_PARAM_GAMMA_TBLS,          /**< 3A gamma table coefficients manual control.
217                                         This is specific setting, valid only in gesture operating modes:
218                                         VCAM_GESTURE_MODE and VCAM_STEREO_GEST_MODE (@see VisionCamCaptureMode).
219                                         @see VisionCamGammaTableType
220                                     */
222     VCAM_PARAM_ROTATION,            /**< Preview frame rotation.
223                                         Pointer to an unsigned integer value must be passed,
224                                         which will represent the degrees of rotation.
225                                         Possible values are: 0, 90, 180, 270 in degrees.
226                                         @see VisionCamRotation_e
227                                     */
229     VCAM_PARAM_MIRROR,              /**< Sensor mirroring depending on the sensor,
230                                         this setting will provide HW or SW mirroring of the image.
231                                         @see VisionCamMirrorType
232                                     */
234     VCAM_PARAM_STEREO_INFO,         /**< Stereo image layout and subsampling.
235                                       @see VisionCamStereoInfo
236                                     */
238     VCAM_PARAM_AWB_MIN_DELAY_TIME,  /**< This will stop white balance algorithm for a certain period of time.
239                                         When this time expires, WB algorithm will start again and will smoothly
240                                         change WB parameters until they reach the values that suit to the light conditions.
241                                         Parameter is pointer to unsigned integer value,
242                                         which represents the delay time in millseconds.
243                                     */
245     VCAM_PARAM_GESTURES_INFO,       /**< Notify the camera auto algorithms that a gesture is detected, and gives location
246                                         of the region of interest.
247                                     */
249     VCAM_PARAM_AGC_MIN_DELAY_TIME,  /**< This will stop exposure gain recalculations for a certain period of time.
250                                         When this time expires, exposure algorithms will smooth
251                                         the light conditions.
252                                         Parameter is pointer to unsigned integer value,
253                                         which represents the delay time in millseconds.
254                                     */
256     VCAM_PARAM_AGC_LOW_TH,          /**< Automatic gain control low threshold.
257                                         Pointer to an integer value must be passed.
258                                         Ragne is 0 - 10000.
259                                     */
261     VCAM_PARAM_AGC_HIGH_TH,         /**< Automatic gain control high threshold.
262                                         Pointer to an integer value must be passed.
263                                         Ragne is 0 - 10000.
264                                     */
266     VCAM_PARAM_2DBUFFER_DIM,        /**< Used to get buffer allocation information.
267                                       This information is limited to 2D buffer dimensions (width and height).
268                                       @see VisionCamResType
269                                     */
271     VCAM_PARAM_PATH,                /**<
272                                     */
274     VCAM_PARAM_MAX
275 } VisionCamParam_e;
277 /** @enum VisionCamExtraDataType_e
278   * Defines which meta data type to be transferred.
279   * @see VCAM_EXTRA_DATA_START
280   * @see VCAM_EXTRA_DATA_STOP
281 */
282 typedef enum _vcam_extradatatypes_e
284    VCAM_EXTRA_DATA_NONE = 0,
285 //     VCAM_EXIF_ATTRIBUTES,
286     VCAM_ANCILLARY_DATA,
287     VCAM_WHITE_BALANCE,
288     VCAM_UNSATURATED_REGIONS,
289     VCAM_FACE_DETECTION,
290 //     VCAM_BARCODE_DETECTION,
291 //     VCAM_FRONT_OBJECT_DETECTION,
292 //     VCAM_MOTION_ESTIMATION,
293     VCAM_MTIS_TYPE,
294 //     VCAM_DISTANCE_ESTIMATION,
295     VCAM_HISTOGRAM,
296     VCAM_FOCUS_REGION,
297 //     VCAM_EXTRA_DATA_PAN_AND_SCAN,
298 //     VCAM_RAW_FORMAT,
299 //     VCAM_SENSOR_TYPE,
300 //     VCAM_SENSOR_CUSTOM_DATA_LENGTH,
301 //     VCAM_SENSOR_CUSTOM_DATA,
302     VCAM_MANUAL_WHITE_BALANCE,
303     VCAM_EXTRA_DATA_TYPE_MAX
304 } VisionCamExtraDataType_e;
306 /** @enum VisionCamFlickerType
307   * Possible flicker avoidance modes.
308   * @see VCAM_PARAM_FLICKER
309 */
310 typedef enum _flicker_type
312     FLICKER_OFF,                    /**< No flicker correction. */
313     FLICKER_AUTO,                   /**< Automatic flicker correction. */
314     FLICKER_50Hz,                   /**< 50 Hz flicker  correction. */
315     FLICKER_60Hz,                   /**< 60 Hz flicker correction. */
316     FLICKER_100Hz = FLICKER_50Hz,   /**< 100 Hz flicker correction. */
317     FLICKER_120Hz = FLICKER_60Hz,   /**< 120 Hz flicker correction. */
319     FLICKER_MAX = 0X7fffffff
320 }VisionCamFlickerType;
322 /** @enum VisionCamRotation_e
323   * Enumatarion that is used to configure
324   * HW rotation of preview frames.
325   * @see VCAM_PARAM_ROTATION
326 */
327 typedef enum _vcam_rotation_e {
328     VCAM_ROTATION_0     = 0,    /**< No rotation. */
329     VCAM_ROTATION_90    = 90,   /**< Rotate 90 degrees right. */
330     VCAM_ROTATION_180   = 180,  /**< Rotate 180 degrees */
331     VCAM_ROTATION_270   = 270   /**< Rotate 270 degrees right*/
332 }VisionCamRotation_e;
334 /** @enum VisionCamSensorSelection
335   * Defines different sensors.
336   * @see VCAM_PARAM_SENSOR_SELECT
337 */
338 typedef enum _sensor_selection
340     VCAM_SENSOR_PRIMARY = 0,    /**< Usually this is the sensor on the back of the device. */
341     VCAM_SENSOR_SECONDARY = 1,  /**< usually, this is the sensor at the front of the device. */
342     VCAM_SENSOR_STEREO = 2,     /**< In case os stereo cameras, this is stereo use case. */
344     VCAM_SENSOR_MAX = 0x7fffffff
345 }VisionCamSensorSelection;
347 /** @enum VisionCamStereoLayout
348   * Defines possible stereo imaging layouts.
349   * @see VisionCamStereoInfo
350 */
351 typedef enum _stereo_layout
353     VCAM_STEREO_LAYOUT_TOPBOTTOM,   /**< Left and right frames are located one above the other. */
354     VCAM_STEREO_LAYOUT_LEFTRIGHT,   /**< Left and right frames are located next to each other. */
356     VCAM_STEREO_LAYOUT_MAX
357 } VisionCamStereoLayout;
359 /** @enum VisionCamCaptureMode
360   * Defines possible camera operating modes.
361 */
362 typedef enum _capture_mode
364     VCAM_VIDEO_NORMAL,      /**< Normal vide processing pipe. */
365     VCAM_VIDEO_HIGH_SPEED,  /**< High speed video processing pipe. */
366     VCAM_GESTURE_MODE,      /**< Video pipe optimized for gesture computations. */
367     VCAM_STEREO_MODE,       /**< Normal stereo pipe. */
368     VCAM_STEREO_GEST_MODE,  /**< stereo pipe, optimized for gesture computations. */
369 #if defined(__QNX__)
370     VCAM_VIEWFINDER_MODE,
371 #endif
373     VCAM_CAP_MODE_MAX
374 }VisionCamCaptureMode;
376 /** @enum VisionCamGestureEvent_e
377   * Defines different gesture events.
378 */
379 typedef enum _vcam_gesture_event_e {
380     VCAM_GESTURE_EVENT_INVALID = 0, /**< No or invalid gesture event. Could also mean incompatible software version. */
381     VCAM_GESTURE_EVENT_SWIPE_LEFT,  /**< Swipe to the left. */
382     VCAM_GESTURE_EVENT_SWIPE_RIGHT, /**< Swite to the right. */
383     VCAM_GESTURE_EVENT_FIST_LEFT,   /**< Fist turned to left. */
384     VCAM_GESTURE_EVENT_FIST_RIGHT,  /**< Fist turned to right. */
386     VCAM_GESTURE_EVENT_MAX,
387 } VisionCamGestureEvent_e;
389 /** @enum VisionCamFocusMode
390   * Defines focus modes.
391 */
392 typedef enum _vcam_focus_mode
394     VCAM_FOCUS_CONTROL_ON = 0,                  /**< Focus is enabled. */
395     VCAM_FOCUS_CONTROL_OFF,                     /**< Focus is disabled. */
396     VCAM_FOCUS_CONTROL_AUTO,                    /**< Continuous autofocus is enabled. */
397     VCAM_FOCUS_CONTROL_AUTO_LOCK,               /**< Single autoficus enabled - once fous position of lens is reached, focus algorithm stops. */
398     /// TI extension follow
399     VCAM_FOCUS_CONTRO_AUTO_MACRO,               /**< Auto focus in macro mode. */
400     VCAM_FOCUS_CONTROL_AUTO_INFINITY,           /**< Infinity focus mode. */
401     VCAM_FOCUS_FACE_PRIORITY_MODE,              /**< Emphasis of focus algorithm is the output of face detect. */
402     VCAM_FOCUS_REGION_PRIORITY_MODE,            /**< Focuses on given regions. */
403     VCAM_FOCUS_CONTROL_HYPERFOCAL,              /**<  */
404     VCAM_FOCUS_CONTROL_PORTRAIT,                /**<  */
405     VCAM_FOCUS_CONTROL_EXTENDED,                /**<  */
406     VCAM_FOCUS_CONTROL_CONTINOUS_NORMAL,        /**<  */
407     VCAM_FOCUS_CONTROL_CONTINOUS_EXTENDED,      /**<  */
408     VCAM_FOCUS_FACE_PRIORITY_CONTINOUS_MODE,    /**<  */
409     VCAM_FOCUS_REGION_PRIORITY_CONTINOUS_MODE,  /**<  */
410     VCAM_FOCUS_CONTROL_MAX
411 }VisionCamFocusMode;
413 /** @struct VisionCamStereoInfo
414   * Configuration for stereo operating modes.
415 */
416 typedef struct _vcam_stereo_info_t {
417     VisionCamStereoLayout layout;       /**< Stereo image layout: top bottom or side by side.*/
418     uint32_t               subsampling; /**< Set to 1 if you are setting your
419                                             dimensions manually to double to desire value.
420                                             Set to 2 if you want to compress the two images
421                                             into a normal image.
422                                         */
423 } VisionCamStereoInfo;
425 /** @enum VisionCamLockState
426   * Defines enable and disable modes used for variety of settings.
427 */
428 typedef enum _vcam_lock_state
430     UNLOCKED    = false,
431     LOCKED      = true
432 }VisionCamLockState;
434 /** @enum VisionCamResolIdex
435   * Defines VisionCam resolutions.
436   * @see VisionCamResolutions
437   * @see VisionCamResType
438 */
439 typedef enum _e_resol_index
441     VCAM_RES_2MP = 0,   /**< 1600 x 1200 pixels */
442     VCAM_RES_1_25MP,    /**< 1300 x 976 pixels */
443     VCAM_RES_720p,      /**< 1280 x 720 pixels */
444     VCAM_RES_SVGA,      /**< 800 x 480 pixels */
445     VCAM_RES_D1PAL,     /**< 720 x 576 pixels */
446     VCAM_RES_D1NTSC,    /**< 720 x 480 pixels */
447     VCAM_RES_PAL,       /**< 768 x 576 pixels */
448     VCAM_RES_VGA,       /**< 640 x 480 pixels */
449     VCAM_RES_CIF,       /**< 352 x 288 pixels */
450     VCAM_RES_QVGA,      /**< 320 x 240 pixels */
451     VCAM_RES_QCIF,      /**< 176 x 144 pixels */
452     VCAM_RES_QQVGA,     /**< 160 x 120 pixels */
453     VCAM_RES_SQCIF,     /**< 128 x 96 pixels */
454     VCAM_RES_SXVGA,     /**< 1280 x 960 pixels */
456     VCAM_RESOL_MAX
457 }VisionCamResolIdex;
459 /** @struct VisionCamResType
460   * Packs resolution index and resolutin sizes for supported resolutins.
461   * @see VisionCamResolIdex
462 */
463 typedef struct _res_type
465     VisionCamResolIdex mResIdx; /**< VisionCam defined resolution index. */
466     uint32_t            mWidth; /**< Width in pixels. */
467     uint32_t            mHeight;/**< Height in pixels. */
468 }VisionCamResType;
470 /** VisionCamResolutions[]
471   * Predefined resolution indexes and sizes.
472   * The only possible for VisionCam.
473 */
474 const VisionCamResType VisionCamResolutions[] = {
475     { VCAM_RES_2MP    , 1600, 1200 },
476     { VCAM_RES_1_25MP , 1300, 976  },
477     { VCAM_RES_720p   , 1280, 720  },
478     { VCAM_RES_SVGA   , 800 , 480  },
479     { VCAM_RES_D1PAL  , 720 , 576  },
480     { VCAM_RES_D1NTSC , 720 , 480  },
481     { VCAM_RES_PAL    , 768 , 576  },
482     { VCAM_RES_VGA    , 640 , 480  },
483     { VCAM_RES_CIF    , 352 , 288  },
484     { VCAM_RES_QVGA   , 320 , 240  },
485     { VCAM_RES_QCIF   , 176 , 144  },
486     { VCAM_RES_QQVGA  , 160 , 120  },
487     { VCAM_RES_SQCIF  , 128 , 96   },
488     { VCAM_RES_SXVGA  , 1280, 960  }
489 };
491 /** @enum VisionCamObjectType
492   * Defines some gesture objects.
493   * These are not the only supported.
494 */
495 typedef enum _vcam_object_type {
496     VCAM_OBJECT_PALM,   /**< Palm */
497     VCAM_OBJECT_FIST,   /**< Fist */
498     VCAM_OBJECT_FACE,   /**< Face */
500     VCAM_OBJECT_MAX
501 }VisionCamObjectType;
503 /** @enum VisionCamWhiteBalType
504   * Defines different white balance modes used by VisionCam
505 */
506 typedef enum _vcam_white_bal_type {
507     VCAM_WHITE_BAL_CONTROL_OFF = 0,         /**< White balance algorithm is turned off. */
508     VCAM_WHITE_BAL_CONTROL_AUTO,            /**< Automatic white balance. */
509     VCAM_WHITE_BAL_CONTROL_SUNLIGHT,        /**< WB optimized for sunny light conditions. */
510     VCAM_WHITE_BAL_CONTROL_CLOUDY,          /**< WB optimized for cloudy light conditions. */
511     VCAM_WHITE_BAL_CONTROL_SHADE,           /**< WB optimized for shaded light conditions. */
512     VCAM_WHITE_BAL_CONTROL_TUNGSTEN,        /**< WB optimized for tungsten (worm) light conditions. */
513     VCAM_WHITE_BAL_CONTROL_FLUORESCENT,     /**< WB optimized for flourescent light conditions. */
514     VCAM_WHITE_BAL_CONTROL_INCANDESCENT,    /**< WB optimized for incadescent (warm) light conditions. */
515     VCAM_WHITE_BAL_CONTROL_FLASH,           /**< WB optimized for camera flash. */
516     VCAM_WHITE_BAL_CONTROL_HORIZON,         /**< WB optimized for landscape sunny conditions.. */
517     VCAM_WHITE_BAL_CONTROL_FACEPRIORITYMODE = 0X7F000001,
519     VCAM_WHITE_BAL_CONTROL_MAX
520 }VisionCamWhiteBalType;
522 /** @enum VisionCamMirrorType
523   * Mirroring of image in frame buffer.
524 */
525 typedef enum _vcam_mirror_type{
526     VCAM_MIRROR_NONE,           /**< No mirror applied. */
527     VCAM_MIRROR_VERTICAL,       /**< Mirror by vertical axis. */
528     VCAM_MIRROR_HORIZONTAL,     /**< Mirror by horizontal axis. */
529     VCAM_MIRROR_BOTH,           /**< Mirror by bith vertical and horizontal axis. */
531     VCAM_MIRROR_MAX
532 }VisionCamMirrorType;
534 /** @enum VisionCamPort_e
535   * Defines different camera output ports.
536   * Sometimes useful as different ports may have different configurations,
537   * also every port outputs a separate image, so one could be used at one process,
538   * while another - on other process.
539   * @note Each frame from a port has a twin on another port. Use frame's timestamp to find the matchin one.
540   *       All ports are synchronised so frames are ouput sequentally.
541   *       Also note that video port is sending frames ONLY when a preview port is sending.
542 */
543 typedef enum _vision_cam_port_e {
544     VCAM_PORT_ALL = 0,  /**< All port listed below. */
545     VCAM_PORT_PREVIEW,  /**< Preview port. */
546     VCAM_PORT_VIDEO,    /**< Video port. */
548     VCAM_PORT_MAX
549 }VisionCamPort_e;
551 /** @enum VCAM_HISTCOMPONENTTYPE
552   * Histogram types.
553   * @see VisionCamHistogram
554 */
555 typedef enum VCAM_HISTCOMPONENTTYPE {
556     VCAM_HISTCOMP_Y = 0,        /**< Luminance histogram (Y) */
557     VCAM_HISTCOMP_YLOG,         /**< Logarithmic luminance histogram (Y)*/
558     VCAM_HISTCOMP_R,            /**< Red histogram component (R)*/
559     VCAM_HISTCOMP_G,            /**< Green histogram component (G)*/
560     VCAM_HISTCOMP_B,            /**< Blue histogram component (B)*/
561     VCAM_HISTCOMP_Cb,           /**< Chroma blue histogram component (Cb)*/
562     VCAM_HISTCOMP_Cr,           /**< Chroma red histogram component (Cr) */
563     VCAM_HISTCOMP_32BIT_PATCH = 0x7FFFFFFF
564 }VCAM_HISTCOMPONENTTYPE;
567 /** @struct VisionCamWhiteBalGains
568   * Manual white balance gain structure.
569   * Contains gain for each color channel.
570   * @see VCAM_PARAM_WB_COLOR_GAINS
571 */
572 typedef struct _white_bal_gains_type{
573     uint16_t mRed;      /**< Red color channel. */
574     uint16_t mGreen_r;  /**< Difference between green and red color. */
575     uint16_t mGreen_b;  /**< Difference between green and blue color. */
576     uint16_t mBlue;     /**< Blue channel. */
577 }VisionCamWhiteBalGains;
579 /** @struct VisionCamAncillary
580   * Ancillary data type definition.
581 */
582 typedef  struct _ancillary_type {
583     uint32_t             nAncillaryDataVersion;     /**< Version of the ancillary data definition implemented by the application in binary coded decimal format. */
584     uint32_t             nFrameNumber;              /**< This is a free-running counter (wraps back to zero at overflow) that is applied to each frame from the sensor whether that frame is not sent or is sent in multiple formats to the host. */
585     uint32_t             nShotNumber;               /**< Indicates the shot number in a multi-shot sequence, counting up from 1 */
586     uint16_t             nInputImageHeight;         /**< Height in pixels of the input image (i.e. from sensor or video decoder) */
587     uint16_t             nInputImageWidth;          /**< Width in pixels of the input image (i.e. from sensor or video decoder) */
588     uint16_t             nOutputImageHeight;        /**< Height in pixels of the image sent to the host */
589     uint16_t             nOutputImageWidth;         /**< Width in pixels of the image sent to the host  */
590     uint16_t             nDigitalZoomFactor;        /**< Digital zoom factor: 10 bits decimal, 6 bits fractional.
591                                                          @note Note: When non-square pixels are sent to the host, as indicated by the pixel aspect ratio ancillary data fields, the digital zoom factor applies in the direction that is the lesser of the pixel aspect ratio fields.
592                                                     */
593     int16_t               nCropCenterColumn;        /**< Defines the center of cropped region with regard to full sensor field of view.   All values are valid, 0x8000 is the left column and 0x7fff is the right column. 0 is the center column.  This is effectively a percentage ranging between +/- 50% */
594     int16_t               nCropCenterRow;           /**< Defines the center of cropped region with regard to full sensor field of view.  All values are valid, 0x8000 is the top row and 0x7fff is the bottom row. 0 is the center row.  This is effectively a percentage ranging between +/- 50%.  */
595     uint16_t             nOpticalZoomValue;         /**< Optical zoom factor: 4 bits decimal, 12 bits fractional */
596     uint8_t               nFlashConfiguration;      /**< Number Logical Flash Sources – Maximum 4 logical Flashes. For each logical flash following two fields will be filled. */
597     uint8_t               nFlashUsage;              /**< 1. Bit 0 and 1 (LSB) - Flash Light Type (00b = Not used; 01b = Xenon; 10b = LED; 11b = Other)
598                                                          2. Bits 2 and 3 – Flash Charging Status (00b = Not charging; 01b = Charging; 10b = Charged; 11b = Error)
599                                                          3. Bits 4 and 5 – Flash Strobe Detection ( 00b = Not supported; 01b = Reserved; 10b = Strobe return light not detected; 11b = Strobe return light detected)
600                                                          4. Bit 6 and 7 - Reserved1. Bit 0 and 1 (LSB) - Flash Light Type (00b = Not used; 01b = Xenon; 10b = LED; 11b = Other)
601                                                     */
602     uint32_t             nFlashStatus;              /**< 1.Bits 0 to 7 -  Flash Mode (bit variable). Flash can support more than one mode.
603                                                            Bit 0 = Capture Flash Mode
604                                                            Bit 1 = Video Light (Torch) Mode
605                                                            Bit 2 = Pre-flash Mode
606                                                            Bit 3 = AF Assist Mode
607                                                            Bit 4 = Privacy Light Mode
608                                                            Bit 5 = Red-eye Reduction Mode
609                                                            Bit 6 = Other Mode 1
610                                                            Bit 7 = Other Mode 2
611                                                         2. Bits 8 to 23 - Flash Control Mode. 2bits/Flash Light Mode
612                                                            00b = Not used
613                                                            01b = Compulsory flash firing
614                                                            10b = Compulsory flash suppression
615                                                            11b = Auto
616                                                         3. Bits 24 to 31 - Flash Intensity
617                                                            0 = Flash did not fire
618                                                            1 = 255 - Flash Intensity or Flash Intensity Identifier1.Bits 0 to 7 -  Flash
619                                                     */
620     uint8_t               nAFStatus;                /**< Auto Focus status
621                                                         FAILED is a single bit independent of the other values.
623                                                         The other values are mutually exclusive
624                                                         OFF=not present or N/A
625                                                         LOCKED=manual
626                                                         RUNNING=auto, active
627                                                         FROZEN=suspended
628                                                     */
629     uint8_t               nAWBStatus;               /**< Auto White Balance status. See explanation in AF status. */
630     uint8_t               nAEStatus;                /**< Auto Exposure status See explanation in AF status. */
631     uint32_t             nExposureTime;             /**< Exposure time in microseconds. */
632     uint16_t             nEVCompensation;           /**< Exposure compensation */
633     uint8_t               nDigitalGainValue;        /**< Digital gain setting */
634     uint8_t               nAnalogGainValue;         /**< Analog gain setting */
635     uint16_t             nCurrentISO;               /**< ISO setting based on reference ISO */
636     uint16_t             nReferenceISO;             /**< Reference ISO for the current sensor */
637     uint8_t               nApertureValue;           /**< Aperture setting */
638     uint8_t               nPixelRange;              /**< Indicates the range of pixel values */
639     uint16_t             nPixelAspectRatio;         /**< Indicates the width corresponding to the aspect ratio (PAR) of the pixels (samples) in the frame to which this ancillary data is attached.  The PAR always indicates the true PAR, unless otherwise indicated in the application-specific documentation. */
640     uint8_t               nCameraShake;             /**< Indicates risk of camera shake. For instance, if exposure time is greater than 1/f but less than 2/f, camera shake can be considered MEDIUM_RISK. If exposure time is greater than 2/f, camera_shake can be considered a HIGH_RISK. */
641     uint16_t             nFocalDistance;            /**< Distance in cm from the camera lens if possible (14 lsbs).  Upper 2 msbs indicate if the lens is set to: infinity (’10), macro (’01), in between (’00), or moving for AF search (’11). */
642     uint64_t             nParameterChangeFlags;     /**< A 32-bit bit mask where each bit represents a sub-set of parameters.  A bit value of ‘0’ indicates that the associated parameter set did not change from the previous frame. A bit value of ‘1’ indicates that the parameter set has changed from the previous frame.
643                                                             0: SEN_EXPOSURE (sensor exp)
644                                                             1: SEN_GAIN (sensor gain ->analogue and digital are in the same field.
645                                                             2: LSC_2D (2d lsc)
646                                                             3: VLDC (Vertical Line Defect Correction)
647                                                             4: ISIF_GAIN
648                                                             5: H3A_WB
649                                                             6: FLASH
650                                                             7: ISP_NOISE_FILTER_1 (iss noise filter)
651                                                             8: GIC (green imbalance correction)
652                                                             9: CFA
653                                                             10: GBCE
654                                                             11: YUV444TO422 (yuv444 to 422)
655                                                             12: EDGE_ENH (Edge enhancement)
656                                                             13: CAR (chromatic aberration reduction)
657                                                             14: LSC_RAD (radial based one - useless)
658                                                             15: DFS (Dark frame subtract)
659                                                             16: DPC (defect pixel correction in ipipeif)
660                                                             17: DPCM
661                                                             18: LPF_H (Low pass filter params for Horizontal resizing)
662                                                             19: LPF_V (Low pass filter params for Vertical resizing)
663                                                             20: CLAMP (ISIF black clamp configuration)
664                                                             21: WB_GAINS (wb gains)
665                                                             22: GAMMA (Gamma)
666                                                             23: RGB2RGB_1
667                                                             24: RGB2YUV
668                                                             25: 3D_LUT (3d lut)
669                                                             26: DPC LUT
670                                                             27: DPC OTF (in ipipe)
671                                                             28: RGB2RGB_2 (after gamma)
672                                                             29: ISP_NOISE_FILTER_2 (iss noise filter)
673                                                             30: CGS (Chroma gain suppression)
674                                                             31: IPIPE_IF_DPC1 (ISIF or VP)
675                                                             32: IPIPE_IF_DPC2 (from SDRAM)
676                                                             33-63: reserved
677                                                     */
678     uint8_t               nNumFacesDetected;        /**< When Face Detect is enabled, this contains the number of faces detected. When face detect is disabled, this number should be set to 0. */
679     uint8_t               nConvergenceMode;         /**< Reserved for future usage. */
680     uint8_t               nConvergenceStatus;       /**< Reserved for future usage. */
681     uint8_t               nDCCStatus;               /**< Reserved for future usage. */
682 }VisionCamAncillary;
684 /** @struct VisionCamHistogram
685   * Histogram data type definition.
686 */
687 typedef struct _histogram_type{
688     uint32_t nBins;                          /**< The number of bins in the histogram */
689     VCAM_HISTCOMPONENTTYPE eComponentType;   /**< Specifies the type of the histogram bins according to enum.
690                                                  It can be selected to generate multiple component types,
691                                                  then the extradata struct is repeated for each component type */
692     uint32_t data[1];
693 }VisionCamHistogram;
695 /** @struct VisionCamMetadata
696   * Image meta data type definition.
697 */
698 typedef struct _metadata_type {
699     VisionCamWhiteBalGains *mAutoWBGains;   /**< Info about auto white balance algorithm output: color gains applied by AWB. */
700     VisionCamWhiteBalGains *mManualWBGains; /**< Info about manual white balance algorithm : color gains applied by user. */
701     VisionCamAncillary     *mAncillary;     /**< Ancillary data. */
702     VisionCamHistogram     *mHistogram2D;   /**< Histogram data for 2D use cases. */
703     VisionCamHistogram     *mHistogramL;    /**< Histogram data for left channel in case of stereoscopic use cases. */
704     VisionCamHistogram     *mHistogramR;    /**< Histogram data for right channel in case of stereoscopic use cases. */
705 }VisionCamMetadata;
707 /** @struct VisionCamGammaTableType
708   * Defines the gamma table data type, that is used while setting manual gamma table coeficients.
709 */
710 typedef struct _gamma_tbl_type {
711     int32_t   mTableSize;   /**< The size of the table. */
712     uint16_t *mRedTable;    /**< Address of the table with red color coeficients. */
713     uint16_t *mGreenTable;  /**< Address of the table with green color coeficients. */
714     uint16_t *mBlueTable;   /**< Address of the table with blue color coeficients. */
715 }VisionCamGammaTableType;
717 /** @struct VisionCamRectType
718   * Definition of rectangle type.
719 */
720 typedef struct _rect_type {
721     int32_t mLeft;      /**< x-axis coordinate of top-left corner of a rectangle. */
722     int32_t mTop;       /**< y-axis coordinate of top-left corner of a rectangle. */
723     uint32_t mWidth;    /**< Width of a rectangle. */
724     uint32_t mHeight;   /**< Height of a rectangle. */
725 }VisionCamRectType;
727 /** @struct VisionCamFaceType
728   * Data type containing the output of face detection algorithm output.
729 */
730 typedef struct _face_type {
731     /**< Detection score between 0 and 100
732          0   means unknown score,
733          1   means least certain,
734          100 means most certain the detection is correct */
735     uint32_t mScore;
736     /**< Coordinates of the face */
737     VisionCamRectType mFacesCoordinates;
738     /**< The orientation of the axis of the detected object.
739          Here roll angle is defined as the angle between the vertical axis of face and the horizontal axis.
740          All angles can have the value of -180 to 180 degree in Q16 format.
741          Some face detection algorithm may not be able to fill in the angles */
742     int32_t mOrientationRoll;
743     int32_t mOrientationYaw;
744     int32_t mOrientationPitch;
745     /**< Represents priority of each object when there are multiple objects detected */
746     uint32_t mPriority;
747 }VisionCamFaceType;
749 /** @struct VisionCamVarFramerateType
750   * Defines the minimum and maximum fps in case a variable frame rate os selected.
751   * Variable frame rate, means that expositions and respectively frame rate are recalculated at any moment.
752 */
753 typedef struct _var_frame_rate_type {
754     uint32_t mMin;  /**< Minimum fps. */
755     uint32_t mMax;  /**< Maximul fps. */
756 }VisionCamVarFramerateType;
758 /** @struct VisionCamObjectRectType
759   * Definition of type, describing an area where an object is detected.
760 */
761 typedef struct _vcam_object_rect_type {
762     VisionCamObjectType mObjType;   /**< The type ofthe object. */
763     int32_t mTop;                   /**< y-axis coordinate of top-left corner of a rectangle. */
764     int32_t mLeft;                  /**< x-axis coordinate of top-left corner of a rectangle. */
765     uint32_t mWidth;                /**< Width of a rectangle. */
766     uint32_t mHeight;               /**< Height of a rectangle. */
767 }VisionCamObjectRectType;
769 #ifdef __cplusplus
770 /** @struct VisionCamGestureInfo
771   * Structure containing information about gesures detected inside the stream.
772 */
773 struct  VisionCamGestureInfo {
774     ~VisionCamGestureInfo()
775     {
776         if( mRegions )
777             delete [] mRegions;
778     }
779     VisionCamGestureEvent_e mGestureType;   /**< Type of the gesture event. */
780     uint64_t timeStamp;                     /**< Timestamp of the frame in which this is detected. */
781     uint32_t mRegionsNum;                   /**< The number of the regions in frame, where it is detected. */
782     VisionCamObjectRectType *mRegions;      /**< Coordinateds and gesture object for each region. */
783 };
784 #else
785 /** @struct VisionCamGestureInfo
786   * Structure containing information about gesures detected inside the stream.
787 */
788 typedef struct  _vcam_gesture_info_type {
789     VisionCamGestureEvent_e mGestureType;   /**< Type of the gesture event. */
790     uint64_t timeStamp;                     /**< Timestamp of the frame in which this is detected. */
791     uint32_t mRegionsNum;                   /**< The number of the regions in frame, where it is detected. */
792     VisionCamObjectRectType *mRegions;      /**< Coordinateds and gesture object for each region. */
793 } VisionCamGestureInfo;
794 #endif // __cplusplus
796 /** @class VisionCamClientNotifier
797   * User notification class.
798   * This is used to notify client when an extarnal camera event occur.
799 */
800 class VisionCamClientNotifier {
801 public:
802     /**< @enum VisionCamClientNotificationMsg
803       * Defines some possible events that may occur outside VisionCam.
804     */
805     typedef enum _vcam_client_notification_msg_type{
806         VCAM_MESSAGE_EMPTY,                     /**< Unknown event occur. */
807         VCAM_MESSAGE_ALLOCATE_V4L2_BUFFERS,     /**< User may allocate image resources (this is in case resources were previously freed, bacause of external event). */
808         VCAM_MESSAGE_FREE_V4L2_BUFFERS,         /**< User must free allocated resources. */
809         VCAM_MESSAGE_PREEMPT_SUSPEND_ACTIVITY,  /**< Camera has been preempted by a higher priority process, so VisionCam will suspend. This means frames will not be received for some time. */
810         VCAM_MESSAGE_PREEMPT_RESUME_ACTIVITY,   /**< VisionCam has got back its control over camera. */
811         VCAM_MESSAGE_PREEMPT_WAIT_RESOURCES,    /**<  */
812         VCAM_MESSAGE_PREAMPT_REASOURCES_READY,  /**<  */
814         VCAM_MESSAGE_MAX
815     }VisionCamClientNotificationMsg;
817     typedef void *(*_vcam_client_notification_callback_type)( _vcam_client_notification_msg_type );
818     typedef _vcam_client_notification_callback_type VisionCamClientNotifierCallback;
820 public:
821     /// Constructor
822     VisionCamClientNotifier()
823     {
824         mNotificationCallback = NULL;
825     }
827     /// The notification function, that user will register.
828     VisionCamClientNotifierCallback mNotificationCallback;
829 };
831 /** @class VisionCamFrame
832   *
833   * Frame descriptor class. Holds preview a frame
834   * and carries all the data related to it.
835 */
836 class VisionCamFrame
838 public:
840     /** default contrustor */
841     VisionCamFrame() {
842       clear();
843     }
845     /** copy constructor */
846     VisionCamFrame(const VisionCamFrame &frame) :
847         mCookie(frame.mCookie),
848         mFrameBuff(frame.mFrameBuff),
849         mExtraDataBuf(frame.mExtraDataBuf),
850         mFrameSource(frame.mFrameSource),
851         mFd(frame.mStartY),
852         mTimestamp(frame.mTimestamp),
853         mWidth(frame.mWidth),
854         mHeight(frame.mHeight),
855         mOffsetX(frame.mOffsetX),
856         mOffsetY(frame.mOffsetY),
857         mLength(frame.mLength),
858         mExtraDataLength(frame.mExtraDataLength),
859         mMetadata(frame.mMetadata),
860         mDetectedFacesNum(frame.mDetectedFacesNum)
861         {
862             if( mDetectedFacesNum )
863                 memcpy( &mFaces, &frame.mFaces, mDetectedFacesNum*sizeof(VisionCamFaceType));
864             else
865                 memset( &mFaces, 0, sizeof(VisionCamFaceType)*MAX_FACES_COUNT);
866         };
868     /** This clears all values */
869     void clear() {
870       mContext = NULL;
871       mCookie = NULL;
872       mFrameBuff = NULL;
873       mExtraDataBuf = NULL;
874       mFrameSource = VCAM_PORT_PREVIEW; // default to the common preview port
875       mFd = 0;
876       mTimestamp = 0;
877       mWidth = 0;
878       mHeight = 0;
879       mOffsetX = 0;
880       mOffsetY = 0;
881       mStartX = 0;
882       mStartY = 0;
883       mLength = 0;
884       mExtraDataLength = 0;
885       mMetadata.mAncillary = NULL;
886       mMetadata.mAutoWBGains = NULL;
887       mMetadata.mManualWBGains = NULL;
888       mDetectedFacesNum = 0;
889       memset(&mFaces, 0, sizeof(mFaces));
890     }
892     /** This serializes all data in the frame into a flat buffer */
893     size_t serialize(uint8_t *buffer, size_t len);
895     /** This unserializes all the data from a flat buffer back into the instance class object */
896     size_t unserialize(uint8_t *buffer, size_t len);
898     /** This returns the max possible size (as currently allocated) of the frame for the purpose of allocating flat memory for serialization */
899     size_t maxSerialLength();
901 public:
902     void *mContext;                 /**< Indicates in which context this frame is set (which VisionCam instance at all). */
903     void *mCookie;                  /**< The cookie data. */
904     void *mFrameBuff;               /**< The image buffer. */
905     void *mExtraDataBuf;            /**< Extra data buffer. */
906     VisionCamPort_e mFrameSource;   /**< The index of the port from which this frame has arrived. */
907     int32_t mFd;                    /**<  */
908     int64_t mTimestamp;             /**< The timestamp for the frame.
909                                       * The timestanp is unique for each frame on a port
910                                       * but when multiple ports are running, the timestamp
911                                       * is the same for the matching frames on different ports.
912                                     */
913     uint32_t mWidth;                /**< Frame width. */
914     uint32_t mHeight;               /**< Frame haight. */
915     uint32_t mOffsetX;              /**< The offset in X-direction of the actual frame data inside the buffer. */
916     uint32_t mOffsetY;              /**< The offset in Y-direction of the actual frame data inside the buffer. */
917     uint32_t mStartX;               /**<  */
918     uint32_t mStartY;               /**<  */
919     uint32_t mLength;               /**< The image size in bytes. */
920     uint32_t mExtraDataLength;      /**< Size in bytes if extra data buffer. */
921     VisionCamMetadata mMetadata;    /**< Parsed meta data. */
922     uint32_t mDetectedFacesNum;     /**< Number of faces detected in this frame. */
923     VisionCamFaceType mFaces[ MAX_FACES_COUNT ];    /**< Informatin about detected faces. */
924 };
927 /** @class VisionCamFramePack
928   * A frame holder.
929   * This structure keeps the matching frames from all possinble sources.
930   * This is used when packaging option is enabled.
931   * Packaging is based on frame timestamp.
932 */
933 class VisionCamFramePack
935 public:
936     VisionCamFramePack(){
937         for( int32_t i = 0; i < VCAM_PORT_MAX; i++) {
938             mFrame[i] = NULL;
939             mExpectedFrames[i] = false;
940         }
941         mTimestamp = 0;
942         mIsEmpty = true;
943     }
945     VisionCamFrame *mFrame[VCAM_PORT_MAX];  /**< Addresses of all the frames from all running sources */
946     int64_t         mTimestamp;             /**< Timestamp of these frames. The same for all*/
948     bool          mExpectedFrames[VCAM_PORT_MAX]; /**< Which frames must be written,
949                                                         corresponds to the frame sourcs state (running or not).
950                                                     */
952     bool          mIsEmpty;                       /**< Read only field:
953                                                         true when there is a valid data inside mFrame[]
954                                                         false when there is no valid data inside mFrame[]
955                                                     */
956 };
958 /** @typedef Frame callback type.
959 */
960 typedef void (*FrameCallback_f)(VisionCamFrame *cameraFrame);
962 /** @typedef Frame callback type,
963   * used to pass multiple frames in a single shot.
964 */
965 typedef void (*FramePackCallback_f)(VisionCamFramePack *cameraFramePacket);
967 /** @typedef Focus callback type.
968 */
969 typedef void ( * FocusCallback_t )(int);
971 /** VisionCam is a Mixin pattern which defines the abstract interface to the
972  * class which wraps the physical Camera and/or the USB/File based alternatives
973  * while implementing some of the common features of the class.
974  */
975 class VisionCam
977 protected:
978     FrameCallback_f m_callback;             /**< The default callback for preview frames */
979     FramePackCallback_f m_pack_callback;    /**< The callback for frames received from all ports and sent in a single call to user*/
980     FocusCallback_t m_focuscallback;        /**< The default focus callback */
981     void * m_cookie;                        /**< The protected cookie data to pass to the m_callback */
982     uint32_t m_frameNum;                    /**< The current number of frames delivered since instantiation */
983 public:
984     VisionCam():
985       m_callback(NULL),
986       m_pack_callback(NULL),
987       m_focuscallback(NULL),
988       m_cookie(NULL),
989       m_frameNum(0) {}
991     /** Deconstructor */
992     virtual ~VisionCam() {}
994     /** Initializing method */
995     virtual int init(void *cookie) = 0;
997     /** Deinitializer */
998     virtual int deinit() = 0;
1000     /** This method informs the VisionCam to use the supplied buffer */
1001     virtual int useBuffers( BufferMeta* meta, uint32_t num_images, VisionCamPort_e port = VCAM_PORT_PREVIEW) = 0;
1003     /**  This method informs the VisionCam to stop using the supplied buffers */
1004     virtual int releaseBuffers( VisionCamPort_e port = VCAM_PORT_PREVIEW ) = 0;
1006     /** This method informs the VisionCam to recall any outstanding buffers from remote cores or to drop pending copies */
1007     virtual int flushBuffers( VisionCamPort_e port = VCAM_PORT_PREVIEW ) = 0;
1009     /** This method informs the VisionCam to execute some additional functionality */
1010     virtual int sendCommand( VisionCamCmd_e cmdId, void *param = NULL, uint32_t size = 0, VisionCamPort_e port = VCAM_PORT_PREVIEW) = 0;
1012     /** This method informs the VisionCam to configure itself with the supplied parameters */
1013     virtual int setParameter( VisionCamParam_e paramId, void* param = NULL, uint32_t size = 0, VisionCamPort_e port = VCAM_PORT_PREVIEW) = 0;
1015     /** This method informs the VisionCam to configure itself with the supplied parameters */
1016     virtual int getParameter( VisionCamParam_e paramId, void* param = NULL, uint32_t size = 0, VisionCamPort_e port = VCAM_PORT_PREVIEW) = 0;
1018     /** This method returns a used buffer to the VisionCam to use again in the future */
1019     virtual int returnFrame( VisionCamFrame *cameraFrame ) = 0;
1021 public:
1022     // Implemented Functions in this Mixin
1024     /** This returns the number of frames read from the camera since initialization */
1025     uint32_t GetFrameNumber();
1027     /** This method informs the VisionCam to enable the callback to the client which informs the client about the preview frame */
1028     int enablePreviewCbk(FrameCallback_f callback) {
1029       int greError = 0;
1030       if (m_callback == NULL) {
1031         m_callback = callback;
1032       } else {
1033         greError = -EBADE;
1034       }
1035       return greError;
1036     }
1038     /** This method informs the VisionCam to enable the callback to the client which informs the client about all frames */
1039     int enablePackedFramesCbk(FramePackCallback_f callback) {
1040       int greError = 0;
1041       if (m_pack_callback == NULL) {
1042         m_pack_callback = callback;
1043       } else {
1044         greError = -EBADE;
1045       }
1046       return greError;
1047     }
1049     /** This method informs the VisionCam to disable the preview frame m_callback */
1050     int disablePreviewCbk(FrameCallback_f callback) {
1051     int greError = 0;
1052     if (callback == m_callback) {
1053       m_callback = NULL;
1054     } else {
1055       greError = -EBADE;
1056     }
1057     return greError;
1060     /** This method informs the VisionCam to disable the packed frames callback */
1061     int disablePackedFramesCbk(FramePackCallback_f callback) {
1062       int greError = 0;
1063       if (callback == m_pack_callback) {
1064         m_pack_callback = NULL;
1065       } else {
1066         greError = -EBADE;
1067       }
1068       return greError;
1069     }
1072     /** This method give the focus callback to camera */
1073     int setFocusCallBack(FocusCallback_t callback) {
1074       m_focuscallback = callback;
1075       return 0;
1076     }
1078 };
1080 uint32_t GetImageSize(uint32_t width, uint32_t height, uint32_t fourcc);
1082 #endif