1/*
2**
3** Copyright 2008, The Android Open Source Project
4** Copyright 2012, Samsung Electronics Co. LTD
5**
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
9**
10**     http://www.apache.org/licenses/LICENSE-2.0
11**
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.
17*/
18
19/*!
20 * \file      ExynosCamera2.cpp
21 * \brief     source file for static information of camera2
22 * \author    Sungjoong Kang(sj3.kang@samsung.com)
23 * \date      2012/08/06
24 *
25 * <b>Revision History: </b>
26 * - 2012/08/06 : Sungjoong Kang(sj3.kang@samsung.com) \n
27 *   Initial Release
28 *
29 */
30
31//#define LOG_NDEBUG 0
32#define LOG_TAG "ExynosCamera2"
33#include <utils/Log.h>
34
35#include "ExynosCamera2.h"
36
37#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))
38
39namespace android {
40
41class Sensor {
42public:
43    /**
44     * Static sensor characteristics
45     */
46    static const unsigned int kResolution[2][2];
47
48    static const nsecs_t kExposureTimeRange[2];
49    static const nsecs_t kFrameDurationRange[2];
50    static const nsecs_t kMinVerticalBlank;
51
52    static const uint8_t kColorFilterArrangement;
53
54    // Output image data characteristics
55    static const uint32_t kMaxRawValue;
56    static const uint32_t kBlackLevel;
57    // Sensor sensitivity, approximate
58
59    static const float kSaturationVoltage;
60    static const uint32_t kSaturationElectrons;
61    static const float kVoltsPerLuxSecond;
62    static const float kElectronsPerLuxSecond;
63
64    static const float kBaseGainFactor;
65
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;
70
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;
76
77    static const int32_t kSensitivityRange[2];
78    static const uint32_t kDefaultSensitivity;
79
80};
81
82
83
84const int32_t Sensor::kSensitivityRange[2] = {100, 1600};
85const nsecs_t Sensor::kExposureTimeRange[2] =
86    {1000L, 30000000000L} ; // 1 us - 30 sec
87const nsecs_t Sensor::kFrameDurationRange[2] =
88    {33331760L, 30000000000L}; // ~1/30 s - 30 sec
89
90const uint8_t Sensor::kColorFilterArrangement = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB;
91
92const 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
98};
99
100// Output image data characteristics
101const uint32_t Sensor::kMaxRawValue = 4000;
102const uint32_t Sensor::kBlackLevel  = 1000;
103
104const uint64_t kAvailableRawMinDurations[1] = {
105    Sensor::kFrameDurationRange[0]
106};
107
108const uint64_t kAvailableProcessedMinDurations[1] = {
109    Sensor::kFrameDurationRange[0]
110};
111const uint64_t kAvailableJpegMinDurations[1] = {
112    Sensor::kFrameDurationRange[0]
113};
114
115const int32_t scalerResolutionS5K4E5[] =
116{
117    1920, 1080, // 16:9
118    1440, 1080, // 4:3
119    1440,  960, // 3:2
120    1280, 1024, // 5:4
121    1280,  720, // 16:9
122     960,  720, // 4:3
123     800,  480, // 5:3
124     768,  576, // 4:3
125     720,  576, // 5:4
126     720,  480, // 3:2
127     640,  480, // 4:3
128     352,  288, // 11:9
129     320,  240, // 4:3
130     240,  160, // 3:2
131     176,  144, // 6:5
132     128,   96, // 4:3
133};
134
135const int32_t jpegResolutionS5K4E5[] =
136{
137    2560, 1920,
138    2560, 1440,
139    2160, 1440,
140    2048, 1536,
141    1600, 1200,
142    1280, 1024,
143    1280,  960,
144    1152,  864,
145     640,  480,
146     320,  240,
147};
148
149const uint8_t availableAfModesS5K4E5[] =
150{
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
156};
157
158const uint8_t sceneModeOverridesS5K4E5[] =
159{
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
176};
177
178const uint8_t availableAeModesS5K4E5[] =
179{
180    ANDROID_CONTROL_AE_MODE_OFF,
181    ANDROID_CONTROL_AE_MODE_ON,
182    ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH
183};
184
185ExynosCamera2InfoS5K4E5::ExynosCamera2InfoS5K4E5()
186{
187    sensorW             = 2560;
188    sensorH             = 1920;
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;
196    focalLength         = 3.43f;
197    aperture            = 2.7f;
198    fnumber             = 2.7f;
199    availableAfModes    = availableAfModesS5K4E5;
200    numAvailableAfModes = ARRAY_SIZE(availableAfModesS5K4E5);
201    sceneModeOverrides  = sceneModeOverridesS5K4E5;
202    numSceneModeOverrides = ARRAY_SIZE(sceneModeOverridesS5K4E5);
203    availableAeModes    = availableAeModesS5K4E5;
204    numAvailableAeModes = ARRAY_SIZE(availableAeModesS5K4E5);
205}
206
207ExynosCamera2InfoS5K4E5::~ExynosCamera2InfoS5K4E5()
208{
209    ALOGV("%s", __FUNCTION__);
210}
211const int32_t scalerResolutionS5K6A3[] =
212{
213    1344,  896, // 3:2
214    1280, 1024, // 5:4
215    1024, 1024, // 1:1
216    1280,  960, // 4:3
217    1280,  720, // 16:9
218     960,  720, // 4:3
219     800,  480, // 5:3
220     768,  576, // 4:3
221     720,  576, // 5:4
222     720,  480, // 3:2
223     640,  480, // 4:3
224     352,  288, // 11:9
225     320,  240, // 4:3
226     240,  160, // 3:2
227     176,  144, // 6:5
228     128,   96, // 4:3
229};
230
231const int32_t jpegResolutionS5K6A3[] =
232{
233    1392, 1392,
234    1392, 1040,
235    1392,  928,
236    1392,  784,
237    1280, 1024,
238    1280,  960,
239    1280,  720,
240    1152,  864,
241     640,  480,
242     320,  240,
243};
244
245const uint8_t availableAfModesS5K6A3[] =
246{
247    ANDROID_CONTROL_AF_MODE_OFF
248};
249
250const uint8_t sceneModeOverridesS5K6A3[] =
251{
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
268};
269
270const uint8_t availableAeModesS5K6A3[] =
271{
272    ANDROID_CONTROL_AE_MODE_OFF,
273    ANDROID_CONTROL_AE_MODE_ON
274};
275
276ExynosCamera2InfoS5K6A3::ExynosCamera2InfoS5K6A3()
277{
278    sensorW     = 1392;
279    sensorH     = 1392;
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;
287    focalLength         = 2.73f;
288    aperture            = 2.8f;
289    fnumber             = 2.8f;
290    availableAfModes    = availableAfModesS5K6A3;
291    numAvailableAfModes = ARRAY_SIZE(availableAfModesS5K6A3);
292    sceneModeOverrides  = sceneModeOverridesS5K6A3;
293    numSceneModeOverrides = ARRAY_SIZE(sceneModeOverridesS5K6A3);
294    availableAeModes    = availableAeModesS5K6A3;
295    numAvailableAeModes = ARRAY_SIZE(availableAeModesS5K6A3);
296}
297
298ExynosCamera2InfoS5K6A3::~ExynosCamera2InfoS5K6A3()
299{
300    ALOGV("%s", __FUNCTION__);
301}
302ExynosCamera2::ExynosCamera2(int cameraId):
303    m_cameraId(cameraId)
304{
305    if (cameraId == 0)
306        m_curCameraInfo      = new ExynosCamera2InfoS5K4E5;
307    else
308        m_curCameraInfo      = new ExynosCamera2InfoS5K6A3;
309}
310
311ExynosCamera2::~ExynosCamera2()
312{
313    ALOGV("%s", __FUNCTION__);
314	delete m_curCameraInfo;
315    m_curCameraInfo = NULL;
316}
317
318int32_t ExynosCamera2::getSensorW()
319{
320    return m_curCameraInfo->sensorW;
321}
322
323int32_t ExynosCamera2::getSensorH()
324{
325    return m_curCameraInfo->sensorH;
326}
327
328int32_t ExynosCamera2::getSensorRawW()
329{
330    return m_curCameraInfo->sensorRawW;
331}
332
333int32_t ExynosCamera2::getSensorRawH()
334{
335    return m_curCameraInfo->sensorRawH;
336}
337
338bool ExynosCamera2::isSupportedResolution(int width, int height)
339{
340    int i;
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) {
344            return true;
345        }
346    }
347    return false;
348}
349
350bool ExynosCamera2::isSupportedJpegResolution(int width, int height)
351{
352    int i;
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) {
356            return true;
357        }
358    }
359    return false;
360}
361
362status_t addOrSize(camera_metadata_t *request,
363        bool sizeRequest,
364        size_t *entryCount,
365        size_t *dataCount,
366        uint32_t tag,
367        const void *entryData,
368        size_t entryDataCount) {
369    status_t res;
370    if (!sizeRequest) {
371        return add_camera_metadata_entry(request, tag, entryData,
372                entryDataCount);
373    } else {
374        int type = get_camera_metadata_tag_type(tag);
375        if (type < 0 ) return BAD_VALUE;
376        (*entryCount)++;
377        (*dataCount) += calculate_camera_metadata_entry_data_size(type,
378                entryDataCount);
379        return OK;
380    }
381}
382
383status_t ExynosCamera2::constructStaticInfo(camera_metadata_t **info,
384        int cameraId, bool sizeRequest) {
385
386    size_t entryCount = 0;
387    size_t dataCount = 0;
388    status_t ret;
389
390#define ADD_OR_SIZE( tag, data, count ) \
391    if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \
392            tag, data, count) ) != OK ) return ret
393
394    // android.info
395
396    int32_t hardwareLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;
397    ADD_OR_SIZE(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
398            &hardwareLevel, 1);
399
400    // android.lens
401
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);
406
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);
411
412    static const float filterDensity = 0;
413    ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
414            &filterDensity, 1);
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);
419
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));
423
424    int32_t lensFacing = cameraId ?
425            ANDROID_LENS_FACING_FRONT : ANDROID_LENS_FACING_BACK;
426    ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1);
427
428    // android.request
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));
432
433    // android.sensor
434    ADD_OR_SIZE(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
435            Sensor::kExposureTimeRange, 2);
436
437    ADD_OR_SIZE(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
438            &Sensor::kFrameDurationRange[1], 1);
439
440    ADD_OR_SIZE(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
441            Sensor::kSensitivityRange,
442            sizeof(Sensor::kSensitivityRange)
443            /sizeof(int32_t));
444
445    ADD_OR_SIZE(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
446            &Sensor::kColorFilterArrangement, 1);
447
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);
452
453    int32_t pixelArraySize[2] = {
454        m_curCameraInfo->sensorW, m_curCameraInfo->sensorH
455    };
456    ADD_OR_SIZE(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, pixelArraySize, 2);
457
458    int32_t activeArraySize[4] = { 0, 0, pixelArraySize[0], pixelArraySize[1]};
459    ADD_OR_SIZE(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, activeArraySize,4);
460
461    ADD_OR_SIZE(ANDROID_SENSOR_INFO_WHITE_LEVEL,
462            &Sensor::kMaxRawValue, 1);
463
464    static const int32_t blackLevelPattern[4] = {
465            Sensor::kBlackLevel, Sensor::kBlackLevel,
466            Sensor::kBlackLevel, Sensor::kBlackLevel
467    };
468    ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
469            blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t));
470
471    static const int32_t orientation[1] = {0};
472    ADD_OR_SIZE(ANDROID_SENSOR_ORIENTATION,
473            orientation, 1);
474
475    //TODO: sensor color calibration fields
476
477    // android.flash
478    uint8_t flashAvailable;
479    if (cameraId == 0)
480        flashAvailable = 1;
481    else
482        flashAvailable = 0;
483    ADD_OR_SIZE(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1);
484
485    static const int64_t flashChargeDuration = 0;
486    ADD_OR_SIZE(ANDROID_FLASH_INFO_CHARGE_DURATION, &flashChargeDuration, 1);
487
488    // android.tonemap
489
490    static const int32_t tonemapCurvePoints = 128;
491    ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1);
492
493    // android.scaler
494
495    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS,
496            kAvailableFormats,
497            sizeof(kAvailableFormats)/sizeof(uint32_t));
498
499    int32_t availableRawSizes[2] = {
500        m_curCameraInfo->sensorRawW, m_curCameraInfo->sensorRawH
501    };
502    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
503            availableRawSizes, 2);
504
505    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
506            kAvailableRawMinDurations,
507            sizeof(kAvailableRawMinDurations)/sizeof(uint64_t));
508
509
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);
516
517    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
518            kAvailableProcessedMinDurations,
519            sizeof(kAvailableProcessedMinDurations)/sizeof(uint64_t));
520
521    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
522            kAvailableJpegMinDurations,
523            sizeof(kAvailableJpegMinDurations)/sizeof(uint64_t));
524
525    static const float maxZoom = 4;
526    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, &maxZoom, 1);
527
528    // android.jpeg
529
530    static const int32_t jpegThumbnailSizes[] = {
531            160, 120,
532            160, 160,
533            160, 90,
534            144, 96,
535              0, 0
536    };
537
538    ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
539            jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t));
540
541    static const int32_t jpegMaxSize = 10 * 1024 * 1024;
542    ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1);
543
544    // android.stats
545
546    static const uint8_t availableFaceDetectModes[] = {
547            ANDROID_STATISTICS_FACE_DETECT_MODE_OFF,
548            ANDROID_STATISTICS_FACE_DETECT_MODE_FULL
549    };
550    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
551            availableFaceDetectModes,
552            sizeof(availableFaceDetectModes));
553
554    m_curCameraInfo->maxFaceCount = CAMERA2_MAX_FACES;
555    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
556            &(m_curCameraInfo->maxFaceCount), 1);
557
558    static const int32_t histogramSize = 64;
559    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
560            &histogramSize, 1);
561
562    static const int32_t maxHistogramCount = 1000;
563    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
564            &maxHistogramCount, 1);
565
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));
569
570    static const int32_t maxSharpnessMapValue = 1000;
571    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
572            &maxSharpnessMapValue, 1);
573
574    // android.control
575
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
581    };
582    ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
583            availableSceneModes, sizeof(availableSceneModes));
584
585    static const uint8_t availableEffects[] = {
586            ANDROID_CONTROL_EFFECT_MODE_OFF
587    };
588    ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS,
589            availableEffects, sizeof(availableEffects));
590
591    int32_t max3aRegions = 1;
592    ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS,
593            &max3aRegions, 1);
594
595    ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES,
596            m_curCameraInfo->availableAeModes, m_curCameraInfo->numAvailableAeModes);
597
598    static const camera_metadata_rational exposureCompensationStep = {
599            1, 1
600    };
601    ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_STEP,
602            &exposureCompensationStep, 1);
603
604    int32_t exposureCompensationRange[] = {-3, 3};
605    ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
606            exposureCompensationRange,
607            sizeof(exposureCompensationRange)/sizeof(int32_t));
608
609    static const int32_t availableTargetFpsRanges[] = {
610            15, 15, 24, 24, 25, 25, 15, 30, 30, 30
611    };
612    ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
613            availableTargetFpsRanges,
614            sizeof(availableTargetFpsRanges)/sizeof(int32_t));
615
616    static const uint8_t availableAntibandingModes[] = {
617            ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,
618            ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO
619    };
620    ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
621            availableAntibandingModes, sizeof(availableAntibandingModes));
622
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
630    };
631    ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
632            availableAwbModes, sizeof(availableAwbModes));
633
634    ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES,
635                m_curCameraInfo->availableAfModes, m_curCameraInfo->numAvailableAfModes);
636
637    static const uint8_t availableVstabModes[] = {
638            ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF,
639            ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON
640    };
641    ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
642            availableVstabModes, sizeof(availableVstabModes));
643
644    ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
645            m_curCameraInfo->sceneModeOverrides, m_curCameraInfo->numSceneModeOverrides);
646
647    static const uint8_t quirkTriggerAuto = 1;
648    ADD_OR_SIZE(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO,
649            &quirkTriggerAuto, 1);
650
651    static const uint8_t quirkUseZslFormat = 1;
652    ADD_OR_SIZE(ANDROID_QUIRKS_USE_ZSL_FORMAT,
653            &quirkUseZslFormat, 1);
654
655    static const uint8_t quirkMeteringCropRegion = 1;
656    ADD_OR_SIZE(ANDROID_QUIRKS_METERING_CROP_REGION,
657            &quirkMeteringCropRegion, 1);
658
659
660#undef ADD_OR_SIZE
661    /** Allocate metadata if sizing */
662    if (sizeRequest) {
663        ALOGV("Allocating %d entries, %d extra bytes for "
664                "static camera info",
665                entryCount, dataCount);
666        *info = allocate_camera_metadata(entryCount, dataCount);
667        if (*info == NULL) {
668            ALOGE("Unable to allocate camera static info"
669                    "(%d entries, %d bytes extra data)",
670                    entryCount, dataCount);
671            return NO_MEMORY;
672        }
673    }
674    return OK;
675}
676
677status_t ExynosCamera2::constructDefaultRequest(
678        int request_template,
679        camera_metadata_t **request,
680        bool sizeRequest) {
681
682    size_t entryCount = 0;
683    size_t dataCount = 0;
684    status_t ret;
685
686#define ADD_OR_SIZE( tag, data, count ) \
687    if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \
688            tag, data, count) ) != OK ) return ret
689
690    static const int64_t USEC = 1000LL;
691    static const int64_t MSEC = USEC * 1000LL;
692    static const int64_t SEC = MSEC * 1000LL;
693
694    /** android.request */
695
696    static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_NONE;
697    ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1);
698
699    static const int32_t id = 0;
700    ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1);
701
702    static const int32_t frameCount = 0;
703    ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1);
704
705    // OUTPUT_STREAMS set by user
706    entryCount += 1;
707    dataCount += 5; // TODO: Should be maximum stream number
708
709    /** android.lens */
710
711    static const float focusDistance = 0;
712    ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
713
714    ADD_OR_SIZE(ANDROID_LENS_APERTURE, &m_curCameraInfo->aperture, 1);
715
716    ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &m_curCameraInfo->focalLength, 1);
717
718    static const float filterDensity = 0;
719    ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1);
720
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);
725
726
727    /** android.sensor */
728
729    static const int64_t defaultExposureTime = 8000000LL; // 1/125 s
730    ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME, &defaultExposureTime, 1);
731
732    static const int64_t frameDuration = 33333333L; // 1/30 s
733    ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1);
734
735
736    /** android.flash */
737
738    static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF;
739    ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1);
740
741    static const uint8_t flashPower = 10;
742    ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1);
743
744    static const int64_t firingTime = 0;
745    ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1);
746
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;
757
758    switch (request_template) {
759      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
760        vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
761        // fall-through
762      case CAMERA2_TEMPLATE_STILL_CAPTURE:
763        // fall-through
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;
773        break;
774      case CAMERA2_TEMPLATE_VIDEO_RECORD:
775        vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
776        // fall-through
777      case CAMERA2_TEMPLATE_PREVIEW:
778        // fall-through
779      default:
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;
788        break;
789    }
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);
799
800    /** android.noise */
801    static const uint8_t noiseStrength = 5;
802    ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_STRENGTH, &noiseStrength, 1);
803
804    /** android.color */
805    static const float colorTransform[9] = {
806        1.0f, 0.f, 0.f,
807        0.f, 1.f, 0.f,
808        0.f, 0.f, 1.f
809    };
810    ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9);
811
812    /** android.tonemap */
813    static const float tonemapCurve[4] = {
814        0.f, 0.f,
815        1.f, 1.f
816    };
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);
820
821    /** android.edge */
822    static const uint8_t edgeStrength = 5;
823    ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1);
824
825    /** android.scaler */
826    int32_t cropRegion[3] = {
827        0, 0, m_curCameraInfo->sensorW
828    };
829    ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3);
830
831    /** android.jpeg */
832    static const int32_t jpegQuality = 100;
833    ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1);
834
835    static const int32_t thumbnailSize[2] = {
836        160, 120
837    };
838    ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2);
839
840    static const int32_t thumbnailQuality = 100;
841    ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1);
842
843    static const double gpsCoordinates[3] = {
844        0, 0, 0
845    };
846    ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 3);
847
848    static const uint8_t gpsProcessingMethod[32] = "None";
849    ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32);
850
851    static const int64_t gpsTimestamp = 0;
852    ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1);
853
854    static const int32_t jpegOrientation = 0;
855    ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1);
856
857    /** android.stats */
858
859    static const uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_FULL;
860    ADD_OR_SIZE(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1);
861
862    static const uint8_t histogramMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
863    ADD_OR_SIZE(ANDROID_STATISTICS_HISTOGRAM_MODE, &histogramMode, 1);
864
865    static const uint8_t sharpnessMapMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
866    ADD_OR_SIZE(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1);
867
868
869    /** android.control */
870
871    uint8_t controlIntent = 0;
872    switch (request_template) {
873      case CAMERA2_TEMPLATE_PREVIEW:
874        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
875        break;
876      case CAMERA2_TEMPLATE_STILL_CAPTURE:
877        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
878        break;
879      case CAMERA2_TEMPLATE_VIDEO_RECORD:
880        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
881        break;
882      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
883        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
884        break;
885      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
886        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
887        break;
888      default:
889        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
890        break;
891    }
892    ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
893
894    static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
895    ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1);
896
897    static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
898    ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
899
900    static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED;
901    ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
902
903    static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON;
904    ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
905
906    int32_t controlRegions[5] = {
907        0, 0, m_curCameraInfo->sensorW, m_curCameraInfo->sensorH, 1000
908    };
909    ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5);
910
911    static const int32_t aeExpCompensation = 0;
912    ADD_OR_SIZE(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1);
913
914    static const int32_t aeTargetFpsRange[2] = {
915        15, 30
916    };
917    ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2);
918
919    static const uint8_t aeAntibandingMode =
920            ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
921    ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1);
922
923    static const uint8_t awbMode =
924            ANDROID_CONTROL_AWB_MODE_AUTO;
925    ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
926
927    ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5);
928
929    uint8_t afMode = 0;
930    switch (request_template) {
931      case CAMERA2_TEMPLATE_PREVIEW:
932        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
933        break;
934      case CAMERA2_TEMPLATE_STILL_CAPTURE:
935        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
936        break;
937      case CAMERA2_TEMPLATE_VIDEO_RECORD:
938        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
939        break;
940      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
941        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
942        break;
943      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
944        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
945        break;
946      default:
947        afMode = ANDROID_CONTROL_AF_MODE_AUTO;
948        break;
949    }
950    ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1);
951
952    ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5);
953
954    if (sizeRequest) {
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);
963            return NO_MEMORY;
964        }
965    }
966    return OK;
967#undef ADD_OR_SIZE
968}
969
970}
971