3 ** Copyright 2008, The Android Open Source Project
4 ** Copyright 2012, Samsung Electronics Co. LTD
6 ** Licensed under the Apache License, Version 2.0 (the "License");
7 ** you may not use this file except in compliance with the License.
8 ** You may obtain a copy of the License at
10 ** http://www.apache.org/licenses/LICENSE-2.0
12 ** Unless required by applicable law or agreed to in writing, software
13 ** distributed under the License is distributed on an "AS IS" BASIS,
14 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 ** See the License for the specific language governing permissions and
16 ** limitations under the License.
20 * \file ExynosCamera2.cpp
21 * \brief source file for static information of camera2
22 * \author Sungjoong Kang(sj3.kang@samsung.com)
25 * <b>Revision History: </b>
26 * - 2012/08/06 : Sungjoong Kang(sj3.kang@samsung.com) \n
31 //#define LOG_NDEBUG 0
32 #define LOG_TAG "ExynosCamera2"
33 #include <utils/Log.h>
35 #include "ExynosCamera2.h"
37 #define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
44 * Static sensor characteristics
46 static const unsigned int kResolution
[2][2];
48 static const nsecs_t kExposureTimeRange
[2];
49 static const nsecs_t kFrameDurationRange
[2];
50 static const nsecs_t kMinVerticalBlank
;
52 static const uint8_t kColorFilterArrangement
;
54 // Output image data characteristics
55 static const uint32_t kMaxRawValue
;
56 static const uint32_t kBlackLevel
;
57 // Sensor sensitivity, approximate
59 static const float kSaturationVoltage
;
60 static const uint32_t kSaturationElectrons
;
61 static const float kVoltsPerLuxSecond
;
62 static const float kElectronsPerLuxSecond
;
64 static const float kBaseGainFactor
;
66 static const float kReadNoiseStddevBeforeGain
; // In electrons
67 static const float kReadNoiseStddevAfterGain
; // In raw digital units
68 static const float kReadNoiseVarBeforeGain
;
69 static const float kReadNoiseVarAfterGain
;
71 // While each row has to read out, reset, and then expose, the (reset +
72 // expose) sequence can be overlapped by other row readouts, so the final
73 // minimum frame duration is purely a function of row readout time, at least
74 // if there's a reasonable number of rows.
75 static const nsecs_t kRowReadoutTime
;
77 static const int32_t kSensitivityRange
[2];
78 static const uint32_t kDefaultSensitivity
;
84 const int32_t Sensor::kSensitivityRange
[2] = {100, 1600};
85 const nsecs_t
Sensor::kExposureTimeRange
[2] =
86 {1000L, 30000000000L} ; // 1 us - 30 sec
87 const nsecs_t
Sensor::kFrameDurationRange
[2] =
88 {33331760L, 30000000000L}; // ~1/30 s - 30 sec
90 const uint8_t Sensor::kColorFilterArrangement
= ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB
;
92 const uint32_t kAvailableFormats
[5] = {
93 HAL_PIXEL_FORMAT_RAW_SENSOR
,
94 HAL_PIXEL_FORMAT_BLOB
,
95 HAL_PIXEL_FORMAT_RGBA_8888
,
96 HAL_PIXEL_FORMAT_YV12
,
97 HAL_PIXEL_FORMAT_YCrCb_420_SP
100 // Output image data characteristics
101 const uint32_t Sensor::kMaxRawValue
= 4000;
102 const uint32_t Sensor::kBlackLevel
= 1000;
104 const uint64_t kAvailableRawMinDurations
[1] = {
105 Sensor::kFrameDurationRange
[0]
108 const uint64_t kAvailableProcessedMinDurations
[1] = {
109 Sensor::kFrameDurationRange
[0]
111 const uint64_t kAvailableJpegMinDurations
[1] = {
112 Sensor::kFrameDurationRange
[0]
115 const int32_t scalerResolutionS5K4E5
[] =
135 const int32_t jpegResolutionS5K4E5
[] =
149 const uint8_t availableAfModesS5K4E5
[] =
151 ANDROID_CONTROL_AF_MODE_OFF
,
152 ANDROID_CONTROL_AF_MODE_AUTO
,
153 ANDROID_CONTROL_AF_MODE_MACRO
,
154 ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
,
155 ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO
158 const uint8_t sceneModeOverridesS5K4E5
[] =
160 // ANDROID_CONTROL_SCENE_MODE_ACTION
161 ANDROID_CONTROL_AE_MODE_ON
,
162 ANDROID_CONTROL_AWB_MODE_AUTO
,
163 ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
,
164 // ANDROID_CONTROL_SCENE_MODE_NIGHT
165 ANDROID_CONTROL_AE_MODE_ON
,
166 ANDROID_CONTROL_AWB_MODE_AUTO
,
167 ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
,
168 // ANDROID_CONTROL_SCENE_MODE_SUNSET
169 ANDROID_CONTROL_AE_MODE_ON
,
170 ANDROID_CONTROL_AWB_MODE_DAYLIGHT
,
171 ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
,
172 // ANDROID_CONTROL_SCENE_MODE_PARTY
173 ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH
,
174 ANDROID_CONTROL_AWB_MODE_AUTO
,
175 ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
178 const uint8_t availableAeModesS5K4E5
[] =
180 ANDROID_CONTROL_AE_MODE_OFF
,
181 ANDROID_CONTROL_AE_MODE_ON
,
182 ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH
185 ExynosCamera2InfoS5K4E5::ExynosCamera2InfoS5K4E5()
189 sensorRawW
= (2560 + 16);
190 sensorRawH
= (1920 + 10);
191 numScalerResolution
= ARRAY_SIZE(scalerResolutionS5K4E5
)/2;
192 scalerResolutions
= scalerResolutionS5K4E5
;
193 numJpegResolution
= ARRAY_SIZE(jpegResolutionS5K4E5
)/2;
194 jpegResolutions
= jpegResolutionS5K4E5
;
195 minFocusDistance
= 0.1f
;
199 availableAfModes
= availableAfModesS5K4E5
;
200 numAvailableAfModes
= ARRAY_SIZE(availableAfModesS5K4E5
);
201 sceneModeOverrides
= sceneModeOverridesS5K4E5
;
202 numSceneModeOverrides
= ARRAY_SIZE(sceneModeOverridesS5K4E5
);
203 availableAeModes
= availableAeModesS5K4E5
;
204 numAvailableAeModes
= ARRAY_SIZE(availableAeModesS5K4E5
);
207 ExynosCamera2InfoS5K4E5::~ExynosCamera2InfoS5K4E5()
209 ALOGV("%s", __FUNCTION__
);
211 const int32_t scalerResolutionS5K6A3
[] =
231 const int32_t jpegResolutionS5K6A3
[] =
245 const uint8_t availableAfModesS5K6A3
[] =
247 ANDROID_CONTROL_AF_MODE_OFF
250 const uint8_t sceneModeOverridesS5K6A3
[] =
252 // ANDROID_CONTROL_SCENE_MODE_ACTION
253 ANDROID_CONTROL_AE_MODE_ON
,
254 ANDROID_CONTROL_AWB_MODE_AUTO
,
255 ANDROID_CONTROL_AF_MODE_OFF
,
256 // ANDROID_CONTROL_SCENE_MODE_NIGHT
257 ANDROID_CONTROL_AE_MODE_ON
,
258 ANDROID_CONTROL_AWB_MODE_AUTO
,
259 ANDROID_CONTROL_AF_MODE_OFF
,
260 // ANDROID_CONTROL_SCENE_MODE_SUNSET
261 ANDROID_CONTROL_AE_MODE_ON
,
262 ANDROID_CONTROL_AWB_MODE_DAYLIGHT
,
263 ANDROID_CONTROL_AF_MODE_OFF
,
264 // ANDROID_CONTROL_SCENE_MODE_PARTY
265 ANDROID_CONTROL_AE_MODE_ON
,
266 ANDROID_CONTROL_AWB_MODE_AUTO
,
267 ANDROID_CONTROL_AF_MODE_OFF
270 const uint8_t availableAeModesS5K6A3
[] =
272 ANDROID_CONTROL_AE_MODE_OFF
,
273 ANDROID_CONTROL_AE_MODE_ON
276 ExynosCamera2InfoS5K6A3::ExynosCamera2InfoS5K6A3()
280 sensorRawW
= (1392 + 16);
281 sensorRawH
= (1392 + 10);
282 numScalerResolution
= ARRAY_SIZE(scalerResolutionS5K6A3
)/2;
283 scalerResolutions
= scalerResolutionS5K6A3
;
284 numJpegResolution
= ARRAY_SIZE(jpegResolutionS5K6A3
)/2;
285 jpegResolutions
= jpegResolutionS5K6A3
;
286 minFocusDistance
= 0.0f
;
290 availableAfModes
= availableAfModesS5K6A3
;
291 numAvailableAfModes
= ARRAY_SIZE(availableAfModesS5K6A3
);
292 sceneModeOverrides
= sceneModeOverridesS5K6A3
;
293 numSceneModeOverrides
= ARRAY_SIZE(sceneModeOverridesS5K6A3
);
294 availableAeModes
= availableAeModesS5K6A3
;
295 numAvailableAeModes
= ARRAY_SIZE(availableAeModesS5K6A3
);
298 ExynosCamera2InfoS5K6A3::~ExynosCamera2InfoS5K6A3()
300 ALOGV("%s", __FUNCTION__
);
302 ExynosCamera2::ExynosCamera2(int cameraId
):
306 m_curCameraInfo
= new ExynosCamera2InfoS5K4E5
;
308 m_curCameraInfo
= new ExynosCamera2InfoS5K6A3
;
311 ExynosCamera2::~ExynosCamera2()
313 ALOGV("%s", __FUNCTION__
);
314 delete m_curCameraInfo
;
315 m_curCameraInfo
= NULL
;
318 int32_t ExynosCamera2::getSensorW()
320 return m_curCameraInfo
->sensorW
;
323 int32_t ExynosCamera2::getSensorH()
325 return m_curCameraInfo
->sensorH
;
328 int32_t ExynosCamera2::getSensorRawW()
330 return m_curCameraInfo
->sensorRawW
;
333 int32_t ExynosCamera2::getSensorRawH()
335 return m_curCameraInfo
->sensorRawH
;
338 bool ExynosCamera2::isSupportedResolution(int width
, int height
)
341 for (i
= 0 ; i
< m_curCameraInfo
->numScalerResolution
; i
++) {
342 if (m_curCameraInfo
->scalerResolutions
[2*i
] == width
343 && m_curCameraInfo
->scalerResolutions
[2*i
+1] == height
) {
350 bool ExynosCamera2::isSupportedJpegResolution(int width
, int height
)
353 for (i
= 0 ; i
< m_curCameraInfo
->numJpegResolution
; i
++) {
354 if (m_curCameraInfo
->jpegResolutions
[2*i
] == width
355 && m_curCameraInfo
->jpegResolutions
[2*i
+1] == height
) {
362 status_t
addOrSize(camera_metadata_t
*request
,
367 const void *entryData
,
368 size_t entryDataCount
) {
371 return add_camera_metadata_entry(request
, tag
, entryData
,
374 int type
= get_camera_metadata_tag_type(tag
);
375 if (type
< 0 ) return BAD_VALUE
;
377 (*dataCount
) += calculate_camera_metadata_entry_data_size(type
,
383 status_t
ExynosCamera2::constructStaticInfo(camera_metadata_t
**info
,
384 int cameraId
, bool sizeRequest
) {
386 size_t entryCount
= 0;
387 size_t dataCount
= 0;
390 #define ADD_OR_SIZE( tag, data, count ) \
391 if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \
392 tag, data, count) ) != OK ) return ret
396 int32_t hardwareLevel
= ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
;
397 ADD_OR_SIZE(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL
,
402 ADD_OR_SIZE(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE
,
403 &(m_curCameraInfo
->minFocusDistance
), 1);
404 ADD_OR_SIZE(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE
,
405 &(m_curCameraInfo
->minFocusDistance
), 1);
407 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS
,
408 &m_curCameraInfo
->focalLength
, 1);
409 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_APERTURES
,
410 &m_curCameraInfo
->aperture
, 1);
412 static const float filterDensity
= 0;
413 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES
,
415 static const uint8_t availableOpticalStabilization
=
416 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF
;
417 ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION
,
418 &availableOpticalStabilization
, 1);
420 static const int32_t lensShadingMapSize
[] = {1, 1};
421 ADD_OR_SIZE(ANDROID_LENS_INFO_SHADING_MAP_SIZE
, lensShadingMapSize
,
422 sizeof(lensShadingMapSize
)/sizeof(int32_t));
424 int32_t lensFacing
= cameraId
?
425 ANDROID_LENS_FACING_FRONT
: ANDROID_LENS_FACING_BACK
;
426 ADD_OR_SIZE(ANDROID_LENS_FACING
, &lensFacing
, 1);
429 static const int32_t maxNumOutputStreams
[] = {1, 3, 1};
430 ADD_OR_SIZE(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS
, maxNumOutputStreams
,
431 sizeof(maxNumOutputStreams
)/sizeof(int32_t));
434 ADD_OR_SIZE(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE
,
435 Sensor::kExposureTimeRange
, 2);
437 ADD_OR_SIZE(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION
,
438 &Sensor::kFrameDurationRange
[1], 1);
440 ADD_OR_SIZE(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE
,
441 Sensor::kSensitivityRange
,
442 sizeof(Sensor::kSensitivityRange
)
445 ADD_OR_SIZE(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT
,
446 &Sensor::kColorFilterArrangement
, 1);
448 // Empirically derived to get correct FOV measurements
449 static const float sensorPhysicalSize
[2] = {3.50f
, 2.625f
}; // mm
450 ADD_OR_SIZE(ANDROID_SENSOR_INFO_PHYSICAL_SIZE
,
451 sensorPhysicalSize
, 2);
453 int32_t pixelArraySize
[2] = {
454 m_curCameraInfo
->sensorW
, m_curCameraInfo
->sensorH
456 ADD_OR_SIZE(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE
, pixelArraySize
, 2);
458 int32_t activeArraySize
[4] = { 0, 0, pixelArraySize
[0], pixelArraySize
[1]};
459 ADD_OR_SIZE(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE
, activeArraySize
,4);
461 ADD_OR_SIZE(ANDROID_SENSOR_INFO_WHITE_LEVEL
,
462 &Sensor::kMaxRawValue
, 1);
464 static const int32_t blackLevelPattern
[4] = {
465 Sensor::kBlackLevel
, Sensor::kBlackLevel
,
466 Sensor::kBlackLevel
, Sensor::kBlackLevel
468 ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN
,
469 blackLevelPattern
, sizeof(blackLevelPattern
)/sizeof(int32_t));
471 static const int32_t orientation
[1] = {0};
472 ADD_OR_SIZE(ANDROID_SENSOR_ORIENTATION
,
475 //TODO: sensor color calibration fields
478 uint8_t flashAvailable
;
483 ADD_OR_SIZE(ANDROID_FLASH_INFO_AVAILABLE
, &flashAvailable
, 1);
485 static const int64_t flashChargeDuration
= 0;
486 ADD_OR_SIZE(ANDROID_FLASH_INFO_CHARGE_DURATION
, &flashChargeDuration
, 1);
490 static const int32_t tonemapCurvePoints
= 128;
491 ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS
, &tonemapCurvePoints
, 1);
495 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS
,
497 sizeof(kAvailableFormats
)/sizeof(uint32_t));
499 int32_t availableRawSizes
[2] = {
500 m_curCameraInfo
->sensorRawW
, m_curCameraInfo
->sensorRawH
502 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES
,
503 availableRawSizes
, 2);
505 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS
,
506 kAvailableRawMinDurations
,
507 sizeof(kAvailableRawMinDurations
)/sizeof(uint64_t));
510 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES
,
511 m_curCameraInfo
->scalerResolutions
,
512 (m_curCameraInfo
->numScalerResolution
)*2);
513 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES
,
514 m_curCameraInfo
->jpegResolutions
,
515 (m_curCameraInfo
->numJpegResolution
)*2);
517 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS
,
518 kAvailableProcessedMinDurations
,
519 sizeof(kAvailableProcessedMinDurations
)/sizeof(uint64_t));
521 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS
,
522 kAvailableJpegMinDurations
,
523 sizeof(kAvailableJpegMinDurations
)/sizeof(uint64_t));
525 static const float maxZoom
= 4;
526 ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM
, &maxZoom
, 1);
530 static const int32_t jpegThumbnailSizes
[] = {
538 ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES
,
539 jpegThumbnailSizes
, sizeof(jpegThumbnailSizes
)/sizeof(int32_t));
541 static const int32_t jpegMaxSize
= 10 * 1024 * 1024;
542 ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE
, &jpegMaxSize
, 1);
546 static const uint8_t availableFaceDetectModes
[] = {
547 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF
,
548 ANDROID_STATISTICS_FACE_DETECT_MODE_FULL
550 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES
,
551 availableFaceDetectModes
,
552 sizeof(availableFaceDetectModes
));
554 m_curCameraInfo
->maxFaceCount
= CAMERA2_MAX_FACES
;
555 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT
,
556 &(m_curCameraInfo
->maxFaceCount
), 1);
558 static const int32_t histogramSize
= 64;
559 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT
,
562 static const int32_t maxHistogramCount
= 1000;
563 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT
,
564 &maxHistogramCount
, 1);
566 static const int32_t sharpnessMapSize
[2] = {64, 64};
567 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE
,
568 sharpnessMapSize
, sizeof(sharpnessMapSize
)/sizeof(int32_t));
570 static const int32_t maxSharpnessMapValue
= 1000;
571 ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE
,
572 &maxSharpnessMapValue
, 1);
576 static const uint8_t availableSceneModes
[] = {
577 ANDROID_CONTROL_SCENE_MODE_ACTION
,
578 ANDROID_CONTROL_SCENE_MODE_NIGHT
,
579 ANDROID_CONTROL_SCENE_MODE_SUNSET
,
580 ANDROID_CONTROL_SCENE_MODE_PARTY
582 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES
,
583 availableSceneModes
, sizeof(availableSceneModes
));
585 static const uint8_t availableEffects
[] = {
586 ANDROID_CONTROL_EFFECT_MODE_OFF
588 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS
,
589 availableEffects
, sizeof(availableEffects
));
591 int32_t max3aRegions
= 1;
592 ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS
,
595 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES
,
596 m_curCameraInfo
->availableAeModes
, m_curCameraInfo
->numAvailableAeModes
);
598 static const camera_metadata_rational exposureCompensationStep
= {
601 ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_STEP
,
602 &exposureCompensationStep
, 1);
604 int32_t exposureCompensationRange
[] = {-3, 3};
605 ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_RANGE
,
606 exposureCompensationRange
,
607 sizeof(exposureCompensationRange
)/sizeof(int32_t));
609 static const int32_t availableTargetFpsRanges
[] = {
610 15, 15, 24, 24, 25, 25, 15, 30, 30, 30
612 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES
,
613 availableTargetFpsRanges
,
614 sizeof(availableTargetFpsRanges
)/sizeof(int32_t));
616 static const uint8_t availableAntibandingModes
[] = {
617 ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF
,
618 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO
620 ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES
,
621 availableAntibandingModes
, sizeof(availableAntibandingModes
));
623 static const uint8_t availableAwbModes
[] = {
624 ANDROID_CONTROL_AWB_MODE_OFF
,
625 ANDROID_CONTROL_AWB_MODE_AUTO
,
626 ANDROID_CONTROL_AWB_MODE_INCANDESCENT
,
627 ANDROID_CONTROL_AWB_MODE_FLUORESCENT
,
628 ANDROID_CONTROL_AWB_MODE_DAYLIGHT
,
629 ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT
631 ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES
,
632 availableAwbModes
, sizeof(availableAwbModes
));
634 ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES
,
635 m_curCameraInfo
->availableAfModes
, m_curCameraInfo
->numAvailableAfModes
);
637 static const uint8_t availableVstabModes
[] = {
638 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF
,
639 ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON
641 ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES
,
642 availableVstabModes
, sizeof(availableVstabModes
));
644 ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE_OVERRIDES
,
645 m_curCameraInfo
->sceneModeOverrides
, m_curCameraInfo
->numSceneModeOverrides
);
647 static const uint8_t quirkTriggerAuto
= 1;
648 ADD_OR_SIZE(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO
,
649 &quirkTriggerAuto
, 1);
651 static const uint8_t quirkUseZslFormat
= 1;
652 ADD_OR_SIZE(ANDROID_QUIRKS_USE_ZSL_FORMAT
,
653 &quirkUseZslFormat
, 1);
655 static const uint8_t quirkMeteringCropRegion
= 1;
656 ADD_OR_SIZE(ANDROID_QUIRKS_METERING_CROP_REGION
,
657 &quirkMeteringCropRegion
, 1);
661 /** Allocate metadata if sizing */
663 ALOGV("Allocating %d entries, %d extra bytes for "
664 "static camera info",
665 entryCount
, dataCount
);
666 *info
= allocate_camera_metadata(entryCount
, dataCount
);
668 ALOGE("Unable to allocate camera static info"
669 "(%d entries, %d bytes extra data)",
670 entryCount
, dataCount
);
677 status_t
ExynosCamera2::constructDefaultRequest(
678 int request_template
,
679 camera_metadata_t
**request
,
682 size_t entryCount
= 0;
683 size_t dataCount
= 0;
686 #define ADD_OR_SIZE( tag, data, count ) \
687 if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \
688 tag, data, count) ) != OK ) return ret
690 static const int64_t USEC
= 1000LL;
691 static const int64_t MSEC
= USEC
* 1000LL;
692 static const int64_t SEC
= MSEC
* 1000LL;
694 /** android.request */
696 static const uint8_t metadataMode
= ANDROID_REQUEST_METADATA_MODE_NONE
;
697 ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE
, &metadataMode
, 1);
699 static const int32_t id
= 0;
700 ADD_OR_SIZE(ANDROID_REQUEST_ID
, &id
, 1);
702 static const int32_t frameCount
= 0;
703 ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT
, &frameCount
, 1);
705 // OUTPUT_STREAMS set by user
707 dataCount
+= 5; // TODO: Should be maximum stream number
711 static const float focusDistance
= 0;
712 ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE
, &focusDistance
, 1);
714 ADD_OR_SIZE(ANDROID_LENS_APERTURE
, &m_curCameraInfo
->aperture
, 1);
716 ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH
, &m_curCameraInfo
->focalLength
, 1);
718 static const float filterDensity
= 0;
719 ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY
, &filterDensity
, 1);
721 static const uint8_t opticalStabilizationMode
=
722 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF
;
723 ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE
,
724 &opticalStabilizationMode
, 1);
727 /** android.sensor */
729 static const int64_t defaultExposureTime
= 8000000LL; // 1/125 s
730 ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME
, &defaultExposureTime
, 1);
732 static const int64_t frameDuration
= 33333333L; // 1/30 s
733 ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION
, &frameDuration
, 1);
738 static const uint8_t flashMode
= ANDROID_FLASH_MODE_OFF
;
739 ADD_OR_SIZE(ANDROID_FLASH_MODE
, &flashMode
, 1);
741 static const uint8_t flashPower
= 10;
742 ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER
, &flashPower
, 1);
744 static const int64_t firingTime
= 0;
745 ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME
, &firingTime
, 1);
747 /** Processing block modes */
748 uint8_t hotPixelMode
= 0;
749 uint8_t demosaicMode
= 0;
750 uint8_t noiseMode
= 0;
751 uint8_t shadingMode
= 0;
752 uint8_t geometricMode
= 0;
753 uint8_t colorMode
= 0;
754 uint8_t tonemapMode
= 0;
755 uint8_t edgeMode
= 0;
756 uint8_t vstabMode
= ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF
;
758 switch (request_template
) {
759 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT
:
760 vstabMode
= ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON
;
762 case CAMERA2_TEMPLATE_STILL_CAPTURE
:
764 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG
:
765 hotPixelMode
= ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY
;
766 demosaicMode
= ANDROID_DEMOSAIC_MODE_HIGH_QUALITY
;
767 noiseMode
= ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY
;
768 shadingMode
= ANDROID_SHADING_MODE_HIGH_QUALITY
;
769 geometricMode
= ANDROID_GEOMETRIC_MODE_HIGH_QUALITY
;
770 colorMode
= ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY
;
771 tonemapMode
= ANDROID_TONEMAP_MODE_HIGH_QUALITY
;
772 edgeMode
= ANDROID_EDGE_MODE_HIGH_QUALITY
;
774 case CAMERA2_TEMPLATE_VIDEO_RECORD
:
775 vstabMode
= ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON
;
777 case CAMERA2_TEMPLATE_PREVIEW
:
780 hotPixelMode
= ANDROID_HOT_PIXEL_MODE_FAST
;
781 demosaicMode
= ANDROID_DEMOSAIC_MODE_FAST
;
782 noiseMode
= ANDROID_NOISE_REDUCTION_MODE_FAST
;
783 shadingMode
= ANDROID_SHADING_MODE_FAST
;
784 geometricMode
= ANDROID_GEOMETRIC_MODE_FAST
;
785 colorMode
= ANDROID_COLOR_CORRECTION_MODE_FAST
;
786 tonemapMode
= ANDROID_TONEMAP_MODE_FAST
;
787 edgeMode
= ANDROID_EDGE_MODE_FAST
;
790 ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE
, &hotPixelMode
, 1);
791 ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE
, &demosaicMode
, 1);
792 ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_MODE
, &noiseMode
, 1);
793 ADD_OR_SIZE(ANDROID_SHADING_MODE
, &shadingMode
, 1);
794 ADD_OR_SIZE(ANDROID_GEOMETRIC_MODE
, &geometricMode
, 1);
795 ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_MODE
, &colorMode
, 1);
796 ADD_OR_SIZE(ANDROID_TONEMAP_MODE
, &tonemapMode
, 1);
797 ADD_OR_SIZE(ANDROID_EDGE_MODE
, &edgeMode
, 1);
798 ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE
, &vstabMode
, 1);
801 static const uint8_t noiseStrength
= 5;
802 ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_STRENGTH
, &noiseStrength
, 1);
805 static const float colorTransform
[9] = {
810 ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_TRANSFORM
, colorTransform
, 9);
812 /** android.tonemap */
813 static const float tonemapCurve
[4] = {
817 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED
, tonemapCurve
, 32); // sungjoong
818 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN
, tonemapCurve
, 32);
819 ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE
, tonemapCurve
, 32);
822 static const uint8_t edgeStrength
= 5;
823 ADD_OR_SIZE(ANDROID_EDGE_STRENGTH
, &edgeStrength
, 1);
825 /** android.scaler */
826 int32_t cropRegion
[3] = {
827 0, 0, m_curCameraInfo
->sensorW
829 ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION
, cropRegion
, 3);
832 static const int32_t jpegQuality
= 100;
833 ADD_OR_SIZE(ANDROID_JPEG_QUALITY
, &jpegQuality
, 1);
835 static const int32_t thumbnailSize
[2] = {
838 ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE
, thumbnailSize
, 2);
840 static const int32_t thumbnailQuality
= 100;
841 ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY
, &thumbnailQuality
, 1);
843 static const double gpsCoordinates
[3] = {
846 ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES
, gpsCoordinates
, 3);
848 static const uint8_t gpsProcessingMethod
[32] = "None";
849 ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD
, gpsProcessingMethod
, 32);
851 static const int64_t gpsTimestamp
= 0;
852 ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP
, &gpsTimestamp
, 1);
854 static const int32_t jpegOrientation
= 0;
855 ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION
, &jpegOrientation
, 1);
859 static const uint8_t faceDetectMode
= ANDROID_STATISTICS_FACE_DETECT_MODE_FULL
;
860 ADD_OR_SIZE(ANDROID_STATISTICS_FACE_DETECT_MODE
, &faceDetectMode
, 1);
862 static const uint8_t histogramMode
= ANDROID_STATISTICS_HISTOGRAM_MODE_OFF
;
863 ADD_OR_SIZE(ANDROID_STATISTICS_HISTOGRAM_MODE
, &histogramMode
, 1);
865 static const uint8_t sharpnessMapMode
= ANDROID_STATISTICS_HISTOGRAM_MODE_OFF
;
866 ADD_OR_SIZE(ANDROID_STATISTICS_SHARPNESS_MAP_MODE
, &sharpnessMapMode
, 1);
869 /** android.control */
871 uint8_t controlIntent
= 0;
872 switch (request_template
) {
873 case CAMERA2_TEMPLATE_PREVIEW
:
874 controlIntent
= ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW
;
876 case CAMERA2_TEMPLATE_STILL_CAPTURE
:
877 controlIntent
= ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE
;
879 case CAMERA2_TEMPLATE_VIDEO_RECORD
:
880 controlIntent
= ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD
;
882 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT
:
883 controlIntent
= ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT
;
885 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG
:
886 controlIntent
= ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG
;
889 controlIntent
= ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM
;
892 ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT
, &controlIntent
, 1);
894 static const uint8_t controlMode
= ANDROID_CONTROL_MODE_AUTO
;
895 ADD_OR_SIZE(ANDROID_CONTROL_MODE
, &controlMode
, 1);
897 static const uint8_t effectMode
= ANDROID_CONTROL_EFFECT_MODE_OFF
;
898 ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE
, &effectMode
, 1);
900 static const uint8_t sceneMode
= ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED
;
901 ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE
, &sceneMode
, 1);
903 static const uint8_t aeMode
= ANDROID_CONTROL_AE_MODE_ON
;
904 ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE
, &aeMode
, 1);
906 int32_t controlRegions
[5] = {
907 0, 0, m_curCameraInfo
->sensorW
, m_curCameraInfo
->sensorH
, 1000
909 ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS
, controlRegions
, 5);
911 static const int32_t aeExpCompensation
= 0;
912 ADD_OR_SIZE(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION
, &aeExpCompensation
, 1);
914 static const int32_t aeTargetFpsRange
[2] = {
917 ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE
, aeTargetFpsRange
, 2);
919 static const uint8_t aeAntibandingMode
=
920 ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO
;
921 ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE
, &aeAntibandingMode
, 1);
923 static const uint8_t awbMode
=
924 ANDROID_CONTROL_AWB_MODE_AUTO
;
925 ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE
, &awbMode
, 1);
927 ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS
, controlRegions
, 5);
930 switch (request_template
) {
931 case CAMERA2_TEMPLATE_PREVIEW
:
932 afMode
= ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
;
934 case CAMERA2_TEMPLATE_STILL_CAPTURE
:
935 afMode
= ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
;
937 case CAMERA2_TEMPLATE_VIDEO_RECORD
:
938 afMode
= ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO
;
940 case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT
:
941 afMode
= ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO
;
943 case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG
:
944 afMode
= ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
;
947 afMode
= ANDROID_CONTROL_AF_MODE_AUTO
;
950 ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE
, &afMode
, 1);
952 ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS
, controlRegions
, 5);
955 ALOGV("Allocating %d entries, %d extra bytes for "
956 "request template type %d",
957 entryCount
, dataCount
, request_template
);
958 *request
= allocate_camera_metadata(entryCount
, dataCount
);
959 if (*request
== NULL
) {
960 ALOGE("Unable to allocate new request template type %d "
961 "(%d entries, %d bytes extra data)", request_template
,
962 entryCount
, dataCount
);