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