summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/videodev2_samsung.h656
-rw-r--r--libcamera/SecCamera.cpp254
-rw-r--r--libcamera/SecCamera.h298
-rw-r--r--libcamera/SecCameraHWInterface.cpp113
4 files changed, 748 insertions, 573 deletions
diff --git a/include/videodev2_samsung.h b/include/videodev2_samsung.h
index d4d9e08..074aab5 100644
--- a/include/videodev2_samsung.h
+++ b/include/videodev2_samsung.h
@@ -1,7 +1,7 @@
/*
* Video for Linux Two header file for samsung
*
- * Copyright (C) 2009, Dongsoo Nathaniel Kim<dongsoo45.kim@samsung.com>
+ * Copyright (C) 2009, Samsung Electronics
*
* This header file contains several v4l2 APIs to be proposed to v4l2
* community and until bein accepted, will be used restrictly in Samsung's
@@ -26,60 +26,606 @@
*/
#ifndef __LINUX_VIDEODEV2_SAMSUNG_H
+#define __LINUX_VIDEODEV2_SAMSUNG_H
-#define V4L2_CID_CAM_FW_MINOR_VER (V4L2_CID_PRIVATE_BASE + 24)
-#define V4L2_CID_CAM_FW_MAJOR_VER (V4L2_CID_PRIVATE_BASE + 25)
-#define V4L2_CID_CAM_PRM_MINOR_VER (V4L2_CID_PRIVATE_BASE + 26)
-#define V4L2_CID_CAM_PRM_MAJOR_VER (V4L2_CID_PRIVATE_BASE + 27)
-#define V4L2_CID_CAMERA_VT_MODE (V4L2_CID_PRIVATE_BASE + 48)
-#define V4L2_CID_CAMERA_VGA_BLUR (V4L2_CID_PRIVATE_BASE + 49)
-#define V4L2_CID_CAMERA_CAPTURE (V4L2_CID_PRIVATE_BASE + 50)
-
-#define V4L2_CID_CAMERA_SCENE_MODE (V4L2_CID_PRIVATE_BASE + 70)
-#define V4L2_CID_CAMERA_FLASH_MODE (V4L2_CID_PRIVATE_BASE + 71)
-#define V4L2_CID_CAMERA_BRIGHTNESS (V4L2_CID_PRIVATE_BASE + 72)
-#define V4L2_CID_CAMERA_WHITE_BALANCE (V4L2_CID_PRIVATE_BASE + 73)
-#define V4L2_CID_CAMERA_EFFECT (V4L2_CID_PRIVATE_BASE + 74)
-#define V4L2_CID_CAMERA_ISO (V4L2_CID_PRIVATE_BASE + 75)
-#define V4L2_CID_CAMERA_METERING (V4L2_CID_PRIVATE_BASE + 76)
-#define V4L2_CID_CAMERA_CONTRAST (V4L2_CID_PRIVATE_BASE + 77)
-#define V4L2_CID_CAMERA_SATURATION (V4L2_CID_PRIVATE_BASE + 78)
-#define V4L2_CID_CAMERA_SHARPNESS (V4L2_CID_PRIVATE_BASE + 79)
-#define V4L2_CID_CAMERA_WDR (V4L2_CID_PRIVATE_BASE + 80)
-#define V4L2_CID_CAMERA_ANTI_SHAKE (V4L2_CID_PRIVATE_BASE + 81)
-#define V4L2_CID_CAMERA_TOUCH_AF_START_STOP (V4L2_CID_PRIVATE_BASE + 82)
-#define V4L2_CID_CAMERA_SMART_AUTO (V4L2_CID_PRIVATE_BASE + 83)
-#define V4L2_CID_CAMERA_VINTAGE_MODE (V4L2_CID_PRIVATE_BASE + 84)
-#define V4L2_CID_CAMERA_GPS_LATITUDE (V4L2_CID_CAMERA_CLASS_BASE + 30)
-#define V4L2_CID_CAMERA_GPS_LONGITUDE (V4L2_CID_CAMERA_CLASS_BASE + 31)
-#define V4L2_CID_CAMERA_GPS_TIMESTAMP (V4L2_CID_CAMERA_CLASS_BASE + 32)
-#define V4L2_CID_CAMERA_GPS_ALTITUDE (V4L2_CID_CAMERA_CLASS_BASE + 33)
-#define V4L2_CID_CAMERA_ZOOM (V4L2_CID_PRIVATE_BASE + 90)
-#define V4L2_CID_CAMERA_FACE_DETECTION (V4L2_CID_PRIVATE_BASE + 91)
-#define V4L2_CID_CAMERA_SMART_AUTO_STATUS (V4L2_CID_PRIVATE_BASE + 92)
-#define V4L2_CID_CAMERA_SET_AUTO_FOCUS (V4L2_CID_PRIVATE_BASE + 93)
-#define V4L2_CID_CAMERA_BEAUTY_SHOT (V4L2_CID_PRIVATE_BASE + 94)
-#define V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK (V4L2_CID_PRIVATE_BASE + 95)
-#define V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK (V4L2_CID_PRIVATE_BASE + 96)
-#define V4L2_CID_CAMERA_OBJECT_POSITION_X (V4L2_CID_PRIVATE_BASE + 97)
-#define V4L2_CID_CAMERA_OBJECT_POSITION_Y (V4L2_CID_PRIVATE_BASE + 98)
-#define V4L2_CID_CAMERA_FOCUS_MODE (V4L2_CID_PRIVATE_BASE + 99)
-#define V4L2_CID_CAMERA_OBJ_TRACKING_STATUS (V4L2_CID_PRIVATE_BASE + 100)
-#define V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP (V4L2_CID_PRIVATE_BASE + 101)
-#define V4L2_CID_CAMERA_CAF_START_STOP (V4L2_CID_PRIVATE_BASE + 102)
-#define V4L2_CID_CAMERA_AUTO_FOCUS_RESULT (V4L2_CID_PRIVATE_BASE + 103)
-#define V4L2_CID_CAMERA_FRAME_RATE (V4L2_CID_PRIVATE_BASE + 104)
-#define V4L2_CID_CAMERA_ANTI_BANDING (V4L2_CID_PRIVATE_BASE + 105)
-#define V4L2_CID_CAMERA_SET_GAMMA (V4L2_CID_PRIVATE_BASE + 106)
-#define V4L2_CID_CAMERA_SET_SLOW_AE (V4L2_CID_PRIVATE_BASE + 107)
-#define V4L2_CID_CAMERA_BATCH_REFLECTION (V4L2_CID_PRIVATE_BASE + 108)
-#define V4L2_CID_CAMERA_EXIF_ORIENTATION (V4L2_CID_PRIVATE_BASE + 109)
-#define V4L2_CID_CAMERA_RESET (V4L2_CID_PRIVATE_BASE + 111)
-#define V4L2_CID_CAMERA_CHECK_DATALINE (V4L2_CID_PRIVATE_BASE + 112)
-#define V4L2_CID_CAMERA_CHECK_DATALINE_STOP (V4L2_CID_PRIVATE_BASE + 113)
-#define V4L2_CID_CAMERA_GET_ISO (V4L2_CID_PRIVATE_BASE + 114)
-#define V4L2_CID_CAMERA_GET_SHT_TIME (V4L2_CID_PRIVATE_BASE + 115)
-#define V4L2_CID_CAMERA_SENSOR_MODE (V4L2_CID_PRIVATE_BASE + 116)
-#define V4L2_CID_ESD_INT (V4L2_CID_PRIVATE_BASE + 117)
+/* Values for 'capabilities' field */
+/* Object detection device */
+#define V4L2_CAP_OBJ_RECOGNITION 0x10000000
+/* strobe control */
+#define V4L2_CAP_STROBE 0x20000000
+
+#define V4L2_CID_FOCUS_MODE (V4L2_CID_CAMERA_CLASS_BASE + 17)
+/* Focus Methods */
+enum v4l2_focus_mode {
+ V4L2_FOCUS_MODE_AUTO = 0,
+ V4L2_FOCUS_MODE_MACRO = 1,
+ V4L2_FOCUS_MODE_MANUAL = 2,
+ V4L2_FOCUS_MODE_LASTP = 2,
+};
+
+#define V4L2_CID_ZOOM_MODE (V4L2_CID_CAMERA_CLASS_BASE + 18)
+/* Zoom Methods */
+enum v4l2_zoom_mode {
+ V4L2_ZOOM_MODE_CONTINUOUS = 0,
+ V4L2_ZOOM_MODE_OPTICAL = 1,
+ V4L2_ZOOM_MODE_DIGITAL = 2,
+ V4L2_ZOOM_MODE_LASTP = 2,
+};
+
+/* Exposure Methods */
+#define V4L2_CID_PHOTOMETRY (V4L2_CID_CAMERA_CLASS_BASE + 19)
+enum v4l2_photometry_mode {
+ V4L2_PHOTOMETRY_MULTISEG = 0, /*Multi Segment */
+ V4L2_PHOTOMETRY_CWA = 1, /*Centre Weighted Average */
+ V4L2_PHOTOMETRY_SPOT = 2,
+ V4L2_PHOTOMETRY_AFSPOT = 3, /*Spot metering on focused point */
+ V4L2_PHOTOMETRY_LASTP = V4L2_PHOTOMETRY_AFSPOT,
+};
+
+/* Manual exposure control items menu type: iris, shutter, iso */
+#define V4L2_CID_CAM_APERTURE (V4L2_CID_CAMERA_CLASS_BASE + 20)
+#define V4L2_CID_CAM_SHUTTER (V4L2_CID_CAMERA_CLASS_BASE + 21)
+#define V4L2_CID_CAM_ISO (V4L2_CID_CAMERA_CLASS_BASE + 22)
+
+/* Following CIDs are menu type */
+#define V4L2_CID_SCENEMODE (V4L2_CID_CAMERA_CLASS_BASE + 23)
+#define V4L2_CID_CAM_STABILIZE (V4L2_CID_CAMERA_CLASS_BASE + 24)
+#define V4L2_CID_CAM_MULTISHOT (V4L2_CID_CAMERA_CLASS_BASE + 25)
+
+/* Control dynamic range */
+#define V4L2_CID_CAM_DR (V4L2_CID_CAMERA_CLASS_BASE + 26)
+
+/* White balance preset control */
+#define V4L2_CID_WHITE_BALANCE_PRESET (V4L2_CID_CAMERA_CLASS_BASE + 27)
+
+/* CID extensions */
+#define V4L2_CID_ROTATION (V4L2_CID_PRIVATE_BASE + 0)
+#define V4L2_CID_PADDR_Y (V4L2_CID_PRIVATE_BASE + 1)
+#define V4L2_CID_PADDR_CB (V4L2_CID_PRIVATE_BASE + 2)
+#define V4L2_CID_PADDR_CR (V4L2_CID_PRIVATE_BASE + 3)
+#define V4L2_CID_PADDR_CBCR (V4L2_CID_PRIVATE_BASE + 4)
+#define V4L2_CID_OVERLAY_AUTO (V4L2_CID_PRIVATE_BASE + 5)
+#define V4L2_CID_OVERLAY_VADDR0 (V4L2_CID_PRIVATE_BASE + 6)
+#define V4L2_CID_OVERLAY_VADDR1 (V4L2_CID_PRIVATE_BASE + 7)
+#define V4L2_CID_OVERLAY_VADDR2 (V4L2_CID_PRIVATE_BASE + 8)
+#define V4L2_CID_OVLY_MODE (V4L2_CID_PRIVATE_BASE + 9)
+#define V4L2_CID_DST_INFO (V4L2_CID_PRIVATE_BASE + 10)
+#define V4L2_CID_IMAGE_EFFECT_FN (V4L2_CID_PRIVATE_BASE + 16)
+#define V4L2_CID_IMAGE_EFFECT_APPLY (V4L2_CID_PRIVATE_BASE + 17)
+#define V4L2_CID_IMAGE_EFFECT_CB (V4L2_CID_PRIVATE_BASE + 18)
+#define V4L2_CID_IMAGE_EFFECT_CR (V4L2_CID_PRIVATE_BASE + 19)
+#define V4L2_CID_RESERVED_MEM_BASE_ADDR (V4L2_CID_PRIVATE_BASE + 20)
+#define V4L2_CID_FIMC_VERSION (V4L2_CID_PRIVATE_BASE + 21)
+
+#define V4L2_CID_STREAM_PAUSE (V4L2_CID_PRIVATE_BASE + 53)
+
+/* CID Extensions for camera sensor operations */
+#define V4L2_CID_CAM_PREVIEW_ONOFF (V4L2_CID_PRIVATE_BASE + 64)
+#define V4L2_CID_CAM_CAPTURE (V4L2_CID_PRIVATE_BASE + 65)
+#define V4L2_CID_CAM_JPEG_MEMSIZE (V4L2_CID_PRIVATE_BASE + 66)
+
+#define V4L2_CID_CAM_DATE_INFO_YEAR (V4L2_CID_PRIVATE_BASE + 14)
+#define V4L2_CID_CAM_DATE_INFO_MONTH (V4L2_CID_PRIVATE_BASE + 15)
+#define V4L2_CID_CAM_DATE_INFO_DATE (V4L2_CID_PRIVATE_BASE + 22)
+#define V4L2_CID_CAM_SENSOR_VER (V4L2_CID_PRIVATE_BASE + 23)
+#define V4L2_CID_CAM_FW_MINOR_VER (V4L2_CID_PRIVATE_BASE + 24)
+#define V4L2_CID_CAM_FW_MAJOR_VER (V4L2_CID_PRIVATE_BASE + 25)
+#define V4L2_CID_CAM_PRM_MINOR_VER (V4L2_CID_PRIVATE_BASE + 26)
+#define V4L2_CID_CAM_PRM_MAJOR_VER (V4L2_CID_PRIVATE_BASE + 27)
+#define V4L2_CID_CAM_FW_VER (V4L2_CID_PRIVATE_BASE + 28)
+#define V4L2_CID_CAM_SET_FW_ADDR (V4L2_CID_PRIVATE_BASE + 29)
+#define V4L2_CID_CAM_SET_FW_SIZE (V4L2_CID_PRIVATE_BASE + 30)
+#define V4L2_CID_CAM_UPDATE_FW (V4L2_CID_PRIVATE_BASE + 31)
+#define V4L2_CID_CAM_JPEG_MAIN_SIZE (V4L2_CID_PRIVATE_BASE + 32)
+#define V4L2_CID_CAM_JPEG_MAIN_OFFSET (V4L2_CID_PRIVATE_BASE + 33)
+#define V4L2_CID_CAM_JPEG_THUMB_SIZE (V4L2_CID_PRIVATE_BASE + 34)
+#define V4L2_CID_CAM_JPEG_THUMB_OFFSET (V4L2_CID_PRIVATE_BASE + 35)
+#define V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET (V4L2_CID_PRIVATE_BASE + 36)
+#define V4L2_CID_CAM_JPEG_QUALITY (V4L2_CID_PRIVATE_BASE + 37)
+#define V4L2_CID_CAM_SENSOR_MAKER (V4L2_CID_PRIVATE_BASE + 38)
+#define V4L2_CID_CAM_SENSOR_OPTICAL (V4L2_CID_PRIVATE_BASE + 39)
+#define V4L2_CID_CAM_AF_VER_LOW (V4L2_CID_PRIVATE_BASE + 40)
+#define V4L2_CID_CAM_AF_VER_HIGH (V4L2_CID_PRIVATE_BASE + 41)
+#define V4L2_CID_CAM_GAMMA_RG_LOW (V4L2_CID_PRIVATE_BASE + 42)
+#define V4L2_CID_CAM_GAMMA_RG_HIGH (V4L2_CID_PRIVATE_BASE + 43)
+#define V4L2_CID_CAM_GAMMA_BG_LOW (V4L2_CID_PRIVATE_BASE + 44)
+#define V4L2_CID_CAM_GAMMA_BG_HIGH (V4L2_CID_PRIVATE_BASE + 45)
+#define V4L2_CID_CAM_DUMP_FW (V4L2_CID_PRIVATE_BASE + 46)
+#define V4L2_CID_CAM_GET_DUMP_SIZE (V4L2_CID_PRIVATE_BASE + 47)
+#define V4L2_CID_CAMERA_VT_MODE (V4L2_CID_PRIVATE_BASE + 48)
+#define V4L2_CID_CAMERA_VGA_BLUR (V4L2_CID_PRIVATE_BASE + 49)
+#define V4L2_CID_CAMERA_CAPTURE (V4L2_CID_PRIVATE_BASE + 50)
+
+#define V4L2_CID_MAIN_SW_DATE_INFO_YEAR (V4L2_CID_PRIVATE_BASE + 54)
+#define V4L2_CID_MAIN_SW_DATE_INFO_MONTH (V4L2_CID_PRIVATE_BASE + 55)
+#define V4L2_CID_MAIN_SW_DATE_INFO_DATE (V4L2_CID_PRIVATE_BASE + 56)
+#define V4L2_CID_MAIN_SW_FW_MINOR_VER (V4L2_CID_PRIVATE_BASE + 57)
+#define V4L2_CID_MAIN_SW_FW_MAJOR_VER (V4L2_CID_PRIVATE_BASE + 58)
+#define V4L2_CID_MAIN_SW_PRM_MINOR_VER (V4L2_CID_PRIVATE_BASE + 59)
+#define V4L2_CID_MAIN_SW_PRM_MAJOR_VER (V4L2_CID_PRIVATE_BASE + 60)
+
+enum v4l2_blur {
+ BLUR_LEVEL_0 = 0,
+ BLUR_LEVEL_1,
+ BLUR_LEVEL_2,
+ BLUR_LEVEL_3,
+ BLUR_LEVEL_MAX,
+};
+
+#define V4L2_CID_CAMERA_SCENE_MODE (V4L2_CID_PRIVATE_BASE + 70)
+enum v4l2_scene_mode {
+ SCENE_MODE_BASE,
+ SCENE_MODE_NONE,
+ SCENE_MODE_PORTRAIT,
+ SCENE_MODE_NIGHTSHOT,
+ SCENE_MODE_BACK_LIGHT,
+ SCENE_MODE_LANDSCAPE,
+ SCENE_MODE_SPORTS,
+ SCENE_MODE_PARTY_INDOOR,
+ SCENE_MODE_BEACH_SNOW,
+ SCENE_MODE_SUNSET,
+ SCENE_MODE_DUST_DAWN,
+ SCENE_MODE_FALL_COLOR,
+ SCENE_MODE_FIREWORKS,
+ SCENE_MODE_TEXT,
+ SCENE_MODE_CANDLE_LIGHT,
+ SCENE_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_FLASH_MODE (V4L2_CID_PRIVATE_BASE + 71)
+enum v4l2_flash_mode {
+ FLASH_MODE_BASE,
+ FLASH_MODE_OFF,
+ FLASH_MODE_AUTO,
+ FLASH_MODE_ON,
+ FLASH_MODE_TORCH,
+ FLASH_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_BRIGHTNESS (V4L2_CID_PRIVATE_BASE + 72)
+enum v4l2_ev_mode {
+ EV_MINUS_4 = 0,
+ EV_MINUS_3,
+ EV_MINUS_2,
+ EV_MINUS_1,
+ EV_DEFAULT,
+ EV_PLUS_1,
+ EV_PLUS_2,
+ EV_PLUS_3,
+ EV_PLUS_4,
+ EV_MAX,
+};
+
+#define V4L2_CID_CAMERA_WHITE_BALANCE (V4L2_CID_PRIVATE_BASE + 73)
+enum v4l2_wb_mode {
+ WHITE_BALANCE_BASE = 0,
+ WHITE_BALANCE_AUTO,
+ WHITE_BALANCE_SUNNY,
+ WHITE_BALANCE_CLOUDY,
+ WHITE_BALANCE_TUNGSTEN,
+ WHITE_BALANCE_FLUORESCENT,
+ WHITE_BALANCE_MAX,
+};
+
+#define V4L2_CID_CAMERA_EFFECT (V4L2_CID_PRIVATE_BASE + 74)
+enum v4l2_effect_mode {
+ IMAGE_EFFECT_BASE = 0,
+ IMAGE_EFFECT_NONE,
+ IMAGE_EFFECT_BNW,
+ IMAGE_EFFECT_SEPIA,
+ IMAGE_EFFECT_AQUA,
+ IMAGE_EFFECT_ANTIQUE,
+ IMAGE_EFFECT_NEGATIVE,
+ IMAGE_EFFECT_SHARPEN,
+ IMAGE_EFFECT_MAX,
+};
+
+#define V4L2_CID_CAMERA_ISO (V4L2_CID_PRIVATE_BASE + 75)
+enum v4l2_iso_mode {
+ ISO_AUTO = 0,
+ ISO_50,
+ ISO_100,
+ ISO_200,
+ ISO_400,
+ ISO_800,
+ ISO_1600,
+ ISO_SPORTS,
+ ISO_NIGHT,
+ ISO_MOVIE,
+ ISO_MAX,
+};
+
+#define V4L2_CID_CAMERA_METERING (V4L2_CID_PRIVATE_BASE + 76)
+enum v4l2_metering_mode {
+ METERING_BASE = 0,
+ METERING_MATRIX,
+ METERING_CENTER,
+ METERING_SPOT,
+ METERING_MAX,
+};
+
+#define V4L2_CID_CAMERA_CONTRAST (V4L2_CID_PRIVATE_BASE + 77)
+enum v4l2_contrast_mode {
+ CONTRAST_MINUS_2 = 0,
+ CONTRAST_MINUS_1,
+ CONTRAST_DEFAULT,
+ CONTRAST_PLUS_1,
+ CONTRAST_PLUS_2,
+ CONTRAST_MAX,
+};
+
+#define V4L2_CID_CAMERA_SATURATION (V4L2_CID_PRIVATE_BASE + 78)
+enum v4l2_saturation_mode {
+ SATURATION_MINUS_2 = 0,
+ SATURATION_MINUS_1,
+ SATURATION_DEFAULT,
+ SATURATION_PLUS_1,
+ SATURATION_PLUS_2,
+ SATURATION_MAX,
+};
+
+#define V4L2_CID_CAMERA_SHARPNESS (V4L2_CID_PRIVATE_BASE + 79)
+enum v4l2_sharpness_mode {
+ SHARPNESS_MINUS_2 = 0,
+ SHARPNESS_MINUS_1,
+ SHARPNESS_DEFAULT,
+ SHARPNESS_PLUS_1,
+ SHARPNESS_PLUS_2,
+ SHARPNESS_MAX,
+};
+
+#define V4L2_CID_CAMERA_WDR (V4L2_CID_PRIVATE_BASE + 80)
+enum v4l2_wdr_mode {
+ WDR_OFF,
+ WDR_ON,
+ WDR_MAX,
+};
+
+#define V4L2_CID_CAMERA_ANTI_SHAKE (V4L2_CID_PRIVATE_BASE + 81)
+enum v4l2_anti_shake_mode {
+ ANTI_SHAKE_OFF,
+ ANTI_SHAKE_STILL_ON,
+ ANTI_SHAKE_MOVIE_ON,
+ ANTI_SHAKE_MAX,
+};
+
+#define V4L2_CID_CAMERA_TOUCH_AF_START_STOP (V4L2_CID_PRIVATE_BASE + 82)
+enum v4l2_touch_af {
+ TOUCH_AF_STOP = 0,
+ TOUCH_AF_START,
+ TOUCH_AF_MAX,
+};
+
+#define V4L2_CID_CAMERA_SMART_AUTO (V4L2_CID_PRIVATE_BASE + 83)
+enum v4l2_smart_auto {
+ SMART_AUTO_OFF = 0,
+ SMART_AUTO_ON,
+ SMART_AUTO_MAX,
+};
+
+#define V4L2_CID_CAMERA_VINTAGE_MODE (V4L2_CID_PRIVATE_BASE + 84)
+enum v4l2_vintage_mode {
+ VINTAGE_MODE_BASE,
+ VINTAGE_MODE_OFF,
+ VINTAGE_MODE_NORMAL,
+ VINTAGE_MODE_WARM,
+ VINTAGE_MODE_COOL,
+ VINTAGE_MODE_BNW,
+ VINTAGE_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_JPEG_QUALITY (V4L2_CID_PRIVATE_BASE + 85)
+#define V4L2_CID_CAMERA_GPS_LATITUDE (V4L2_CID_CAMERA_CLASS_BASE + 30)
+#define V4L2_CID_CAMERA_GPS_LONGITUDE (V4L2_CID_CAMERA_CLASS_BASE + 31)
+#define V4L2_CID_CAMERA_GPS_TIMESTAMP (V4L2_CID_CAMERA_CLASS_BASE + 32)
+#define V4L2_CID_CAMERA_GPS_ALTITUDE (V4L2_CID_CAMERA_CLASS_BASE + 33)
+#define V4L2_CID_CAMERA_EXIF_TIME_INFO (V4L2_CID_CAMERA_CLASS_BASE + 34)
+#define V4L2_CID_CAMERA_ZOOM (V4L2_CID_PRIVATE_BASE + 90)
+enum v4l2_zoom_level {
+ ZOOM_LEVEL_0 = 0,
+ ZOOM_LEVEL_1,
+ ZOOM_LEVEL_2,
+ ZOOM_LEVEL_3,
+ ZOOM_LEVEL_4,
+ ZOOM_LEVEL_5,
+ ZOOM_LEVEL_6,
+ ZOOM_LEVEL_7,
+ ZOOM_LEVEL_8,
+ ZOOM_LEVEL_9,
+ ZOOM_LEVEL_10,
+ ZOOM_LEVEL_11,
+ ZOOM_LEVEL_12,
+ ZOOM_LEVEL_MAX,
+};
+
+#define V4L2_CID_CAMERA_FACE_DETECTION (V4L2_CID_PRIVATE_BASE + 91)
+enum v4l2_face_detection {
+ FACE_DETECTION_OFF = 0,
+ FACE_DETECTION_ON,
+ FACE_DETECTION_NOLINE,
+ FACE_DETECTION_ON_BEAUTY,
+ FACE_DETECTION_MAX,
+};
+
+#define V4L2_CID_CAMERA_SMART_AUTO_STATUS (V4L2_CID_PRIVATE_BASE + 92)
+enum v4l2_smart_auto_status {
+ SMART_AUTO_STATUS_AUTO = 0,
+ SMART_AUTO_STATUS_LANDSCAPE,
+ SMART_AUTO_STATUS_PORTRAIT,
+ SMART_AUTO_STATUS_MACRO,
+ SMART_AUTO_STATUS_NIGHT,
+ SMART_AUTO_STATUS_PORTRAIT_NIGHT,
+ SMART_AUTO_STATUS_BACKLIT,
+ SMART_AUTO_STATUS_PORTRAIT_BACKLIT,
+ SMART_AUTO_STATUS_ANTISHAKE,
+ SMART_AUTO_STATUS_PORTRAIT_ANTISHAKE,
+ SMART_AUTO_STATUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_SET_AUTO_FOCUS (V4L2_CID_PRIVATE_BASE + 93)
+enum v4l2_auto_focus {
+ AUTO_FOCUS_OFF = 0,
+ AUTO_FOCUS_ON,
+ AUTO_FOCUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_BEAUTY_SHOT (V4L2_CID_PRIVATE_BASE + 94)
+enum v4l2_beauty_shot {
+ BEAUTY_SHOT_OFF = 0,
+ BEAUTY_SHOT_ON,
+ BEAUTY_SHOT_MAX,
+};
+
+#define V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK (V4L2_CID_PRIVATE_BASE + 95)
+enum v4l2_ae_awb_lockunlock {
+ AE_UNLOCK_AWB_UNLOCK = 0,
+ AE_LOCK_AWB_UNLOCK,
+ AE_UNLOCK_AWB_LOCK,
+ AE_LOCK_AWB_LOCK,
+ AE_AWB_MAX
+};
+
+#define V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK (V4L2_CID_PRIVATE_BASE + 96)
+enum v4l2_face_lock {
+ FACE_LOCK_OFF = 0,
+ FACE_LOCK_ON,
+ FIRST_FACE_TRACKING,
+ FACE_LOCK_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJECT_POSITION_X (V4L2_CID_PRIVATE_BASE + 97)
+#define V4L2_CID_CAMERA_OBJECT_POSITION_Y (V4L2_CID_PRIVATE_BASE + 98)
+#define V4L2_CID_CAMERA_FOCUS_MODE (V4L2_CID_PRIVATE_BASE + 99)
+enum v4l2_focusmode {
+ FOCUS_MODE_AUTO = 0,
+ FOCUS_MODE_MACRO,
+ FOCUS_MODE_FACEDETECT,
+ FOCUS_MODE_AUTO_DEFAULT,
+ FOCUS_MODE_MACRO_DEFAULT,
+ FOCUS_MODE_FACEDETECT_DEFAULT,
+ FOCUS_MODE_INFINITY,
+ FOCUS_MODE_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJ_TRACKING_STATUS (V4L2_CID_PRIVATE_BASE + 100)
+enum v4l2_obj_tracking_status {
+ OBJECT_TRACKING_STATUS_BASE,
+ OBJECT_TRACKING_STATUS_PROGRESSING,
+ OBJECT_TRACKING_STATUS_SUCCESS,
+ OBJECT_TRACKING_STATUS_FAIL,
+ OBJECT_TRACKING_STATUS_MISSING,
+ OBJECT_TRACKING_STATUS_MAX,
+};
+
+#define V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP (V4L2_CID_PRIVATE_BASE + 101)
+enum v4l2_ot_start_stop {
+ OT_STOP = 0,
+ OT_START,
+ OT_MAX,
+};
+
+#define V4L2_CID_CAMERA_CAF_START_STOP (V4L2_CID_PRIVATE_BASE + 102)
+enum v4l2_caf_start_stop {
+ CAF_STOP = 0,
+ CAF_START,
+ CAF_MAX,
+};
+
+#define V4L2_CID_CAMERA_AUTO_FOCUS_RESULT (V4L2_CID_PRIVATE_BASE + 103)
+#define V4L2_CID_CAMERA_FRAME_RATE (V4L2_CID_PRIVATE_BASE + 104)
+enum v4l2_frame_rate {
+ FRAME_RATE_AUTO = 0,
+ FRAME_RATE_7 = 7,
+ FRAME_RATE_15 = 15,
+ FRAME_RATE_30 = 30,
+ FRAME_RATE_60 = 60,
+ FRAME_RATE_120 = 120,
+ FRAME_RATE_MAX
+};
+
+#define V4L2_CID_CAMERA_ANTI_BANDING (V4L2_CID_PRIVATE_BASE + 105)
+enum v4l2_anti_banding {
+ ANTI_BANDING_AUTO = 0,
+ ANTI_BANDING_50HZ = 1,
+ ANTI_BANDING_60HZ = 2,
+ ANTI_BANDING_OFF = 3,
+};
+
+#define V4L2_CID_CAMERA_SET_GAMMA (V4L2_CID_PRIVATE_BASE + 106)
+enum v4l2_gamma_mode {
+ GAMMA_OFF = 0,
+ GAMMA_ON = 1,
+ GAMMA_MAX,
+};
+
+#define V4L2_CID_CAMERA_SET_SLOW_AE (V4L2_CID_PRIVATE_BASE + 107)
+enum v4l2_slow_ae_mode {
+ SLOW_AE_OFF,
+ SLOW_AE_ON,
+ SLOW_AE_MAX,
+};
+
+#define V4L2_CID_CAMERA_BATCH_REFLECTION (V4L2_CID_PRIVATE_BASE + 108)
+#define V4L2_CID_CAMERA_EXIF_ORIENTATION (V4L2_CID_PRIVATE_BASE + 109)
+
+#define V4L2_CID_CAMERA_RESET (V4L2_CID_PRIVATE_BASE + 111)
+#define V4L2_CID_CAMERA_CHECK_DATALINE (V4L2_CID_PRIVATE_BASE + 112)
+#define V4L2_CID_CAMERA_CHECK_DATALINE_STOP (V4L2_CID_PRIVATE_BASE + 113)
+#define V4L2_CID_CAMERA_GET_ISO (V4L2_CID_PRIVATE_BASE + 114)
+#define V4L2_CID_CAMERA_GET_SHT_TIME (V4L2_CID_PRIVATE_BASE + 115)
+#define V4L2_CID_CAMERA_SENSOR_MODE (V4L2_CID_PRIVATE_BASE + 116)
+#define V4L2_CID_ESD_INT (V4L2_CID_PRIVATE_BASE + 117)
+
+/* Pixel format FOURCC depth Description */
+/* 12 Y/CbCr 4:2:0 64x32 macroblocks */
+#define V4L2_PIX_FMT_NV12T v4l2_fourcc('T', 'V', '1', '2')
+
+/*
+ * * V4L2 extention for digital camera
+ * */
+/* Strobe flash light */
+enum v4l2_strobe_control {
+ /* turn off the flash light */
+ V4L2_STROBE_CONTROL_OFF = 0,
+ /* turn on the flash light */
+ V4L2_STROBE_CONTROL_ON = 1,
+ /* act guide light before splash */
+ V4L2_STROBE_CONTROL_AFGUIDE = 2,
+ /* charge the flash light */
+ V4L2_STROBE_CONTROL_CHARGE = 3,
+};
+
+enum v4l2_strobe_conf {
+ V4L2_STROBE_OFF = 0, /* Always off */
+ V4L2_STROBE_ON = 1, /* Always splashes */
+ /* Auto control presets */
+ V4L2_STROBE_AUTO = 2,
+ V4L2_STROBE_REDEYE_REDUCTION = 3,
+ V4L2_STROBE_SLOW_SYNC = 4,
+ V4L2_STROBE_FRONT_CURTAIN = 5,
+ V4L2_STROBE_REAR_CURTAIN = 6,
+ /* Extra manual control presets */
+ /* keep turned on until turning off */
+ V4L2_STROBE_PERMANENT = 7,
+ V4L2_STROBE_EXTERNAL = 8,
+};
+
+enum v4l2_strobe_status {
+ V4L2_STROBE_STATUS_OFF = 0,
+ /* while processing configurations */
+ V4L2_STROBE_STATUS_BUSY = 1,
+ V4L2_STROBE_STATUS_ERR = 2,
+ V4L2_STROBE_STATUS_CHARGING = 3,
+ V4L2_STROBE_STATUS_CHARGED = 4,
+};
+
+/* capabilities field */
+/* No strobe supported */
+#define V4L2_STROBE_CAP_NONE 0x0000
+/* Always flash off mode */
+#define V4L2_STROBE_CAP_OFF 0x0001
+/* Always use flash light mode */
+#define V4L2_STROBE_CAP_ON 0x0002
+/* Flashlight works automatic */
+#define V4L2_STROBE_CAP_AUTO 0x0004
+/* Red-eye reduction */
+#define V4L2_STROBE_CAP_REDEYE 0x0008
+/* Slow sync */
+#define V4L2_STROBE_CAP_SLOWSYNC 0x0010
+/* Front curtain */
+#define V4L2_STROBE_CAP_FRONT_CURTAIN 0x0020
+/* Rear curtain */
+#define V4L2_STROBE_CAP_REAR_CURTAIN 0x0040
+/* keep turned on until turning off */
+#define V4L2_STROBE_CAP_PERMANENT 0x0080
+/* use external strobe */
+#define V4L2_STROBE_CAP_EXTERNAL 0x0100
+
+/* Set mode and Get status */
+struct v4l2_strobe {
+ /* off/on/charge:0/1/2 */
+ enum v4l2_strobe_control control;
+ /* supported strobe capabilities */
+ __u32 capabilities;
+ enum v4l2_strobe_conf mode;
+ enum v4l2_strobe_status status; /* read only */
+ /* default is 0 and range of value varies from each models */
+ __u32 flash_ev;
+ __u32 reserved[4];
+};
+
+#define VIDIOC_S_STROBE _IOWR('V', 83, struct v4l2_strobe)
+#define VIDIOC_G_STROBE _IOR('V', 84, struct v4l2_strobe)
+
+/* Object recognition and collateral actions */
+enum v4l2_recog_mode {
+ V4L2_RECOGNITION_MODE_OFF = 0,
+ V4L2_RECOGNITION_MODE_ON = 1,
+ V4L2_RECOGNITION_MODE_LOCK = 2,
+};
+
+enum v4l2_recog_action {
+ V4L2_RECOGNITION_ACTION_NONE = 0, /* only recognition */
+ V4L2_RECOGNITION_ACTION_BLINK = 1, /* Capture on blinking */
+ V4L2_RECOGNITION_ACTION_SMILE = 2, /* Capture on smiling */
+};
+
+enum v4l2_recog_pattern {
+ V4L2_RECOG_PATTERN_FACE = 0, /* Face */
+ V4L2_RECOG_PATTERN_HUMAN = 1, /* Human */
+ V4L2_RECOG_PATTERN_CHAR = 2, /* Character */
+};
+
+struct v4l2_recog_rect {
+ enum v4l2_recog_pattern p; /* detected pattern */
+ struct v4l2_rect o; /* detected area */
+ __u32 reserved[4];
+};
+
+struct v4l2_recog_data {
+ __u8 detect_cnt; /* detected object counter */
+ struct v4l2_rect o; /* detected area */
+ __u32 reserved[4];
+};
+
+struct v4l2_recognition {
+ enum v4l2_recog_mode mode;
+
+ /* Which pattern to detect */
+ enum v4l2_recog_pattern pattern;
+
+ /* How many object to detect */
+ __u8 obj_num;
+
+ /* select detected object */
+ __u32 detect_idx;
+
+ /* read only :Get object coordination */
+ struct v4l2_recog_data data;
+
+ enum v4l2_recog_action action;
+ __u32 reserved[4];
+};
+
+#define VIDIOC_S_RECOGNITION _IOWR('V', 85, struct v4l2_recognition)
+#define VIDIOC_G_RECOGNITION _IOR('V', 86, struct v4l2_recognition)
+
+/* We use this struct as the v4l2_streamparm raw_data for
+ * VIDIOC_G_PARM and VIDIOC_S_PARM
+ */
+struct sec_cam_parm {
+ struct v4l2_captureparm capture;
+ int contrast;
+ int effects;
+ int brightness;
+ int flash_mode;
+ int focus_mode;
+ int iso;
+ int metering;
+ int saturation;
+ int scene_mode;
+ int sharpness;
+ int white_balance;
+};
#endif /* __LINUX_VIDEODEV2_SAMSUNG_H */
diff --git a/libcamera/SecCamera.cpp b/libcamera/SecCamera.cpp
index 733c374..d143540 100644
--- a/libcamera/SecCamera.cpp
+++ b/libcamera/SecCamera.cpp
@@ -576,14 +576,14 @@ static int fimc_v4l2_s_ext_ctrl(int fp, unsigned int id, void *value)
return ret;
}
#endif
-static int fimc_v4l2_g_parm(int fp)
+
+static int fimc_v4l2_g_parm(int fp, struct v4l2_streamparm *streamparm)
{
- struct v4l2_streamparm stream;
int ret;
- stream.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+ streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- ret = ioctl(fp, VIDIOC_G_PARM, &stream);
+ ret = ioctl(fp, VIDIOC_G_PARM, streamparm);
if (ret < 0) {
LOGE("ERR(%s):VIDIOC_G_PARM failed\n", __func__);
return -1;
@@ -596,17 +596,13 @@ static int fimc_v4l2_g_parm(int fp)
return 0;
}
-static int fimc_v4l2_s_parm(int fp, int fps_numerator, int fps_denominator)
+static int fimc_v4l2_s_parm(int fp, struct v4l2_streamparm *streamparm)
{
- struct v4l2_streamparm stream;
int ret;
- stream.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- stream.parm.capture.capturemode = 0;
- stream.parm.capture.timeperframe.numerator = fps_numerator;
- stream.parm.capture.timeperframe.denominator = fps_denominator;
+ streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- ret = ioctl(fp, VIDIOC_S_PARM, &stream);
+ ret = ioctl(fp, VIDIOC_S_PARM, streamparm);
if (ret < 0) {
LOGE("ERR(%s):VIDIOC_S_PARM failed\n", __func__);
return ret;
@@ -619,8 +615,6 @@ static int fimc_v4l2_s_parm(int fp, int fps_numerator, int fps_denominator)
// Constructor & Destructor
SecCamera::SecCamera() :
- m_focus_mode(1),
- m_iso(-1),
m_flag_init(0),
m_camera_id(CAMERA_ID_BACK),
m_preview_v4lformat(V4L2_PIX_FMT_NV21),
@@ -634,18 +628,8 @@ SecCamera::SecCamera() :
m_snapshot_max_width (MAX_BACK_CAMERA_SNAPSHOT_WIDTH),
m_snapshot_max_height (MAX_BACK_CAMERA_SNAPSHOT_HEIGHT),
m_angle(-1),
- m_fps(-1),
- m_autofocus(-1),
- m_white_balance(-1),
- m_brightness(-1),
- m_image_effect(-1),
#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
m_anti_banding(-1),
- m_flash_mode(-1),
- m_metering(-1),
- m_contrast(-1),
- m_saturation(-1),
- m_sharpness(-1),
m_wdr(-1),
m_anti_shake(-1),
m_zoom_level(-1),
@@ -668,7 +652,7 @@ SecCamera::SecCamera() :
m_slow_ae(-1),
m_camera_af_flag(-1),
#else
- m_image_effect(IMAGE_EFFECT_ORIGINAL),
+ m_autofocus(-1),
#endif
m_flag_camera_start(0),
m_jpeg_thumbnail_width (0),
@@ -679,6 +663,22 @@ SecCamera::SecCamera() :
m_esd_check_count(0)
#endif // ENABLE_ESD_PREVIEW_CHECK
{
+ m_params = (struct sec_cam_parm*)&m_streamparm.parm.raw_data;
+ struct v4l2_captureparm capture;
+ m_params->capture.timeperframe.numerator = 1;
+ m_params->capture.timeperframe.denominator = 0;
+ m_params->contrast = -1;
+ m_params->effects = -1;
+ m_params->brightness = -1;
+ m_params->flash_mode = -1;
+ m_params->focus_mode = -1;
+ m_params->iso = -1;
+ m_params->metering = -1;
+ m_params->saturation = -1;
+ m_params->scene_mode = -1;
+ m_params->sharpness = -1;
+ m_params->white_balance = -1;
+
LOGV("%s :", __func__);
}
@@ -896,6 +896,9 @@ int SecCamera::flagPreviewStart(void)
int SecCamera::startPreview(void)
{
+ v4l2_streamparm streamparm;
+ struct sec_cam_parm *parms;
+ parms = (struct sec_cam_parm*)&streamparm.parm.raw_data;
#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
LOGV("%s :", __func__);
#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */
@@ -929,12 +932,6 @@ int SecCamera::startPreview(void)
ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
CHECK(ret);
- /* g_parm, s_parm sample */
- ret = fimc_v4l2_g_parm(m_cam_fd);
- CHECK(ret);
- ret = fimc_v4l2_s_parm(m_cam_fd, 1, m_fps);
- CHECK(ret);
-
#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
LOGV("%s : m_preview_width: %d m_preview_height: %d m_angle: %d\n",
__func__, m_preview_width, m_preview_height, m_angle);
@@ -963,56 +960,16 @@ int SecCamera::startPreview(void)
m_flag_camera_start = 1; //Kamat check
if (m_camera_id == CAMERA_ID_BACK) {
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, m_image_effect);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, m_white_balance);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ISO, m_iso);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FLASH_MODE,
- m_flash_mode);
- CHECK(ret);
- if (m_focus_mode ==FOCUS_MODE_FACEDETECT)
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, FOCUS_MODE_AUTO);
- else {
- if (m_shot_mode == 2) { //Panorama shot
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, m_focus_mode);
- CHECK(ret);
- m_camera_af_flag = -1;
- } else if (m_shot_mode == 3) { //Smile shot
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, m_focus_mode);
- CHECK(ret);
- m_camera_af_flag = -1;
- } else if (m_camera_af_flag < 0) { //After captur, Focus is fixed.
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, m_focus_mode);
- CHECK(ret);
- m_camera_af_flag = 0;
- }
- }
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, m_fps);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, m_metering);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SATURATION, m_saturation);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CONTRAST, m_contrast);
- CHECK(ret);
-
- // Apply the scene mode only in camera not in camcorder
- if (!m_sensor_mode) {
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, m_scene_mode);
- CHECK(ret);
- }
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, m_brightness);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SHARPNESS, m_sharpness);
+ ret = fimc_v4l2_s_parm(m_cam_fd, &m_streamparm);
CHECK(ret);
} else { // In case VGA camera
/* Brightness setting */
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, m_brightness);
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS,
+ m_params->brightness);
CHECK(ret);
/* Blur setting */
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VGA_BLUR, m_blur_level);
+ ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VGA_BLUR,
+ m_blur_level);
CHECK(ret);
}
#endif
@@ -1115,12 +1072,6 @@ int SecCamera::startRecord(void)
ret = fimc_v4l2_querybuf(m_cam_fd2, m_buffers_c2, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
CHECK(ret);
- /* g_parm, s_parm sample */
- ret = fimc_v4l2_g_parm(m_cam_fd2);
- CHECK(ret);
- ret = fimc_v4l2_s_parm(m_cam_fd2, 1, m_fps);
- CHECK(ret);
-
/* start with all buffers in queue */
for (int i = 0; i < MAX_BUFFERS; i++) {
ret = fimc_v4l2_qbuf(m_cam_fd2, i);
@@ -1448,11 +1399,6 @@ int SecCamera::setSnapshotCmd(void)
ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
CHECK_PTR(ret);
- ret = fimc_v4l2_g_parm(m_cam_fd);
- CHECK_PTR(ret);
- ret = fimc_v4l2_s_parm(m_cam_fd, 1, m_fps);
- CHECK_PTR(ret);
-
ret = fimc_v4l2_qbuf(m_cam_fd, 0);
CHECK_PTR(ret);
@@ -1704,12 +1650,6 @@ int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_bu
ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
CHECK(ret);
- /* g_parm, s_parm sample */
- ret = fimc_v4l2_g_parm(m_cam_fd);
- CHECK(ret);
- ret = fimc_v4l2_s_parm(m_cam_fd, 1, m_fps);
- CHECK(ret);
-
ret = fimc_v4l2_qbuf(m_cam_fd, 0);
CHECK(ret);
@@ -2057,25 +1997,19 @@ void SecCamera::setFrameRate(int frame_rate)
if (frame_rate < FRAME_RATE_AUTO || FRAME_RATE_MAX < frame_rate )
LOGE("ERR(%s):Invalid frame_rate(%d)", __func__, frame_rate);
- if (m_fps != frame_rate) {
- m_fps = frame_rate;
+ if (m_params->capture.timeperframe.denominator != (unsigned)frame_rate) {
+ m_params->capture.timeperframe.denominator = frame_rate;
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, frame_rate) < 0)
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FRAME_RATE", __func__);
}
}
#else
- m_fps = frame_rate;
+ m_params->capture.timeperframe.denominator = frame_rate;
#endif
}
-/* kidggang (10.7.5) - Problem - After jpegquality is capture, operation setting is normal.
-void SecCamera::setJpegQuality(int quality)
-{
- m_jpeg_quality = quality;
-}
-*/
// -----------------------------------
int SecCamera::setVerticalMirror(void)
@@ -2127,8 +2061,8 @@ int SecCamera::setWhiteBalance(int white_balance)
return -1;
}
- if (m_white_balance != white_balance) {
- m_white_balance = white_balance;
+ if (m_params->white_balance != white_balance) {
+ m_params->white_balance = white_balance;
#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, white_balance) < 0) {
@@ -2144,8 +2078,8 @@ int SecCamera::setWhiteBalance(int white_balance)
int SecCamera::getWhiteBalance(void)
{
- LOGV("%s : white_balance(%d)", __func__, m_white_balance);
- return m_white_balance;
+ LOGV("%s : white_balance(%d)", __func__, m_parmas.white_balance);
+ return m_params->white_balance;
}
// -----------------------------------
@@ -2154,15 +2088,15 @@ int SecCamera::setBrightness(int brightness)
{
LOGV("%s(brightness(%d))", __func__, brightness);
- brightness += BRIGHTNESS_NORMAL;
+ brightness += EV_DEFAULT;
- if (brightness < BRIGHTNESS_MINUS_4 || BRIGHTNESS_PLUS_4 < brightness) {
+ if (brightness < EV_MINUS_4 || EV_PLUS_4 < brightness) {
LOGE("ERR(%s):Invalid brightness(%d)", __func__, brightness);
return -1;
}
- if (m_brightness != brightness) {
- m_brightness = brightness;
+ if (m_params->brightness != brightness) {
+ m_params->brightness = brightness;
#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, brightness) < 0) {
@@ -2178,8 +2112,8 @@ int SecCamera::setBrightness(int brightness)
int SecCamera::getBrightness(void)
{
- LOGV("%s : brightness(%d)", __func__, m_brightness);
- return m_brightness;
+ LOGV("%s : brightness(%d)", __func__, m_params->brightness);
+ return m_params->brightness;
}
// -----------------------------------
@@ -2197,8 +2131,8 @@ int SecCamera::setImageEffect(int image_effect)
return -1;
}
- if (m_image_effect != image_effect) {
- m_image_effect = image_effect;
+ if (m_params->effects != image_effect) {
+ m_params->effects = image_effect;
#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, image_effect) < 0) {
@@ -2214,8 +2148,8 @@ int SecCamera::setImageEffect(int image_effect)
int SecCamera::getImageEffect(void)
{
- LOGV("%s : image_effect(%d)", __func__, m_image_effect);
- return m_image_effect;
+ LOGV("%s : image_effect(%d)", __func__, m_params->effects);
+ return m_params->effects;
}
// ======================================================================
@@ -2252,10 +2186,10 @@ int SecCamera::setSceneMode(int scene_mode)
return -1;
}
- if (m_scene_mode != scene_mode) {
- m_scene_mode = scene_mode;
+ if (m_params->scene_mode != scene_mode) {
+ m_params->scene_mode = scene_mode;
if (m_flag_camera_start) {
- if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, m_scene_mode) < 0) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, scene_mode) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SCENE_MODE", __func__);
return -1;
}
@@ -2267,7 +2201,7 @@ int SecCamera::setSceneMode(int scene_mode)
int SecCamera::getSceneMode(void)
{
- return m_scene_mode;
+ return m_params->scene_mode;
}
//======================================================================
@@ -2281,8 +2215,8 @@ int SecCamera::setFlashMode(int flash_mode)
return -1;
}
- if (m_flash_mode != flash_mode) {
- m_flash_mode = flash_mode;
+ if (m_params->flash_mode != flash_mode) {
+ m_params->flash_mode = flash_mode;
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FLASH_MODE, flash_mode) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FLASH_MODE", __func__);
@@ -2296,7 +2230,7 @@ int SecCamera::setFlashMode(int flash_mode)
int SecCamera::getFlashMode(void)
{
- return m_flash_mode;
+ return m_params->flash_mode;
}
//======================================================================
@@ -2309,8 +2243,8 @@ int SecCamera::setISO(int iso_value)
return -1;
}
- if (m_iso != iso_value) {
- m_iso = iso_value;
+ if (m_params->iso != iso_value) {
+ m_params->iso = iso_value;
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ISO, iso_value) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ISO", __func__);
@@ -2324,7 +2258,7 @@ int SecCamera::setISO(int iso_value)
int SecCamera::getISO(void)
{
- return m_iso;
+ return m_params->iso;
}
//======================================================================
@@ -2338,8 +2272,8 @@ int SecCamera::setContrast(int contrast_value)
return -1;
}
- if (m_contrast != contrast_value) {
- m_contrast = contrast_value;
+ if (m_params->contrast != contrast_value) {
+ m_params->contrast = contrast_value;
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CONTRAST, contrast_value) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CONTRAST", __func__);
@@ -2353,7 +2287,7 @@ int SecCamera::setContrast(int contrast_value)
int SecCamera::getContrast(void)
{
- return m_contrast;
+ return m_params->contrast;
}
//======================================================================
@@ -2367,8 +2301,8 @@ int SecCamera::setSaturation(int saturation_value)
return -1;
}
- if (m_saturation != saturation_value) {
- m_saturation = saturation_value;
+ if (m_params->saturation != saturation_value) {
+ m_params->saturation = saturation_value;
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SATURATION, saturation_value) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__);
@@ -2382,7 +2316,7 @@ int SecCamera::setSaturation(int saturation_value)
int SecCamera::getSaturation(void)
{
- return m_saturation;
+ return m_params->saturation;
}
//======================================================================
@@ -2396,8 +2330,8 @@ int SecCamera::setSharpness(int sharpness_value)
return -1;
}
- if (m_sharpness != sharpness_value) {
- m_sharpness = sharpness_value;
+ if (m_params->sharpness != sharpness_value) {
+ m_params->sharpness = sharpness_value;
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SHARPNESS, sharpness_value) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__);
@@ -2411,7 +2345,7 @@ int SecCamera::setSharpness(int sharpness_value)
int SecCamera::getSharpness(void)
{
- return m_sharpness;
+ return m_params->sharpness;
}
//======================================================================
@@ -2484,8 +2418,8 @@ int SecCamera::setMetering(int metering_value)
return -1;
}
- if (m_metering != metering_value) {
- m_metering = metering_value;
+ if (m_params->metering != metering_value) {
+ m_params->metering = metering_value;
if (m_flag_camera_start) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, metering_value) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_METERING", __func__);
@@ -2499,7 +2433,7 @@ int SecCamera::setMetering(int metering_value)
int SecCamera::getMetering(void)
{
- return m_metering;
+ return m_params->metering;
}
//======================================================================
@@ -2684,7 +2618,7 @@ int SecCamera::setBeautyShot(int beauty_shot)
}
}
- setFaceDetect(FACE_DETECT_BEAUTY_ON);
+ setFaceDetect(FACE_DETECTION_ON_BEAUTY);
}
return 0;
@@ -2735,27 +2669,13 @@ int SecCamera::setFocusMode(int focus_mode)
return -1;
}
- if (m_focus_mode != focus_mode) {
- m_focus_mode = focus_mode;
+ if (m_params->focus_mode != focus_mode) {
+ m_params->focus_mode = focus_mode;
- if (m_focus_mode != FOCUS_MODE_FACEDETECT) {
- m_face_detect = FACE_DETECT_OFF;
- if (m_flag_camera_start) {
-// setFaceDetect(m_face_detect);
-
- if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__);
- return -1;
- }
- }
- } else {
- m_face_detect = FACE_DETECT_NORMAL_ON;
- if (m_flag_camera_start) {
- if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, FOCUS_MODE_AUTO) < 0) {
- LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__);
- return -1;
-// setFaceDetect(m_face_detect);
- }
+ if (m_flag_camera_start) {
+ if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode) < 0) {
+ LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__);
+ return -1;
}
}
}
@@ -2765,7 +2685,7 @@ int SecCamera::setFocusMode(int focus_mode)
int SecCamera::getFocusMode(void)
{
- return m_focus_mode;
+ return m_params->focus_mode;
}
//======================================================================
@@ -2777,7 +2697,7 @@ int SecCamera::setFaceDetect(int face_detect)
if (m_face_detect != face_detect) {
m_face_detect = face_detect;
if (m_flag_camera_start) {
- if (m_face_detect != FACE_DETECT_OFF) {
+ if (m_face_detect != FACE_DETECTION_OFF) {
if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, FOCUS_MODE_AUTO) < 0) {
LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODin face detecion", __func__);
return -1;
@@ -2940,7 +2860,7 @@ int SecCamera::setSlowAE(int slow_ae)
//======================================================================
int SecCamera::setRecordingSize(int width, int height)
{
- LOGE("%s(width(%d), height(%d))", __func__, width, height);
+ LOGV("%s(width(%d), height(%d))", __func__, width, height);
m_recording_width = width;
m_recording_height = height;
@@ -3412,10 +3332,10 @@ void SecCamera::setExifChangedAttribute()
//3 ISO Speed Rating
int iso = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_ISO);
- if (m_iso == ISO_AUTO) {
+ if (m_params->iso == ISO_AUTO) {
mExifInfo.iso_speed_rating = iso;
} else {
- switch(m_iso) {
+ switch(m_params->iso) {
case ISO_50:
mExifInfo.iso_speed_rating = 50;
break;
@@ -3456,7 +3376,7 @@ void SecCamera::setExifChangedAttribute()
mExifInfo.brightness.num = bv*EXIF_DEF_APEX_DEN;
mExifInfo.brightness.den = EXIF_DEF_APEX_DEN;
//3 Exposure Bias
- if (m_scene_mode == SCENE_MODE_BEACH_SNOW) {
+ if (m_params->scene_mode == SCENE_MODE_BEACH_SNOW) {
mExifInfo.exposure_bias.num = EXIF_DEF_APEX_DEN;
mExifInfo.exposure_bias.den = EXIF_DEF_APEX_DEN;
} else {
@@ -3464,7 +3384,7 @@ void SecCamera::setExifChangedAttribute()
mExifInfo.exposure_bias.den = 0;
}
//3 Metering Mode
- switch (m_metering) {
+ switch (m_params->metering) {
case METERING_SPOT:
mExifInfo.metering_mode = EXIF_METERING_SPOT;
break;
@@ -3479,12 +3399,12 @@ void SecCamera::setExifChangedAttribute()
break;
}
//3 White Balance
- if (m_white_balance == WHITE_BALANCE_AUTO)
+ if (m_params->white_balance == WHITE_BALANCE_AUTO)
mExifInfo.white_balance = EXIF_WB_AUTO;
else
mExifInfo.white_balance = EXIF_WB_MANUAL;
//3 Scene Capture Type
- switch (m_scene_mode) {
+ switch (m_params->scene_mode) {
case SCENE_MODE_PORTRAIT:
mExifInfo.scene_capture_type = EXIF_SCENE_PORTRAIT;
break;
diff --git a/libcamera/SecCamera.h b/libcamera/SecCamera.h
index 46a638b..6d7b782 100644
--- a/libcamera/SecCamera.h
+++ b/libcamera/SecCamera.h
@@ -215,155 +215,7 @@ public:
CAMERA_ID_FRONT = 1,
};
- enum AUTO_FOCUS {
- AUTO_FOCUS_OFF = 0,
- AUTO_FOCUS_ON,
- AUTO_FOCUS_MAX,
- };
-
- enum WHILTE_BALANCE {
- #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
- WHITE_BALANCE_BASE,
- WHITE_BALANCE_AUTO,
- WHITE_BALANCE_DAYLIGHT,
- WHITE_BALANCE_CLOUDY,
- WHITE_BALANCE_INCANDESCENT,
- WHITE_BALANCE_FLUORESCENT,
- WHITE_BALANCE_MAX,
- #else
- WHITE_BALANCE_AUTO,
- WHITE_BALANCE_INDOOR3100,
- WHITE_BALANCE_OUTDOOR5100,
- WHITE_BALANCE_INDOOR2000,
- WHITE_BALANCE_HALT,
- WHITE_BALANCE_CLOUDY,
- WHITE_BALANCE_SUNNY,
- #endif
- };
-
- enum BRIGHTNESS {
- BRIGHTNESS_MINUS_4= 0,
- BRIGHTNESS_MINUS_3,
- BRIGHTNESS_MINUS_2,
- BRIGHTNESS_MINUS_1,
- BRIGHTNESS_NORMAL,
- BRIGHTNESS_PLUS_1,
- BRIGHTNESS_PLUS_2,
- BRIGHTNESS_PLUS_3,
- BRIGHTNESS_PLUS_4,
- };
-
- enum IMAGE_EFFECT {
- #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
- IMAGE_EFFECT_BASE,
- IMAGE_EFFECT_NONE,
- IMAGE_EFFECT_BNW,
- IMAGE_EFFECT_SEPIA,
- IMAGE_EFFECT_AQUA,
- IMAGE_EFFECT_ANTIQUE,
- IMAGE_EFFECT_NEGATIVE,
- IMAGE_EFFECT_SHARPEN,
- IMAGE_EFFECT_MAX,
- #else
- IMAGE_EFFECT_ORIGINAL,
- IMAGE_EFFECT_ARBITRARY,
- IMAGE_EFFECT_NEGATIVE,
- IMAGE_EFFECT_FREEZE,
- IMAGE_EFFECT_EMBOSSING,
- IMAGE_EFFECT_SILHOUETTE,
- #endif
- };
-
#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
- enum SCENE_MODE {
- SCENE_MODE_BASE,
- SCENE_MODE_NONE,
- SCENE_MODE_PORTRAIT,
- SCENE_MODE_NIGHTSHOT,
- SCENE_MODE_BACK_LIGHT,
- SCENE_MODE_LANDSCAPE,
- SCENE_MODE_SPORTS,
- SCENE_MODE_PARTY_INDOOR,
- SCENE_MODE_BEACH_SNOW,
- SCENE_MODE_SUNSET,
- SCENE_MODE_DUSK_DAWN,
- SCENE_MODE_FALL_COLOR,
- SCENE_MODE_FIREWORKS,
- SCENE_MODE_TEXT,
- SCENE_MODE_CANDLE_LIGHT,
- SCENE_MODE_MAX,
- };
-
- enum FLASH_MODE {
- FLASH_MODE_BASE,
- FLASH_MODE_OFF,
- FLASH_MODE_AUTO,
- FLASH_MODE_ON,
- FLASH_MODE_TORCH,
- FLASH_MODE_MAX,
- };
-
- enum ISO {
- ISO_AUTO,
- ISO_50,
- ISO_100,
- ISO_200,
- ISO_400,
- ISO_800,
- ISO_1600,
- ISO_SPORTS,
- ISO_NIGHT,
- ISO_MOVIE,
- ISO_MAX,
- };
-
- enum METERING {
- METERING_BASE = 0,
- METERING_MATRIX,
- METERING_CENTER,
- METERING_SPOT,
- METERING_MAX,
- };
-
- enum CONTRAST {
- CONTRAST_MINUS_2 = 0,
- CONTRAST_MINUS_1,
- CONTRAST_NORMAL,
- CONTRAST_PLUS_1,
- CONTRAST_PLUS_2,
- CONTRAST_MAX,
- };
-
- enum SATURATION {
- SATURATION_MINUS_2= 0,
- SATURATION_MINUS_1,
- SATURATION_NORMAL,
- SATURATION_PLUS_1,
- SATURATION_PLUS_2,
- SATURATION_MAX,
- };
-
- enum SHARPNESS {
- SHARPNESS_MINUS_2 = 0,
- SHARPNESS_MINUS_1,
- SHARPNESS_NORMAL,
- SHARPNESS_PLUS_1,
- SHARPNESS_PLUS_2,
- SHARPNESS_MAX,
- };
-
- enum WDR {
- WDR_OFF,
- WDR_ON,
- WDR_MAX,
- };
-
- enum ANTI_SHAKE {
- ANTI_SHAKE_OFF,
- ANTI_SHAKE_ON,
- ANTI_SHAKE_MAX,
- };
-
enum JPEG_QUALITY {
JPEG_QUALITY_ECONOMY = 0,
JPEG_QUALITY_NORMAL = 50,
@@ -371,128 +223,12 @@ public:
JPEG_QUALITY_MAX,
};
- enum ZOOM_LEVEL {
- ZOOM_LEVEL_0 = 0,
- ZOOM_LEVEL_1,
- ZOOM_LEVEL_2,
- ZOOM_LEVEL_3,
- ZOOM_LEVEL_4,
- ZOOM_LEVEL_5,
- ZOOM_LEVEL_6,
- ZOOM_LEVEL_7,
- ZOOM_LEVEL_8,
- ZOOM_LEVEL_9,
- ZOOM_LEVEL_10,
- ZOOM_LEVEL_11,
- ZOOM_LEVEL_12,
- ZOOM_LEVEL_MAX,
- };
-
enum OBJECT_TRACKING {
OBJECT_TRACKING_OFF,
OBJECT_TRACKING_ON,
OBJECT_TRACKING_MAX,
};
- enum OBJECT_TRACKING_STAUS {
- OBJECT_TRACKING_STATUS_BASE,
- OBJECT_TRACKING_STATUS_PROGRESSING,
- OBJECT_TRACKING_STATUS_SUCCESS,
- OBJECT_TRACKING_STATUS_FAIL,
- OBJECT_TRACKING_STATUS_MISSING,
- OBJECT_TRACKING_STATUS_MAX,
- };
-
- enum SMART_AUTO {
- SMART_AUTO_OFF,
- SMART_AUTO_ON,
- SMART_AUTO_MAX,
- };
-
- enum BEAUTY_SHOT {
- BEAUTY_SHOT_OFF,
- BEAUTY_SHOT_ON,
- BEAUTY_SHOT_MAX,
- };
-
- enum VINTAGE_MODE {
- VINTAGE_MODE_BASE,
- VINTAGE_MODE_OFF,
- VINTAGE_MODE_NORMAL,
- VINTAGE_MODE_WARM,
- VINTAGE_MODE_COOL,
- VINTAGE_MODE_BNW,
- VINTAGE_MODE_MAX,
- };
-
- enum FOCUS_MODE {
- FOCUS_MODE_AUTO,
- FOCUS_MODE_MACRO,
- FOCUS_MODE_FACEDETECT,
- FOCUS_MODE_AUTO_DEFAULT,
- FOCUS_MODE_MACRO_DEFAULT,
- FOCUS_MODE_FACEDETECT_DEFAULT,
- FOCUS_MODE_INFINITY,
- FOCUS_MODE_MAX,
- };
-
- enum FACE_DETECT {
- FACE_DETECT_OFF,
- FACE_DETECT_NORMAL_ON,
- FACE_DETECT_BEAUTY_ON,
- FACE_DETECT_NO_LINE,
- FACE_DETECT_MAX,
- };
-
- enum AE_AWB_LOCK_UNLOCK {
- AE_UNLOCK_AWB_UNLOCK = 0,
- AE_LOCK_AWB_UNLOCK,
- AE_UNLOCK_AWB_LOCK,
- AE_LOCK_AWB_LOCK,
- AE_AWB_MAX
- };
-
- enum FRAME_RATE {
- FRAME_RATE_AUTO = 0,
- FRAME_RATE_15 = 15,
- FRAME_RATE_30 = 30,
- FRAME_RATE_60 = 60,
- FRAME_RATE_120 = 120,
- FRAME_RATE_MAX
- };
- enum ANTI_BANDING {
- ANTI_BANDING_AUTO = 0,
- ANTI_BANDING_50HZ = 1,
- ANTI_BANDING_60HZ = 2,
- ANTI_BANDING_OFF = 3,
- };
-
- enum SMART_AUTO_SCENE {
- SMART_AUTO_STATUS_AUTO = 0,
- SMART_AUTO_STATUS_LANDSCAPE,
- SMART_AUTO_STATUS_PORTRAIT,
- SMART_AUTO_STATUS_MACRO,
- SMART_AUTO_STATUS_NIGHT,
- SMART_AUTO_STATUS_PORTRAIT_NIGHT,
- SMART_AUTO_STATUS_BACKLIT,
- SMART_AUTO_STATUS_PORTRAIT_BACKLIT,
- SMART_AUTO_STATUS_ANTISHAKE,
- SMART_AUTO_STATUS_PORTRAIT_ANTISHAKE,
- SMART_AUTO_STATUS_MAX,
- };
-
- enum GAMMA {
- GAMMA_OFF,
- GAMMA_ON,
- GAMMA_MAX,
- };
-
- enum SLOW_AE {
- SLOW_AE_OFF,
- SLOW_AE_ON,
- SLOW_AE_MAX,
- };
-
/*VT call*/
enum VT_MODE {
VT_MODE_OFF,
@@ -515,30 +251,13 @@ public:
SHOT_MODE_SELF = 6,
};
- enum BLUR_LEVEL {
- BLUR_LEVEL_0 = 0,
- BLUR_LEVEL_1,
- BLUR_LEVEL_2,
- BLUR_LEVEL_3,
- BLUR_LEVEL_MAX,
- };
-
enum CHK_DATALINE {
CHK_DATALINE_OFF,
CHK_DATALINE_ON,
CHK_DATALINE_MAX,
};
- enum FACE_LOCK {
- FACE_LOCK_OFF,
- FACE_LOCK_ON,
- FIRST_FACE_TRACKING,
- FACE_LOCK_MAX
- };
-
int m_touch_af_start_stop;
- int m_focus_mode;
- int m_iso;
#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
struct gps_info_latiude {
@@ -590,9 +309,7 @@ public:
unsigned int getRecPhyAddrC(int);
#endif
int flagPreviewStart(void);
- //int getPreview (unsigned char *buffer, unsigned int buffer_size);
int getPreview(void);
- //int getPreview(int *offset, int *size, unsigned char *buffer, unsigned int buffer_size);
int setPreviewSize(int width, int height, int pixel_format);
int getPreviewSize(int *width, int *height, int *frame_size);
int getPreviewMaxSize(int *width, int *height);
@@ -724,7 +441,6 @@ public:
#endif
void setFrameRate(int frame_rate);
-// void setJpegQuality(int quality);
unsigned char* getJpeg(int*, unsigned int*);
int getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf,
unsigned int *output_size);
@@ -784,6 +500,8 @@ public:
private:
+ v4l2_streamparm m_streamparm;
+ struct sec_cam_parm *m_params;
int m_flag_init;
int m_camera_id;
@@ -812,19 +530,11 @@ private:
int m_snapshot_max_height;
int m_angle;
- int m_fps;
+#ifndef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
int m_autofocus;
- int m_white_balance;
- int m_brightness;
- int m_image_effect;
+#endif
#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION
int m_anti_banding;
- int m_scene_mode;
- int m_flash_mode;
- int m_metering;
- int m_contrast;
- int m_saturation;
- int m_sharpness;
int m_wdr;
int m_anti_shake;
int m_zoom_level;
diff --git a/libcamera/SecCameraHWInterface.cpp b/libcamera/SecCameraHWInterface.cpp
index 4eccb31..e8df8eb 100644
--- a/libcamera/SecCameraHWInterface.cpp
+++ b/libcamera/SecCameraHWInterface.cpp
@@ -1668,18 +1668,18 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
const char *new_flash_mode_str = NULL;
if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_AUTO)) {
- new_scene_mode = SecCamera::SCENE_MODE_NONE;
+ new_scene_mode = SCENE_MODE_NONE;
} else {
// defaults for the scene modes
mInternalParameters.set("iso", "auto");
mInternalParameters.set("metering", "center");
mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
- SecCamera::BRIGHTNESS_NORMAL);
+ EV_DEFAULT);
mParameters.set(CameraParameters::KEY_WHITE_BALANCE,
CameraParameters::WHITE_BALANCE_AUTO);
- mInternalParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL);
- mInternalParameters.set("saturation", SecCamera::SATURATION_NORMAL);
+ mInternalParameters.set("sharpness", SHARPNESS_DEFAULT);
+ mInternalParameters.set("saturation", SATURATION_DEFAULT);
if (new_camera_id == SecCamera::CAMERA_ID_BACK) {
mParameters.set(CameraParameters::KEY_FOCUS_MODE,
CameraParameters::FOCUS_MODE_AUTO);
@@ -1689,47 +1689,46 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
if (!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_PORTRAIT)) {
- new_scene_mode = SecCamera::SCENE_MODE_PORTRAIT;
+ new_scene_mode = SCENE_MODE_PORTRAIT;
- mInternalParameters.set("sharpness",
- SecCamera::SHARPNESS_MINUS_1);
+ mInternalParameters.set("sharpness", SHARPNESS_MINUS_1);
} else if (!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_LANDSCAPE)) {
- new_scene_mode = SecCamera::SCENE_MODE_LANDSCAPE;
+ new_scene_mode = SCENE_MODE_LANDSCAPE;
mInternalParameters.set("metering", "matrix");
- mInternalParameters.set("sharpness", SecCamera::SHARPNESS_PLUS_1);
- mInternalParameters.set("saturation", SecCamera::SATURATION_PLUS_1);
+ mInternalParameters.set("sharpness", SHARPNESS_PLUS_1);
+ mInternalParameters.set("saturation", SATURATION_PLUS_1);
mParameters.set(CameraParameters::KEY_FLASH_MODE,
CameraParameters::FLASH_MODE_OFF);
} else if (!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_SPORTS)) {
- new_scene_mode = SecCamera::SCENE_MODE_SPORTS;
+ new_scene_mode = SCENE_MODE_SPORTS;
mInternalParameters.set("iso", "sports");
mParameters.set(CameraParameters::KEY_FLASH_MODE,
CameraParameters::FLASH_MODE_OFF);
} else if (!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_PARTY)) {
- new_scene_mode = SecCamera::SCENE_MODE_PARTY_INDOOR;
+ new_scene_mode = SCENE_MODE_PARTY_INDOOR;
mInternalParameters.set("iso", "200");
- mInternalParameters.set("saturation", SecCamera::SATURATION_PLUS_1);
+ mInternalParameters.set("saturation", SATURATION_PLUS_1);
} else if ((!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_BEACH)) ||
(!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_SNOW))) {
- new_scene_mode = SecCamera::SCENE_MODE_BEACH_SNOW;
+ new_scene_mode = SCENE_MODE_BEACH_SNOW;
mInternalParameters.set("iso", "50");
mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION,
- SecCamera::BRIGHTNESS_PLUS_2);
- mInternalParameters.set("saturation", SecCamera::SATURATION_PLUS_1);
+ EV_PLUS_2);
+ mInternalParameters.set("saturation", SATURATION_PLUS_1);
mParameters.set(CameraParameters::KEY_FLASH_MODE,
CameraParameters::FLASH_MODE_OFF);
} else if (!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_SUNSET)) {
- new_scene_mode = SecCamera::SCENE_MODE_SUNSET;
+ new_scene_mode = SCENE_MODE_SUNSET;
mParameters.set(CameraParameters::KEY_WHITE_BALANCE,
CameraParameters::WHITE_BALANCE_DAYLIGHT);
@@ -1737,7 +1736,7 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
CameraParameters::FLASH_MODE_OFF);
} else if (!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_NIGHT)) {
- new_scene_mode = SecCamera::SCENE_MODE_NIGHTSHOT;
+ new_scene_mode = SCENE_MODE_NIGHTSHOT;
mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE,
"3780,30000");
@@ -1746,14 +1745,14 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
CameraParameters::FLASH_MODE_OFF);
} else if (!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_FIREWORKS)) {
- new_scene_mode = SecCamera::SCENE_MODE_FIREWORKS;
+ new_scene_mode = SCENE_MODE_FIREWORKS;
mInternalParameters.set("iso", "50");
mParameters.set(CameraParameters::KEY_FLASH_MODE,
CameraParameters::FLASH_MODE_OFF);
} else if (!strcmp(new_scene_mode_str,
CameraParameters::SCENE_MODE_CANDLELIGHT)) {
- new_scene_mode = SecCamera::SCENE_MODE_CANDLE_LIGHT;
+ new_scene_mode = SCENE_MODE_CANDLE_LIGHT;
mParameters.set(CameraParameters::KEY_WHITE_BALANCE,
CameraParameters::WHITE_BALANCE_DAYLIGHT);
@@ -1780,25 +1779,25 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
if (new_iso_str != NULL) {
int new_iso = -1;
if (!strcmp(new_iso_str, "auto"))
- new_iso = SecCamera::ISO_AUTO;
+ new_iso = ISO_AUTO;
else if (!strcmp(new_iso_str, "50"))
- new_iso = SecCamera::ISO_50;
+ new_iso = ISO_50;
else if (!strcmp(new_iso_str, "100"))
- new_iso = SecCamera::ISO_100;
+ new_iso = ISO_100;
else if (!strcmp(new_iso_str, "200"))
- new_iso = SecCamera::ISO_200;
+ new_iso = ISO_200;
else if (!strcmp(new_iso_str, "400"))
- new_iso = SecCamera::ISO_400;
+ new_iso = ISO_400;
else if (!strcmp(new_iso_str, "800"))
- new_iso = SecCamera::ISO_800;
+ new_iso = ISO_800;
else if (!strcmp(new_iso_str, "1600"))
- new_iso = SecCamera::ISO_1600;
+ new_iso = ISO_1600;
else if (!strcmp(new_iso_str, "sports"))
- new_iso = SecCamera::ISO_SPORTS;
+ new_iso = ISO_SPORTS;
else if (!strcmp(new_iso_str, "night"))
- new_iso = SecCamera::ISO_NIGHT;
+ new_iso = ISO_NIGHT;
else if (!strcmp(new_iso_str, "movie"))
- new_iso = SecCamera::ISO_MOVIE;
+ new_iso = ISO_MOVIE;
else {
LOGE("%s::unmatched iso(%d)", __func__, new_iso);
ret = UNKNOWN_ERROR;
@@ -1816,11 +1815,11 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
if (new_metering_str != NULL) {
int new_metering = -1;
if (!strcmp(new_metering_str, "matrix"))
- new_metering = SecCamera::METERING_MATRIX;
+ new_metering = METERING_MATRIX;
else if (!strcmp(new_metering_str, "center"))
- new_metering = SecCamera::METERING_CENTER;
+ new_metering = METERING_CENTER;
else if (!strcmp(new_metering_str, "spot"))
- new_metering = SecCamera::METERING_SPOT;
+ new_metering = METERING_SPOT;
else {
LOGE("%s::unmatched metering(%s)", __func__, new_metering_str);
ret = UNKNOWN_ERROR;
@@ -1850,19 +1849,19 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
int new_white = -1;
if (!strcmp(new_white_str, CameraParameters::WHITE_BALANCE_AUTO))
- new_white = SecCamera::WHITE_BALANCE_AUTO;
+ new_white = WHITE_BALANCE_AUTO;
else if (!strcmp(new_white_str,
CameraParameters::WHITE_BALANCE_DAYLIGHT))
- new_white = SecCamera::WHITE_BALANCE_DAYLIGHT;
+ new_white = WHITE_BALANCE_SUNNY;
else if (!strcmp(new_white_str,
CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT))
- new_white = SecCamera::WHITE_BALANCE_CLOUDY;
+ new_white = WHITE_BALANCE_CLOUDY;
else if (!strcmp(new_white_str,
CameraParameters::WHITE_BALANCE_FLUORESCENT))
- new_white = SecCamera::WHITE_BALANCE_FLUORESCENT;
+ new_white = WHITE_BALANCE_FLUORESCENT;
else if (!strcmp(new_white_str,
CameraParameters::WHITE_BALANCE_INCANDESCENT))
- new_white = SecCamera::WHITE_BALANCE_INCANDESCENT;
+ new_white = WHITE_BALANCE_TUNGSTEN;
else {
LOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent
ret = UNKNOWN_ERROR;
@@ -1899,19 +1898,19 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
if (!strcmp(new_focus_mode_str,
CameraParameters::FOCUS_MODE_AUTO)) {
- new_focus_mode = SecCamera::FOCUS_MODE_AUTO;
+ new_focus_mode = FOCUS_MODE_AUTO;
mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR);
}
else if (!strcmp(new_focus_mode_str,
CameraParameters::FOCUS_MODE_MACRO)) {
- new_focus_mode = SecCamera::FOCUS_MODE_MACRO;
+ new_focus_mode = FOCUS_MODE_MACRO;
mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR);
}
else if (!strcmp(new_focus_mode_str,
CameraParameters::FOCUS_MODE_INFINITY)) {
- new_focus_mode = SecCamera::FOCUS_MODE_INFINITY;
+ new_focus_mode = FOCUS_MODE_INFINITY;
mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES,
BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR);
}
@@ -1933,11 +1932,11 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
int new_flash_mode = -1;
if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_OFF))
- new_flash_mode = SecCamera::FLASH_MODE_OFF;
+ new_flash_mode = FLASH_MODE_OFF;
else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_AUTO))
- new_flash_mode = SecCamera::FLASH_MODE_AUTO;
+ new_flash_mode = FLASH_MODE_AUTO;
else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_ON))
- new_flash_mode = SecCamera::FLASH_MODE_ON;
+ new_flash_mode = FLASH_MODE_ON;
else {
LOGE("%s::unmatched flash_mode(%s)", __func__, new_flash_mode_str); //red-eye
ret = UNKNOWN_ERROR;
@@ -1968,15 +1967,15 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
int new_image_effect = -1;
if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NONE))
- new_image_effect = SecCamera::IMAGE_EFFECT_NONE;
+ new_image_effect = IMAGE_EFFECT_NONE;
else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_MONO))
- new_image_effect = SecCamera::IMAGE_EFFECT_BNW;
+ new_image_effect = IMAGE_EFFECT_BNW;
else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_SEPIA))
- new_image_effect = SecCamera::IMAGE_EFFECT_SEPIA;
+ new_image_effect = IMAGE_EFFECT_SEPIA;
else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_AQUA))
- new_image_effect = SecCamera::IMAGE_EFFECT_AQUA;
+ new_image_effect = IMAGE_EFFECT_AQUA;
else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NEGATIVE))
- new_image_effect = SecCamera::IMAGE_EFFECT_NEGATIVE;
+ new_image_effect = IMAGE_EFFECT_NEGATIVE;
else {
//posterize, whiteboard, blackboard, solarize
LOGE("ERR(%s):Invalid effect(%s)", __func__, new_image_effect_str);
@@ -1998,13 +1997,13 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
int new_antibanding = -1;
if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_AUTO))
- new_antibanding = SecCamera::ANTI_BANDING_AUTO;
+ new_antibanding = ANTI_BANDING_AUTO;
else if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_50HZ))
- new_antibanding = SecCamera::ANTI_BANDING_50HZ;
+ new_antibanding = ANTI_BANDING_50HZ;
else if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_60HZ))
- new_antibanding = SecCamera::ANTI_BANDING_60HZ;
+ new_antibanding = ANTI_BANDING_60HZ;
else if (!strcmp(new_antibanding_str, CameraParameters::ANTIBANDING_OFF))
- new_antibanding = SecCamera::ANTI_BANDING_OFF;
+ new_antibanding = ANTI_BANDING_OFF;
else {
LOGE("%s::unmatched antibanding(%s)", __func__, new_antibanding_str);
ret = UNKNOWN_ERROR;
@@ -2102,9 +2101,9 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
if (new_gamma_str != NULL) {
int new_gamma = -1;
if (!strcmp(new_gamma_str, "off"))
- new_gamma = SecCamera::GAMMA_OFF;
+ new_gamma = GAMMA_OFF;
else if (!strcmp(new_gamma_str, "on"))
- new_gamma = SecCamera::GAMMA_ON;
+ new_gamma = GAMMA_ON;
else {
LOGE("%s::unmatched gamma(%s)", __func__, new_gamma_str);
ret = UNKNOWN_ERROR;
@@ -2125,9 +2124,9 @@ status_t CameraHardwareSec::setParameters(const CameraParameters& params)
int new_slow_ae = -1;
if (!strcmp(new_slow_ae_str, "off"))
- new_slow_ae = SecCamera::SLOW_AE_OFF;
+ new_slow_ae = SLOW_AE_OFF;
else if (!strcmp(new_slow_ae_str, "on"))
- new_slow_ae = SecCamera::SLOW_AE_ON;
+ new_slow_ae = SLOW_AE_ON;
else {
LOGE("%s::unmatched slow_ae(%s)", __func__, new_slow_ae_str);
ret = UNKNOWN_ERROR;
generated by cgit v1.1 at 2024-06-03 08:50:56 +0000