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/CameraParameters2.h>
     29 #include <camera/CameraMetadata.h>
     30 
     31 namespace android {
     32 namespace camera2 {
     33 
     34 /**
     35  * Current camera state; this is the full state of the Camera under the old
     36  * camera API (contents of the CameraParameters2 object in a more-efficient
     37  * format, plus other state). The enum values are mostly based off the
     38  * corresponding camera2 enums, not the camera1 strings. A few are defined here
     39  * if they don't cleanly map to camera2 values.
     40  */
     41 struct Parameters {
     42     /**
     43      * Parameters and other state
     44      */
     45     int cameraId;
     46     int cameraFacing;
     47 
     48     int previewWidth, previewHeight;
     49     int32_t previewFpsRange[2];
     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     struct Size {
    109         int32_t width;
    110         int32_t height;
    111     };
    112 
    113     int32_t exposureCompensation;
    114     bool autoExposureLock;
    115     bool autoWhiteBalanceLock;
    116 
    117     Vector<Area> meteringAreas;
    118 
    119     int zoom;
    120 
    121     int videoWidth, videoHeight;
    122 
    123     bool recordingHint;
    124     bool videoStabilization;
    125 
    126     enum lightFxMode_t {
    127         LIGHTFX_NONE = 0,
    128         LIGHTFX_LOWLIGHT,
    129         LIGHTFX_HDR
    130     } lightFx;
    131 
    132     CameraParameters2 params;
    133     String8 paramsFlattened;
    134 
    135     // These parameters are also part of the camera API-visible state, but not
    136     // directly listed in Camera.Parameters
    137     bool storeMetadataInBuffers;
    138     bool playShutterSound;
    139     bool enableFaceDetect;
    140 
    141     bool enableFocusMoveMessages;
    142     int afTriggerCounter;
    143     int afStateCounter;
    144     int currentAfTriggerId;
    145     bool afInMotion;
    146 
    147     int precaptureTriggerCounter;
    148 
    149     int takePictureCounter;
    150 
    151     uint32_t previewCallbackFlags;
    152     bool previewCallbackOneShot;
    153     bool previewCallbackSurface;
    154 
    155     bool zslMode;
    156 
    157     // Overall camera state
    158     enum State {
    159         DISCONNECTED,
    160         STOPPED,
    161         WAITING_FOR_PREVIEW_WINDOW,
    162         PREVIEW,
    163         RECORD,
    164         STILL_CAPTURE,
    165         VIDEO_SNAPSHOT
    166     } state;
    167 
    168     // Number of zoom steps to simulate
    169     static const unsigned int NUM_ZOOM_STEPS = 100;
    170     // Max preview size allowed
    171     static const unsigned int MAX_PREVIEW_WIDTH = 1920;
    172     static const unsigned int MAX_PREVIEW_HEIGHT = 1080;
    173     // Aspect ratio tolerance
    174     static const float ASPECT_RATIO_TOLERANCE = 0.001;
    175 
    176     // Full static camera info, object owned by someone else, such as
    177     // Camera2Device.
    178     const CameraMetadata *info;
    179 
    180     // Fast-access static device information; this is a subset of the
    181     // information available through the staticInfo() method, used for
    182     // frequently-accessed values or values that have to be calculated from the
    183     // static information.
    184     struct DeviceInfo {
    185         int32_t arrayWidth;
    186         int32_t arrayHeight;
    187         int32_t bestStillCaptureFpsRange[2];
    188         uint8_t bestFaceDetectMode;
    189         int32_t maxFaces;
    190         struct OverrideModes {
    191             flashMode_t flashMode;
    192             uint8_t     wbMode;
    193             focusMode_t focusMode;
    194             OverrideModes():
    195                     flashMode(FLASH_MODE_INVALID),
    196                     wbMode(ANDROID_CONTROL_AWB_MODE_OFF),
    197                     focusMode(FOCUS_MODE_INVALID) {
    198             }
    199         };
    200         DefaultKeyedVector<uint8_t, OverrideModes> sceneModeOverrides;
    201         float minFocalLength;
    202         bool useFlexibleYuv;
    203     } fastInfo;
    204 
    205     // Quirks information; these are short-lived flags to enable workarounds for
    206     // incomplete HAL implementations
    207     struct Quirks {
    208         bool triggerAfWithAuto;
    209         bool useZslFormat;
    210         bool meteringCropRegion;
    211         bool partialResults;
    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