Home | History | Annotate | Download | only in camera2 
      1 /*
      2  * Copyright (C) 2012 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef ANDROID_SERVERS_CAMERA_CAMERA2PARAMETERS_H
     18 #define ANDROID_SERVERS_CAMERA_CAMERA2PARAMETERS_H
     19 
     20 #include <system/graphics.h>
     21 
     22 #include <utils/Errors.h>
     23 #include <utils/Mutex.h>
     24 #include <utils/String8.h>
     25 #include <utils/Vector.h>
     26 #include <utils/KeyedVector.h>
     27 #include <camera/CameraParameters.h>
     28 #include <camera/CameraMetadata.h>
     29 
     30 namespace android {
     31 namespace camera2 {
     32 
     33 /**
     34  * Current camera state; this is the full state of the Camera under the old
     35  * camera API (contents of the CameraParameters object in a more-efficient
     36  * format, plus other state). The enum values are mostly based off the
     37  * corresponding camera2 enums, not the camera1 strings. A few are defined here
     38  * if they don't cleanly map to camera2 values.
     39  */
     40 struct Parameters {
     41     /**
     42      * Parameters and other state
     43      */
     44     int cameraId;
     45     int cameraFacing;
     46 
     47     int previewWidth, previewHeight;
     48     int32_t previewFpsRange[2];
     49     int previewFps; // deprecated, here only for tracking changes
     50     int previewFormat;
     51 
     52     int previewTransform; // set by CAMERA_CMD_SET_DISPLAY_ORIENTATION
     53 
     54     int pictureWidth, pictureHeight;
     55 
     56     int32_t jpegThumbSize[2];
     57     uint8_t jpegQuality, jpegThumbQuality;
     58     int32_t jpegRotation;
     59 
     60     bool gpsEnabled;
     61     double gpsCoordinates[3];
     62     int64_t gpsTimestamp;
     63     String8 gpsProcessingMethod;
     64 
     65     uint8_t wbMode;
     66     uint8_t effectMode;
     67     uint8_t antibandingMode;
     68     uint8_t sceneMode;
     69 
     70     enum flashMode_t {
     71         FLASH_MODE_OFF = 0,
     72         FLASH_MODE_AUTO,
     73         FLASH_MODE_ON,
     74         FLASH_MODE_TORCH,
     75         FLASH_MODE_RED_EYE = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE,
     76         FLASH_MODE_INVALID = -1
     77     } flashMode;
     78 
     79     enum focusMode_t {
     80         FOCUS_MODE_AUTO = ANDROID_CONTROL_AF_MODE_AUTO,
     81         FOCUS_MODE_MACRO = ANDROID_CONTROL_AF_MODE_MACRO,
     82         FOCUS_MODE_CONTINUOUS_VIDEO = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO,
     83         FOCUS_MODE_CONTINUOUS_PICTURE = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
     84         FOCUS_MODE_EDOF = ANDROID_CONTROL_AF_MODE_EDOF,
     85         FOCUS_MODE_INFINITY,
     86         FOCUS_MODE_FIXED,
     87         FOCUS_MODE_INVALID = -1
     88     } focusMode;
     89 
     90     uint8_t focusState; // Latest focus state from HAL
     91 
     92     // For use with triggerAfWithAuto quirk
     93     focusMode_t shadowFocusMode;
     94 
     95     struct Area {
     96         int left, top, right, bottom;
     97         int weight;
     98         Area() {}
     99         Area(int left, int top, int right, int bottom, int weight):
    100                 left(left), top(top), right(right), bottom(bottom),
    101                 weight(weight) {}
    102         bool isEmpty() const {
    103             return (left == 0) && (top == 0) && (right == 0) && (bottom == 0);
    104         }
    105     };
    106     Vector<Area> focusingAreas;
    107 
    108     int32_t exposureCompensation;
    109     bool autoExposureLock;
    110     bool autoWhiteBalanceLock;
    111 
    112     Vector<Area> meteringAreas;
    113 
    114     int zoom;
    115 
    116     int videoWidth, videoHeight;
    117 
    118     bool recordingHint;
    119     bool videoStabilization;
    120 
    121     enum lightFxMode_t {
    122         LIGHTFX_NONE = 0,
    123         LIGHTFX_LOWLIGHT,
    124         LIGHTFX_HDR
    125     } lightFx;
    126 
    127     CameraParameters params;
    128     String8 paramsFlattened;
    129 
    130     // These parameters are also part of the camera API-visible state, but not
    131     // directly listed in Camera.Parameters
    132     bool storeMetadataInBuffers;
    133     bool playShutterSound;
    134     bool enableFaceDetect;
    135 
    136     bool enableFocusMoveMessages;
    137     int afTriggerCounter;
    138     int currentAfTriggerId;
    139     bool afInMotion;
    140 
    141     int precaptureTriggerCounter;
    142 
    143     uint32_t previewCallbackFlags;
    144     bool previewCallbackOneShot;
    145 
    146     bool zslMode;
    147 
    148     // Overall camera state
    149     enum State {
    150         DISCONNECTED,
    151         STOPPED,
    152         WAITING_FOR_PREVIEW_WINDOW,
    153         PREVIEW,
    154         RECORD,
    155         STILL_CAPTURE,
    156         VIDEO_SNAPSHOT
    157     } state;
    158 
    159     // Number of zoom steps to simulate
    160     static const unsigned int NUM_ZOOM_STEPS = 100;
    161 
    162     // Full static camera info, object owned by someone else, such as
    163     // Camera2Device.
    164     const CameraMetadata *info;
    165 
    166     // Fast-access static device information; this is a subset of the
    167     // information available through the staticInfo() method, used for
    168     // frequently-accessed values or values that have to be calculated from the
    169     // static information.
    170     struct DeviceInfo {
    171         int32_t arrayWidth;
    172         int32_t arrayHeight;
    173         uint8_t bestFaceDetectMode;
    174         int32_t maxFaces;
    175         struct OverrideModes {
    176             flashMode_t flashMode;
    177             uint8_t     wbMode;
    178             focusMode_t focusMode;
    179             OverrideModes():
    180                     flashMode(FLASH_MODE_INVALID),
    181                     wbMode(ANDROID_CONTROL_AWB_MODE_OFF),
    182                     focusMode(FOCUS_MODE_INVALID) {
    183             }
    184         };
    185         DefaultKeyedVector<uint8_t, OverrideModes> sceneModeOverrides;
    186         float minFocalLength;
    187         bool useFlexibleYuv;
    188     } fastInfo;
    189 
    190     // Quirks information; these are short-lived flags to enable workarounds for
    191     // incomplete HAL implementations
    192     struct Quirks {
    193         bool triggerAfWithAuto;
    194         bool useZslFormat;
    195         bool meteringCropRegion;
    196     } quirks;
    197 
    198     /**
    199      * Parameter manipulation and setup methods
    200      */
    201 
    202     Parameters(int cameraId, int cameraFacing);
    203     ~Parameters();
    204 
    205     // Sets up default parameters
    206     status_t initialize(const CameraMetadata *info);
    207 
    208     // Build fast-access device static info from static info
    209     status_t buildFastInfo();
    210     // Query for quirks from static info
    211     status_t buildQuirks();
    212 
    213     // Get entry from camera static characteristics information. min/maxCount
    214     // are used for error checking the number of values in the entry. 0 for
    215     // max/minCount means to do no bounds check in that direction. In case of
    216     // error, the entry data pointer is null and the count is 0.
    217     camera_metadata_ro_entry_t staticInfo(uint32_t tag,
    218             size_t minCount=0, size_t maxCount=0, bool required=true) const;
    219 
    220     // Validate and update camera parameters based on new settings
    221     status_t set(const String8 &paramString);
    222 
    223     // Retrieve the current settings
    224     String8 get() const;
    225 
    226     // Update passed-in request for common parameters
    227     status_t updateRequest(CameraMetadata *request) const;
    228 
    229     // Add/update JPEG entries in metadata
    230     status_t updateRequestJpeg(CameraMetadata *request) const;
    231 
    232     // Calculate the crop region rectangle based on current stream sizes
    233     struct CropRegion {
    234         float left;
    235         float top;
    236         float width;
    237         float height;
    238 
    239         enum Outputs {
    240             OUTPUT_PREVIEW         = 0x01,
    241             OUTPUT_VIDEO           = 0x02,
    242             OUTPUT_JPEG_THUMBNAIL  = 0x04,
    243             OUTPUT_PICTURE         = 0x08,
    244         };
    245     };
    246     CropRegion calculateCropRegion(CropRegion::Outputs outputs) const;
    247 
    248     // Calculate the field of view of the high-resolution JPEG capture
    249     status_t calculatePictureFovs(float *horizFov, float *vertFov) const;
    250 
    251     // Static methods for debugging and converting between camera1 and camera2
    252     // parameters
    253 
    254     static const char *getStateName(State state);
    255 
    256     static int formatStringToEnum(const char *format);
    257     static const char *formatEnumToString(int format);
    258 
    259     static int wbModeStringToEnum(const char *wbMode);
    260     static const char* wbModeEnumToString(uint8_t wbMode);
    261     static int effectModeStringToEnum(const char *effectMode);
    262     static int abModeStringToEnum(const char *abMode);
    263     static int sceneModeStringToEnum(const char *sceneMode);
    264     static flashMode_t flashModeStringToEnum(const char *flashMode);
    265     static const char* flashModeEnumToString(flashMode_t flashMode);
    266     static focusMode_t focusModeStringToEnum(const char *focusMode);
    267     static const char* focusModeEnumToString(focusMode_t focusMode);
    268     static lightFxMode_t lightFxStringToEnum(const char *lightFxMode);
    269 
    270     static status_t parseAreas(const char *areasCStr,
    271             Vector<Area> *areas);
    272 
    273     enum AreaKind
    274     {
    275         AREA_KIND_FOCUS,
    276         AREA_KIND_METERING
    277     };
    278     status_t validateAreas(const Vector<Area> &areas,
    279                                   size_t maxRegions,
    280                                   AreaKind areaKind) const;
    281     static bool boolFromString(const char *boolStr);
    282 
    283     // Map from camera orientation + facing to gralloc transform enum
    284     static int degToTransform(int degrees, bool mirror);
    285 
    286     // API specifies FPS ranges are done in fixed point integer, with LSB = 0.001.
    287     // Note that this doesn't apply to the (deprecated) single FPS value.
    288     static const int kFpsToApiScale = 1000;
    289 
    290     // Transform between (-1000,-1000)-(1000,1000) normalized coords from camera
    291     // API and HAL2 (0,0)-(activePixelArray.width/height) coordinates
    292     int arrayXToNormalized(int width) const;
    293     int arrayYToNormalized(int height) const;
    294     int normalizedXToArray(int x) const;
    295     int normalizedYToArray(int y) const;
    296 
    297     struct Range {
    298         int min;
    299         int max;
    300     };
    301 
    302     int32_t fpsFromRange(int32_t min, int32_t max) const;
    303 
    304 private:
    305 
    306     // Convert between HAL2 sensor array coordinates and
    307     // viewfinder crop-region relative array coordinates
    308     int cropXToArray(int x) const;
    309     int cropYToArray(int y) const;
    310     int arrayXToCrop(int x) const;
    311     int arrayYToCrop(int y) const;
    312 
    313     // Convert between viewfinder crop-region relative array coordinates
    314     // and camera API (-1000,1000)-(1000,1000) normalized coords
    315     int cropXToNormalized(int x) const;
    316     int cropYToNormalized(int y) const;
    317     int normalizedXToCrop(int x) const;
    318     int normalizedYToCrop(int y) const;
    319 };
    320 
    321 // This class encapsulates the Parameters class so that it can only be accessed
    322 // by constructing a Lock object, which locks the SharedParameter's mutex.
    323 class SharedParameters {
    324   public:
    325     SharedParameters(int cameraId, int cameraFacing):
    326             mParameters(cameraId, cameraFacing) {
    327     }
    328 
    329     template<typename S, typename P>
    330     class BaseLock {
    331       public:
    332         BaseLock(S &p):
    333                 mParameters(p.mParameters),
    334                 mSharedParameters(p) {
    335             mSharedParameters.mLock.lock();
    336         }
    337 
    338         ~BaseLock() {
    339             mSharedParameters.mLock.unlock();
    340         }
    341         P &mParameters;
    342       private:
    343         // Disallow copying, default construction
    344         BaseLock();
    345         BaseLock(const BaseLock &);
    346         BaseLock &operator=(const BaseLock &);
    347         S &mSharedParameters;
    348     };
    349     typedef BaseLock<SharedParameters, Parameters> Lock;
    350     typedef BaseLock<const SharedParameters, const Parameters> ReadLock;
    351 
    352     // Access static info, read-only and immutable, so no lock needed
    353     camera_metadata_ro_entry_t staticInfo(uint32_t tag,
    354             size_t minCount=0, size_t maxCount=0) const {
    355         return mParameters.staticInfo(tag, minCount, maxCount);
    356     }
    357 
    358     // Only use for dumping or other debugging
    359     const Parameters &unsafeAccess() {
    360         return mParameters;
    361     }
    362   private:
    363     Parameters mParameters;
    364     mutable Mutex mLock;
    365 };
    366 
    367 
    368 }; // namespace camera2
    369 }; // namespace android
    370 
    371 #endif
    372