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
41int32_t SUPPORT_THUMBNAIL_REAR_SIZE[3][2] =
42{
43    {160, 120},
44    {160, 90},
45    {144, 96}
46};
47
48int32_t SUPPORT_THUMBNAIL_FRONT_SIZE[4][2] =
49{
50    {160, 120},
51    {160, 160},
52    {160, 90},
53    {144, 96}
54};
55
56class Sensor {
57public:
58    /**
59     * Static sensor characteristics
60     */
61    static const unsigned int kResolution[2][2];
62
63    static const nsecs_t kExposureTimeRange[2];
64    static const nsecs_t kFrameDurationRange[2];
65    static const nsecs_t kMinVerticalBlank;
66
67    static const uint8_t kColorFilterArrangement;
68
69    // Output image data characteristics
70    static const uint32_t kMaxRawValue;
71    static const uint32_t kBlackLevel;
72    // Sensor sensitivity, approximate
73
74    static const float kSaturationVoltage;
75    static const uint32_t kSaturationElectrons;
76    static const float kVoltsPerLuxSecond;
77    static const float kElectronsPerLuxSecond;
78
79    static const float kBaseGainFactor;
80
81    static const float kReadNoiseStddevBeforeGain; // In electrons
82    static const float kReadNoiseStddevAfterGain;  // In raw digital units
83    static const float kReadNoiseVarBeforeGain;
84    static const float kReadNoiseVarAfterGain;
85
86    // While each row has to read out, reset, and then expose, the (reset +
87    // expose) sequence can be overlapped by other row readouts, so the final
88    // minimum frame duration is purely a function of row readout time, at least
89    // if there's a reasonable number of rows.
90    static const nsecs_t kRowReadoutTime;
91
92    static const int32_t kSensitivityRange[2];
93    static const uint32_t kDefaultSensitivity;
94
95};
96
97
98
99const int32_t Sensor::kSensitivityRange[2] = {100, 1600};
100const nsecs_t Sensor::kExposureTimeRange[2] =
101    {1000L, 30000000000L} ; // 1 us - 30 sec
102const nsecs_t Sensor::kFrameDurationRange[2] =
103    {33331760L, 30000000000L}; // ~1/30 s - 30 sec
104
105const uint8_t Sensor::kColorFilterArrangement = ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB;
106
107const uint32_t kAvailableFormats[5] = {
108        HAL_PIXEL_FORMAT_RAW_SENSOR,
109        HAL_PIXEL_FORMAT_BLOB,
110        HAL_PIXEL_FORMAT_RGBA_8888,
111        HAL_PIXEL_FORMAT_YV12,
112        HAL_PIXEL_FORMAT_YCrCb_420_SP
113};
114
115// Output image data characteristics
116const uint32_t Sensor::kMaxRawValue = 4000;
117const uint32_t Sensor::kBlackLevel  = 1000;
118
119const uint64_t kAvailableRawMinDurations[1] = {
120    Sensor::kFrameDurationRange[0]
121};
122
123const uint64_t kAvailableProcessedMinDurations[1] = {
124    Sensor::kFrameDurationRange[0]
125};
126const uint64_t kAvailableJpegMinDurations[1] = {
127    Sensor::kFrameDurationRange[0]
128};
129
130const int32_t scalerResolutionS5K4E5[] =
131{
132    1920, 1080, // 16:9
133    1440, 1080, // 4:3
134    1440,  960, // 3:2
135    1280, 1024, // 5:4
136    1280,  720, // 16:9
137     960,  720, // 4:3
138     800,  480, // 5:3
139     768,  576, // 4:3
140     720,  576, // 5:4
141     720,  480, // 3:2
142     640,  480, // 4:3
143     352,  288, // 11:9
144     320,  240, // 4:3
145     240,  160, // 3:2
146     176,  144, // 6:5
147     128,   96, // 4:3
148};
149
150const int32_t jpegResolutionS5K4E5[] =
151{
152    2560, 1920,
153    2560, 1440,
154    2160, 1440,
155    2048, 1536,
156    1600, 1200,
157    1280, 1024,
158    1280,  960,
159    1152,  864,
160     640,  480,
161     320,  240,
162};
163
164const uint8_t availableAfModesS5K4E5[] =
165{
166    ANDROID_CONTROL_AF_MODE_OFF,
167    ANDROID_CONTROL_AF_MODE_AUTO,
168    ANDROID_CONTROL_AF_MODE_MACRO,
169    ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
170    ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO
171};
172
173const uint8_t sceneModeOverridesS5K4E5[] =
174{
175    // ANDROID_CONTROL_SCENE_MODE_ACTION
176    ANDROID_CONTROL_AE_MODE_ON,
177    ANDROID_CONTROL_AWB_MODE_AUTO,
178    ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
179    // ANDROID_CONTROL_SCENE_MODE_NIGHT
180    ANDROID_CONTROL_AE_MODE_ON,
181    ANDROID_CONTROL_AWB_MODE_AUTO,
182    ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
183    // ANDROID_CONTROL_SCENE_MODE_SUNSET
184    ANDROID_CONTROL_AE_MODE_ON,
185    ANDROID_CONTROL_AWB_MODE_DAYLIGHT,
186    ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
187    // ANDROID_CONTROL_SCENE_MODE_PARTY
188    ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH,
189    ANDROID_CONTROL_AWB_MODE_AUTO,
190    ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE
191};
192
193const uint8_t availableAeModesS5K4E5[] =
194{
195    ANDROID_CONTROL_AE_MODE_OFF,
196    ANDROID_CONTROL_AE_MODE_ON,
197    ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH
198};
199
200ExynosCamera2InfoS5K4E5::ExynosCamera2InfoS5K4E5()
201{
202    sensorW             = 2560;
203    sensorH             = 1920;
204    sensorRawW          = (2560 + 16);
205    sensorRawH          = (1920 + 10);
206    numScalerResolution = ARRAY_SIZE(scalerResolutionS5K4E5)/2;
207    scalerResolutions   = scalerResolutionS5K4E5;
208    numJpegResolution   = ARRAY_SIZE(jpegResolutionS5K4E5)/2;
209    jpegResolutions     = jpegResolutionS5K4E5;
210    minFocusDistance    = 0.1f;
211    focalLength         = 3.43f;
212    aperture            = 2.7f;
213    fnumber             = 2.7f;
214    availableAfModes    = availableAfModesS5K4E5;
215    numAvailableAfModes = ARRAY_SIZE(availableAfModesS5K4E5);
216    sceneModeOverrides  = sceneModeOverridesS5K4E5;
217    numSceneModeOverrides = ARRAY_SIZE(sceneModeOverridesS5K4E5);
218    availableAeModes    = availableAeModesS5K4E5;
219    numAvailableAeModes = ARRAY_SIZE(availableAeModesS5K4E5);
220}
221
222ExynosCamera2InfoS5K4E5::~ExynosCamera2InfoS5K4E5()
223{
224    ALOGV("%s", __FUNCTION__);
225}
226const int32_t scalerResolutionS5K6A3[] =
227{
228    1344,  896, // 3:2
229    1280, 1024, // 5:4
230    1024, 1024, // 1:1
231    1280,  960, // 4:3
232    1280,  720, // 16:9
233     960,  720, // 4:3
234     800,  480, // 5:3
235     768,  576, // 4:3
236     720,  576, // 5:4
237     720,  480, // 3:2
238     640,  480, // 4:3
239     352,  288, // 11:9
240     320,  240, // 4:3
241     240,  160, // 3:2
242     176,  144, // 6:5
243     128,   96, // 4:3
244};
245
246const int32_t jpegResolutionS5K6A3[] =
247{
248    1392, 1392,
249    1392, 1040,
250    1392,  928,
251    1392,  784,
252    1280, 1024,
253    1280,  960,
254    1280,  720,
255    1152,  864,
256     640,  480,
257     320,  240,
258};
259
260const uint8_t availableAfModesS5K6A3[] =
261{
262    ANDROID_CONTROL_AF_MODE_OFF
263};
264
265const uint8_t sceneModeOverridesS5K6A3[] =
266{
267    // ANDROID_CONTROL_SCENE_MODE_ACTION
268    ANDROID_CONTROL_AE_MODE_ON,
269    ANDROID_CONTROL_AWB_MODE_AUTO,
270    ANDROID_CONTROL_AF_MODE_OFF,
271    // ANDROID_CONTROL_SCENE_MODE_NIGHT
272    ANDROID_CONTROL_AE_MODE_ON,
273    ANDROID_CONTROL_AWB_MODE_AUTO,
274    ANDROID_CONTROL_AF_MODE_OFF,
275    // ANDROID_CONTROL_SCENE_MODE_SUNSET
276    ANDROID_CONTROL_AE_MODE_ON,
277    ANDROID_CONTROL_AWB_MODE_DAYLIGHT,
278    ANDROID_CONTROL_AF_MODE_OFF,
279    // ANDROID_CONTROL_SCENE_MODE_PARTY
280    ANDROID_CONTROL_AE_MODE_ON,
281    ANDROID_CONTROL_AWB_MODE_AUTO,
282    ANDROID_CONTROL_AF_MODE_OFF
283};
284
285const uint8_t availableAeModesS5K6A3[] =
286{
287    ANDROID_CONTROL_AE_MODE_OFF,
288    ANDROID_CONTROL_AE_MODE_ON
289};
290
291ExynosCamera2InfoS5K6A3::ExynosCamera2InfoS5K6A3()
292{
293    sensorW     = 1392;
294    sensorH     = 1392;
295    sensorRawW  = (1392 + 16);
296    sensorRawH  = (1392 + 10);
297    numScalerResolution = ARRAY_SIZE(scalerResolutionS5K6A3)/2;
298    scalerResolutions   = scalerResolutionS5K6A3;
299    numJpegResolution   = ARRAY_SIZE(jpegResolutionS5K6A3)/2;
300    jpegResolutions     = jpegResolutionS5K6A3;
301    minFocusDistance    = 0.0f;
302    focalLength         = 2.73f;
303    aperture            = 2.8f;
304    fnumber             = 2.8f;
305    availableAfModes    = availableAfModesS5K6A3;
306    numAvailableAfModes = ARRAY_SIZE(availableAfModesS5K6A3);
307    sceneModeOverrides  = sceneModeOverridesS5K6A3;
308    numSceneModeOverrides = ARRAY_SIZE(sceneModeOverridesS5K6A3);
309    availableAeModes    = availableAeModesS5K6A3;
310    numAvailableAeModes = ARRAY_SIZE(availableAeModesS5K6A3);
311}
312
313ExynosCamera2InfoS5K6A3::~ExynosCamera2InfoS5K6A3()
314{
315    ALOGV("%s", __FUNCTION__);
316}
317ExynosCamera2::ExynosCamera2(int cameraId):
318    m_cameraId(cameraId)
319{
320    if (cameraId == 0)
321        m_curCameraInfo      = new ExynosCamera2InfoS5K4E5;
322    else
323        m_curCameraInfo      = new ExynosCamera2InfoS5K6A3;
324}
325
326ExynosCamera2::~ExynosCamera2()
327{
328    ALOGV("%s", __FUNCTION__);
329	delete m_curCameraInfo;
330    m_curCameraInfo = NULL;
331}
332
333int32_t ExynosCamera2::getSensorW()
334{
335    return m_curCameraInfo->sensorW;
336}
337
338int32_t ExynosCamera2::getSensorH()
339{
340    return m_curCameraInfo->sensorH;
341}
342
343int32_t ExynosCamera2::getSensorRawW()
344{
345    return m_curCameraInfo->sensorRawW;
346}
347
348int32_t ExynosCamera2::getSensorRawH()
349{
350    return m_curCameraInfo->sensorRawH;
351}
352
353bool ExynosCamera2::isSupportedResolution(int width, int height)
354{
355    int i;
356    for (i = 0 ; i < m_curCameraInfo->numScalerResolution ; i++) {
357        if (m_curCameraInfo->scalerResolutions[2*i] == width
358                && m_curCameraInfo->scalerResolutions[2*i+1] == height) {
359            return true;
360        }
361    }
362    return false;
363}
364
365bool ExynosCamera2::isSupportedJpegResolution(int width, int height)
366{
367    int i;
368    for (i = 0 ; i < m_curCameraInfo->numJpegResolution ; i++) {
369        if (m_curCameraInfo->jpegResolutions[2*i] == width
370                && m_curCameraInfo->jpegResolutions[2*i+1] == height) {
371            return true;
372        }
373    }
374    return false;
375}
376
377status_t addOrSize(camera_metadata_t *request,
378        bool sizeRequest,
379        size_t *entryCount,
380        size_t *dataCount,
381        uint32_t tag,
382        const void *entryData,
383        size_t entryDataCount) {
384    status_t res;
385    if (!sizeRequest) {
386        return add_camera_metadata_entry(request, tag, entryData,
387                entryDataCount);
388    } else {
389        int type = get_camera_metadata_tag_type(tag);
390        if (type < 0 ) return BAD_VALUE;
391        (*entryCount)++;
392        (*dataCount) += calculate_camera_metadata_entry_data_size(type,
393                entryDataCount);
394        return OK;
395    }
396}
397
398status_t ExynosCamera2::constructStaticInfo(camera_metadata_t **info,
399        int cameraId, bool sizeRequest) {
400
401    size_t entryCount = 0;
402    size_t dataCount = 0;
403    status_t ret;
404
405#define ADD_OR_SIZE( tag, data, count ) \
406    if ( ( ret = addOrSize(*info, sizeRequest, &entryCount, &dataCount, \
407            tag, data, count) ) != OK ) return ret
408
409    // android.info
410
411    int32_t hardwareLevel = ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED;
412    ADD_OR_SIZE(ANDROID_INFO_SUPPORTED_HARDWARE_LEVEL,
413            &hardwareLevel, 1);
414
415    // android.lens
416
417    ADD_OR_SIZE(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE,
418            &(m_curCameraInfo->minFocusDistance), 1);
419    ADD_OR_SIZE(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE,
420            &(m_curCameraInfo->minFocusDistance), 1);
421
422    ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
423            &m_curCameraInfo->focalLength, 1);
424    ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_APERTURES,
425            &m_curCameraInfo->aperture, 1);
426
427    static const float filterDensity = 0;
428    ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
429            &filterDensity, 1);
430    static const uint8_t availableOpticalStabilization =
431            ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
432    ADD_OR_SIZE(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION,
433            &availableOpticalStabilization, 1);
434
435    static const int32_t lensShadingMapSize[] = {1, 1};
436    ADD_OR_SIZE(ANDROID_LENS_INFO_SHADING_MAP_SIZE, lensShadingMapSize,
437            sizeof(lensShadingMapSize)/sizeof(int32_t));
438
439    int32_t lensFacing = cameraId ?
440            ANDROID_LENS_FACING_FRONT : ANDROID_LENS_FACING_BACK;
441    ADD_OR_SIZE(ANDROID_LENS_FACING, &lensFacing, 1);
442
443    // android.request
444    static const int32_t maxNumOutputStreams[] = {1, 3, 1};
445    ADD_OR_SIZE(ANDROID_REQUEST_MAX_NUM_OUTPUT_STREAMS, maxNumOutputStreams,
446            sizeof(maxNumOutputStreams)/sizeof(int32_t));
447
448    // android.sensor
449    ADD_OR_SIZE(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE,
450            Sensor::kExposureTimeRange, 2);
451
452    ADD_OR_SIZE(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION,
453            &Sensor::kFrameDurationRange[1], 1);
454
455    ADD_OR_SIZE(ANDROID_SENSOR_INFO_SENSITIVITY_RANGE,
456            Sensor::kSensitivityRange,
457            sizeof(Sensor::kSensitivityRange)
458            /sizeof(int32_t));
459
460    ADD_OR_SIZE(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT,
461            &Sensor::kColorFilterArrangement, 1);
462
463    // Empirically derived to get correct FOV measurements
464    static const float sensorPhysicalSize[2] = {3.50f, 2.625f}; // mm
465    ADD_OR_SIZE(ANDROID_SENSOR_INFO_PHYSICAL_SIZE,
466            sensorPhysicalSize, 2);
467
468    int32_t pixelArraySize[2] = {
469        m_curCameraInfo->sensorW, m_curCameraInfo->sensorH
470    };
471    ADD_OR_SIZE(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, pixelArraySize, 2);
472
473    int32_t activeArraySize[4] = { 0, 0, pixelArraySize[0], pixelArraySize[1]};
474    ADD_OR_SIZE(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, activeArraySize,4);
475
476    ADD_OR_SIZE(ANDROID_SENSOR_INFO_WHITE_LEVEL,
477            &Sensor::kMaxRawValue, 1);
478
479    static const int32_t blackLevelPattern[4] = {
480            Sensor::kBlackLevel, Sensor::kBlackLevel,
481            Sensor::kBlackLevel, Sensor::kBlackLevel
482    };
483    ADD_OR_SIZE(ANDROID_SENSOR_BLACK_LEVEL_PATTERN,
484            blackLevelPattern, sizeof(blackLevelPattern)/sizeof(int32_t));
485
486    static const int32_t orientation[1] = {0};
487    ADD_OR_SIZE(ANDROID_SENSOR_ORIENTATION,
488            orientation, 1);
489
490    //TODO: sensor color calibration fields
491
492    // android.flash
493    uint8_t flashAvailable;
494    if (cameraId == 0)
495        flashAvailable = 1;
496    else
497        flashAvailable = 0;
498    ADD_OR_SIZE(ANDROID_FLASH_INFO_AVAILABLE, &flashAvailable, 1);
499
500    static const int64_t flashChargeDuration = 0;
501    ADD_OR_SIZE(ANDROID_FLASH_INFO_CHARGE_DURATION, &flashChargeDuration, 1);
502
503    // android.tonemap
504
505    static const int32_t tonemapCurvePoints = 128;
506    ADD_OR_SIZE(ANDROID_TONEMAP_MAX_CURVE_POINTS, &tonemapCurvePoints, 1);
507
508    // android.scaler
509
510    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_FORMATS,
511            kAvailableFormats,
512            sizeof(kAvailableFormats)/sizeof(uint32_t));
513
514    int32_t availableRawSizes[2] = {
515        m_curCameraInfo->sensorRawW, m_curCameraInfo->sensorRawH
516    };
517    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_SIZES,
518            availableRawSizes, 2);
519
520    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS,
521            kAvailableRawMinDurations,
522            sizeof(kAvailableRawMinDurations)/sizeof(uint64_t));
523
524
525    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES,
526        m_curCameraInfo->scalerResolutions,
527        (m_curCameraInfo->numScalerResolution)*2);
528    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_SIZES,
529        m_curCameraInfo->jpegResolutions,
530        (m_curCameraInfo->numJpegResolution)*2);
531
532    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_PROCESSED_MIN_DURATIONS,
533            kAvailableProcessedMinDurations,
534            sizeof(kAvailableProcessedMinDurations)/sizeof(uint64_t));
535
536    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS,
537            kAvailableJpegMinDurations,
538            sizeof(kAvailableJpegMinDurations)/sizeof(uint64_t));
539
540    static const float maxZoom = 4;
541    ADD_OR_SIZE(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, &maxZoom, 1);
542
543    // android.jpeg
544
545    size_t sizeOfThumbnailList = (cameraId) ? sizeof(SUPPORT_THUMBNAIL_FRONT_SIZE) /
546            sizeof(int32_t) : sizeof(SUPPORT_THUMBNAIL_REAR_SIZE) / sizeof(int32_t);
547
548    // Copy sizes from front or back camera
549    int32_t jpegThumbnailSizes[sizeOfThumbnailList + 2];
550
551    if (cameraId) {
552        memcpy(jpegThumbnailSizes, SUPPORT_THUMBNAIL_FRONT_SIZE,
553                sizeof(int32_t) * sizeOfThumbnailList);
554    } else {
555        memcpy(jpegThumbnailSizes, SUPPORT_THUMBNAIL_REAR_SIZE,
556                sizeof(int32_t) * sizeOfThumbnailList);
557    }
558
559    // Always include 0,0 size in list
560    jpegThumbnailSizes[sizeOfThumbnailList] = 0;
561    jpegThumbnailSizes[sizeOfThumbnailList + 1] = 0;
562
563    ADD_OR_SIZE(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
564            jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t));
565
566    static const int32_t jpegMaxSize = 10 * 1024 * 1024;
567    ADD_OR_SIZE(ANDROID_JPEG_MAX_SIZE, &jpegMaxSize, 1);
568
569    // android.stats
570
571    static const uint8_t availableFaceDetectModes[] = {
572            ANDROID_STATISTICS_FACE_DETECT_MODE_OFF,
573            ANDROID_STATISTICS_FACE_DETECT_MODE_FULL
574    };
575    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES,
576            availableFaceDetectModes,
577            sizeof(availableFaceDetectModes));
578
579    m_curCameraInfo->maxFaceCount = CAMERA2_MAX_FACES;
580    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT,
581            &(m_curCameraInfo->maxFaceCount), 1);
582
583    static const int32_t histogramSize = 64;
584    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT,
585            &histogramSize, 1);
586
587    static const int32_t maxHistogramCount = 1000;
588    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT,
589            &maxHistogramCount, 1);
590
591    static const int32_t sharpnessMapSize[2] = {64, 64};
592    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE,
593            sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t));
594
595    static const int32_t maxSharpnessMapValue = 1000;
596    ADD_OR_SIZE(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE,
597            &maxSharpnessMapValue, 1);
598
599    // android.control
600
601    static const uint8_t availableSceneModes[] = {
602            ANDROID_CONTROL_SCENE_MODE_ACTION,
603            ANDROID_CONTROL_SCENE_MODE_NIGHT,
604            ANDROID_CONTROL_SCENE_MODE_SUNSET,
605            ANDROID_CONTROL_SCENE_MODE_PARTY
606    };
607    ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
608            availableSceneModes, sizeof(availableSceneModes));
609
610    static const uint8_t availableEffects[] = {
611            ANDROID_CONTROL_EFFECT_MODE_OFF
612    };
613    ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_EFFECTS,
614            availableEffects, sizeof(availableEffects));
615
616    static const int32_t max3aRegions[] = {/*AE*/ 1,/*AWB*/ 1,/*AF*/ 1};
617    ADD_OR_SIZE(ANDROID_CONTROL_MAX_REGIONS,
618            max3aRegions, sizeof(max3aRegions)/sizeof(max3aRegions[0]));
619
620    ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_MODES,
621            m_curCameraInfo->availableAeModes, m_curCameraInfo->numAvailableAeModes);
622
623    static const camera_metadata_rational exposureCompensationStep = {
624            1, 1
625    };
626    ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_STEP,
627            &exposureCompensationStep, 1);
628
629    int32_t exposureCompensationRange[] = {-3, 3};
630    ADD_OR_SIZE(ANDROID_CONTROL_AE_COMPENSATION_RANGE,
631            exposureCompensationRange,
632            sizeof(exposureCompensationRange)/sizeof(int32_t));
633
634    static const int32_t availableTargetFpsRanges[] = {
635            15, 15, 24, 24, 25, 25, 15, 30, 30, 30
636    };
637    ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES,
638            availableTargetFpsRanges,
639            sizeof(availableTargetFpsRanges)/sizeof(int32_t));
640
641    static const uint8_t availableAntibandingModes[] = {
642            ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF,
643            ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO
644    };
645    ADD_OR_SIZE(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES,
646            availableAntibandingModes, sizeof(availableAntibandingModes));
647
648    static const uint8_t availableAwbModes[] = {
649            ANDROID_CONTROL_AWB_MODE_OFF,
650            ANDROID_CONTROL_AWB_MODE_AUTO,
651            ANDROID_CONTROL_AWB_MODE_INCANDESCENT,
652            ANDROID_CONTROL_AWB_MODE_FLUORESCENT,
653            ANDROID_CONTROL_AWB_MODE_DAYLIGHT,
654            ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT
655    };
656    ADD_OR_SIZE(ANDROID_CONTROL_AWB_AVAILABLE_MODES,
657            availableAwbModes, sizeof(availableAwbModes));
658
659    ADD_OR_SIZE(ANDROID_CONTROL_AF_AVAILABLE_MODES,
660                m_curCameraInfo->availableAfModes, m_curCameraInfo->numAvailableAfModes);
661
662    static const uint8_t availableVstabModes[] = {
663            ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF,
664            ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON
665    };
666    ADD_OR_SIZE(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES,
667            availableVstabModes, sizeof(availableVstabModes));
668
669    ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE_OVERRIDES,
670            m_curCameraInfo->sceneModeOverrides, m_curCameraInfo->numSceneModeOverrides);
671
672    static const uint8_t quirkTriggerAuto = 1;
673    ADD_OR_SIZE(ANDROID_QUIRKS_TRIGGER_AF_WITH_AUTO,
674            &quirkTriggerAuto, 1);
675
676    static const uint8_t quirkUseZslFormat = 1;
677    ADD_OR_SIZE(ANDROID_QUIRKS_USE_ZSL_FORMAT,
678            &quirkUseZslFormat, 1);
679
680    static const uint8_t quirkMeteringCropRegion = 1;
681    ADD_OR_SIZE(ANDROID_QUIRKS_METERING_CROP_REGION,
682            &quirkMeteringCropRegion, 1);
683
684
685#undef ADD_OR_SIZE
686    /** Allocate metadata if sizing */
687    if (sizeRequest) {
688        ALOGV("Allocating %d entries, %d extra bytes for "
689                "static camera info",
690                entryCount, dataCount);
691        *info = allocate_camera_metadata(entryCount, dataCount);
692        if (*info == NULL) {
693            ALOGE("Unable to allocate camera static info"
694                    "(%d entries, %d bytes extra data)",
695                    entryCount, dataCount);
696            return NO_MEMORY;
697        }
698    }
699    return OK;
700}
701
702status_t ExynosCamera2::constructDefaultRequest(
703        int request_template,
704        camera_metadata_t **request,
705        bool sizeRequest) {
706
707    size_t entryCount = 0;
708    size_t dataCount = 0;
709    status_t ret;
710
711#define ADD_OR_SIZE( tag, data, count ) \
712    if ( ( ret = addOrSize(*request, sizeRequest, &entryCount, &dataCount, \
713            tag, data, count) ) != OK ) return ret
714
715    static const int64_t USEC = 1000LL;
716    static const int64_t MSEC = USEC * 1000LL;
717    static const int64_t SEC = MSEC * 1000LL;
718
719    /** android.request */
720
721    static const uint8_t metadataMode = ANDROID_REQUEST_METADATA_MODE_NONE;
722    ADD_OR_SIZE(ANDROID_REQUEST_METADATA_MODE, &metadataMode, 1);
723
724    static const int32_t id = 0;
725    ADD_OR_SIZE(ANDROID_REQUEST_ID, &id, 1);
726
727    static const int32_t frameCount = 0;
728    ADD_OR_SIZE(ANDROID_REQUEST_FRAME_COUNT, &frameCount, 1);
729
730    // OUTPUT_STREAMS set by user
731    entryCount += 1;
732    dataCount += 5; // TODO: Should be maximum stream number
733
734    /** android.lens */
735
736    static const float focusDistance = 0;
737    ADD_OR_SIZE(ANDROID_LENS_FOCUS_DISTANCE, &focusDistance, 1);
738
739    ADD_OR_SIZE(ANDROID_LENS_APERTURE, &m_curCameraInfo->aperture, 1);
740
741    ADD_OR_SIZE(ANDROID_LENS_FOCAL_LENGTH, &m_curCameraInfo->focalLength, 1);
742
743    static const float filterDensity = 0;
744    ADD_OR_SIZE(ANDROID_LENS_FILTER_DENSITY, &filterDensity, 1);
745
746    static const uint8_t opticalStabilizationMode =
747            ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF;
748    ADD_OR_SIZE(ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
749            &opticalStabilizationMode, 1);
750
751
752    /** android.sensor */
753
754    static const int64_t defaultExposureTime = 8000000LL; // 1/125 s
755    ADD_OR_SIZE(ANDROID_SENSOR_EXPOSURE_TIME, &defaultExposureTime, 1);
756
757    static const int64_t frameDuration = 33333333L; // 1/30 s
758    ADD_OR_SIZE(ANDROID_SENSOR_FRAME_DURATION, &frameDuration, 1);
759
760
761    /** android.flash */
762
763    static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF;
764    ADD_OR_SIZE(ANDROID_FLASH_MODE, &flashMode, 1);
765
766    static const uint8_t flashPower = 10;
767    ADD_OR_SIZE(ANDROID_FLASH_FIRING_POWER, &flashPower, 1);
768
769    static const int64_t firingTime = 0;
770    ADD_OR_SIZE(ANDROID_FLASH_FIRING_TIME, &firingTime, 1);
771
772    /** Processing block modes */
773    uint8_t hotPixelMode = 0;
774    uint8_t demosaicMode = 0;
775    uint8_t noiseMode = 0;
776    uint8_t shadingMode = 0;
777    uint8_t colorMode = 0;
778    uint8_t tonemapMode = 0;
779    uint8_t edgeMode = 0;
780    uint8_t vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF;
781
782    switch (request_template) {
783      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
784        vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
785        // fall-through
786      case CAMERA2_TEMPLATE_STILL_CAPTURE:
787        // fall-through
788      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
789        hotPixelMode = ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY;
790        demosaicMode = ANDROID_DEMOSAIC_MODE_HIGH_QUALITY;
791        noiseMode = ANDROID_NOISE_REDUCTION_MODE_HIGH_QUALITY;
792        shadingMode = ANDROID_SHADING_MODE_HIGH_QUALITY;
793        colorMode = ANDROID_COLOR_CORRECTION_MODE_HIGH_QUALITY;
794        tonemapMode = ANDROID_TONEMAP_MODE_HIGH_QUALITY;
795        edgeMode = ANDROID_EDGE_MODE_HIGH_QUALITY;
796        break;
797      case CAMERA2_TEMPLATE_VIDEO_RECORD:
798        vstabMode = ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_ON;
799        // fall-through
800      case CAMERA2_TEMPLATE_PREVIEW:
801        // fall-through
802      default:
803        hotPixelMode = ANDROID_HOT_PIXEL_MODE_FAST;
804        demosaicMode = ANDROID_DEMOSAIC_MODE_FAST;
805        noiseMode = ANDROID_NOISE_REDUCTION_MODE_FAST;
806        shadingMode = ANDROID_SHADING_MODE_FAST;
807        colorMode = ANDROID_COLOR_CORRECTION_MODE_FAST;
808        tonemapMode = ANDROID_TONEMAP_MODE_FAST;
809        edgeMode = ANDROID_EDGE_MODE_FAST;
810        break;
811    }
812    ADD_OR_SIZE(ANDROID_HOT_PIXEL_MODE, &hotPixelMode, 1);
813    ADD_OR_SIZE(ANDROID_DEMOSAIC_MODE, &demosaicMode, 1);
814    ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_MODE, &noiseMode, 1);
815    ADD_OR_SIZE(ANDROID_SHADING_MODE, &shadingMode, 1);
816    ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_MODE, &colorMode, 1);
817    ADD_OR_SIZE(ANDROID_TONEMAP_MODE, &tonemapMode, 1);
818    ADD_OR_SIZE(ANDROID_EDGE_MODE, &edgeMode, 1);
819    ADD_OR_SIZE(ANDROID_CONTROL_VIDEO_STABILIZATION_MODE, &vstabMode, 1);
820
821    /** android.noise */
822    static const uint8_t noiseStrength = 5;
823    ADD_OR_SIZE(ANDROID_NOISE_REDUCTION_STRENGTH, &noiseStrength, 1);
824
825    /** android.color */
826    static const float colorTransform[9] = {
827        1.0f, 0.f, 0.f,
828        0.f, 1.f, 0.f,
829        0.f, 0.f, 1.f
830    };
831    ADD_OR_SIZE(ANDROID_COLOR_CORRECTION_TRANSFORM, colorTransform, 9);
832
833    /** android.tonemap */
834    static const float tonemapCurve[4] = {
835        0.f, 0.f,
836        1.f, 1.f
837    };
838    ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_RED, tonemapCurve, 32); // sungjoong
839    ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_GREEN, tonemapCurve, 32);
840    ADD_OR_SIZE(ANDROID_TONEMAP_CURVE_BLUE, tonemapCurve, 32);
841
842    /** android.edge */
843    static const uint8_t edgeStrength = 5;
844    ADD_OR_SIZE(ANDROID_EDGE_STRENGTH, &edgeStrength, 1);
845
846    /** android.scaler */
847    int32_t cropRegion[3] = {
848        0, 0, m_curCameraInfo->sensorW
849    };
850    ADD_OR_SIZE(ANDROID_SCALER_CROP_REGION, cropRegion, 3);
851
852    /** android.jpeg */
853    static const int32_t jpegQuality = 100;
854    ADD_OR_SIZE(ANDROID_JPEG_QUALITY, &jpegQuality, 1);
855
856    static const int32_t thumbnailSize[2] = {
857        160, 120
858    };
859    ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_SIZE, thumbnailSize, 2);
860
861    static const int32_t thumbnailQuality = 100;
862    ADD_OR_SIZE(ANDROID_JPEG_THUMBNAIL_QUALITY, &thumbnailQuality, 1);
863
864    static const double gpsCoordinates[3] = {
865        0, 0, 0
866    };
867    ADD_OR_SIZE(ANDROID_JPEG_GPS_COORDINATES, gpsCoordinates, 3);
868
869    static const uint8_t gpsProcessingMethod[32] = "None";
870    ADD_OR_SIZE(ANDROID_JPEG_GPS_PROCESSING_METHOD, gpsProcessingMethod, 32);
871
872    static const int64_t gpsTimestamp = 0;
873    ADD_OR_SIZE(ANDROID_JPEG_GPS_TIMESTAMP, &gpsTimestamp, 1);
874
875    static const int32_t jpegOrientation = 0;
876    ADD_OR_SIZE(ANDROID_JPEG_ORIENTATION, &jpegOrientation, 1);
877
878    /** android.stats */
879
880    static const uint8_t faceDetectMode = ANDROID_STATISTICS_FACE_DETECT_MODE_FULL;
881    ADD_OR_SIZE(ANDROID_STATISTICS_FACE_DETECT_MODE, &faceDetectMode, 1);
882
883    static const uint8_t histogramMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
884    ADD_OR_SIZE(ANDROID_STATISTICS_HISTOGRAM_MODE, &histogramMode, 1);
885
886    static const uint8_t sharpnessMapMode = ANDROID_STATISTICS_HISTOGRAM_MODE_OFF;
887    ADD_OR_SIZE(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, &sharpnessMapMode, 1);
888
889
890    /** android.control */
891
892    uint8_t controlIntent = 0;
893    switch (request_template) {
894      case CAMERA2_TEMPLATE_PREVIEW:
895        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW;
896        break;
897      case CAMERA2_TEMPLATE_STILL_CAPTURE:
898        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE;
899        break;
900      case CAMERA2_TEMPLATE_VIDEO_RECORD:
901        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD;
902        break;
903      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
904        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT;
905        break;
906      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
907        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG;
908        break;
909      default:
910        controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM;
911        break;
912    }
913    ADD_OR_SIZE(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1);
914
915    static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO;
916    ADD_OR_SIZE(ANDROID_CONTROL_MODE, &controlMode, 1);
917
918    static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF;
919    ADD_OR_SIZE(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1);
920
921    static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_DISABLED;
922    ADD_OR_SIZE(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1);
923
924    static const uint8_t aeMode = ANDROID_CONTROL_AE_MODE_ON;
925    ADD_OR_SIZE(ANDROID_CONTROL_AE_MODE, &aeMode, 1);
926
927    int32_t controlRegions[5] = {
928        0, 0, m_curCameraInfo->sensorW, m_curCameraInfo->sensorH, 1000
929    };
930    ADD_OR_SIZE(ANDROID_CONTROL_AE_REGIONS, controlRegions, 5);
931
932    static const int32_t aeExpCompensation = 0;
933    ADD_OR_SIZE(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExpCompensation, 1);
934
935    static const int32_t aeTargetFpsRange[2] = {
936        15, 30
937    };
938    ADD_OR_SIZE(ANDROID_CONTROL_AE_TARGET_FPS_RANGE, aeTargetFpsRange, 2);
939
940    static const uint8_t aeAntibandingMode =
941            ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO;
942    ADD_OR_SIZE(ANDROID_CONTROL_AE_ANTIBANDING_MODE, &aeAntibandingMode, 1);
943
944    static const uint8_t awbMode =
945            ANDROID_CONTROL_AWB_MODE_AUTO;
946    ADD_OR_SIZE(ANDROID_CONTROL_AWB_MODE, &awbMode, 1);
947
948    ADD_OR_SIZE(ANDROID_CONTROL_AWB_REGIONS, controlRegions, 5);
949
950    uint8_t afMode = 0;
951    switch (request_template) {
952      case CAMERA2_TEMPLATE_PREVIEW:
953        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
954        break;
955      case CAMERA2_TEMPLATE_STILL_CAPTURE:
956        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
957        break;
958      case CAMERA2_TEMPLATE_VIDEO_RECORD:
959        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
960        break;
961      case CAMERA2_TEMPLATE_VIDEO_SNAPSHOT:
962        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO;
963        break;
964      case CAMERA2_TEMPLATE_ZERO_SHUTTER_LAG:
965        afMode = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE;
966        break;
967      default:
968        afMode = ANDROID_CONTROL_AF_MODE_AUTO;
969        break;
970    }
971    ADD_OR_SIZE(ANDROID_CONTROL_AF_MODE, &afMode, 1);
972
973    ADD_OR_SIZE(ANDROID_CONTROL_AF_REGIONS, controlRegions, 5);
974
975    if (sizeRequest) {
976        ALOGV("Allocating %d entries, %d extra bytes for "
977                "request template type %d",
978                entryCount, dataCount, request_template);
979        *request = allocate_camera_metadata(entryCount, dataCount);
980        if (*request == NULL) {
981            ALOGE("Unable to allocate new request template type %d "
982                    "(%d entries, %d bytes extra data)", request_template,
983                    entryCount, dataCount);
984            return NO_MEMORY;
985        }
986    }
987    return OK;
988#undef ADD_OR_SIZE
989}
990
991}
992