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/Compat.h>
     23 #include <utils/Errors.h>
     24 #include <utils/KeyedVector.h>
     25 #include <utils/Mutex.h>
     26 #include <utils/String8.h>
     27 #include <utils/Vector.h>
     28 
     29 #include <camera/CameraParameters.h>
     30 #include <camera/CameraParameters2.h>
     31 #include <camera/CameraMetadata.h>
     32 
     33 namespace android {
     34 namespace camera2 {
     35 
     36 /**
     37  * Current camera state; this is the full state of the Camera under the old
     38  * camera API (contents of the CameraParameters2 object in a more-efficient
     39  * format, plus other state). The enum values are mostly based off the
     40  * corresponding camera2 enums, not the camera1 strings. A few are defined here
     41  * if they don't cleanly map to camera2 values.
     42  */
     43 struct Parameters {
     44     /**
     45      * Parameters and other state
     46      */
     47     int cameraId;
     48     int cameraFacing;
     49 
     50     int previewWidth, previewHeight;
     51     int32_t previewFpsRange[2];
     52     int previewFormat;
     53 
     54     int previewTransform; // set by CAMERA_CMD_SET_DISPLAY_ORIENTATION
     55 
     56     int pictureWidth, pictureHeight;
     57     // Store the picture size before they are overriden by video snapshot
     58     int pictureWidthLastSet, pictureHeightLastSet;
     59     bool pictureSizeOverriden;
     60 
     61     int32_t jpegThumbSize[2];
     62     uint8_t jpegQuality, jpegThumbQuality;
     63     int32_t jpegRotation;
     64 
     65     bool gpsEnabled;
     66     double gpsCoordinates[3];
     67     int64_t gpsTimestamp;
     68     String8 gpsProcessingMethod;
     69 
     70     uint8_t wbMode;
     71     uint8_t effectMode;
     72     uint8_t antibandingMode;
     73     uint8_t sceneMode;
     74 
     75     enum flashMode_t {
     76         FLASH_MODE_OFF = 0,
     77         FLASH_MODE_AUTO,
     78         FLASH_MODE_ON,
     79         FLASH_MODE_TORCH,
     80         FLASH_MODE_RED_EYE = ANDROID_CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE,
     81         FLASH_MODE_INVALID = -1
     82     } flashMode;
     83 
     84     enum focusMode_t {
     85         FOCUS_MODE_AUTO = ANDROID_CONTROL_AF_MODE_AUTO,
     86         FOCUS_MODE_MACRO = ANDROID_CONTROL_AF_MODE_MACRO,
     87         FOCUS_MODE_CONTINUOUS_VIDEO = ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO,
     88         FOCUS_MODE_CONTINUOUS_PICTURE = ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE,
     89         FOCUS_MODE_EDOF = ANDROID_CONTROL_AF_MODE_EDOF,
     90         FOCUS_MODE_INFINITY,
     91         FOCUS_MODE_FIXED,
     92         FOCUS_MODE_INVALID = -1
     93     } focusMode;
     94 
     95     uint8_t focusState; // Latest focus state from HAL
     96 
     97     // For use with triggerAfWithAuto quirk
     98     focusMode_t shadowFocusMode;
     99 
    100     struct Area {
    101         int left, top, right, bottom;
    102         int weight;
    103         Area() {}
    104         Area(int left, int top, int right, int bottom, int weight):
    105                 left(left), top(top), right(right), bottom(bottom),
    106                 weight(weight) {}
    107         bool isEmpty() const {
    108             return (left == 0) && (top == 0) && (right == 0) && (bottom == 0);
    109         }
    110     };
    111     Vector<Area> focusingAreas;
    112 
    113     struct Size {
    114         int32_t width;
    115         int32_t height;
    116     };
    117 
    118     struct FpsRange {
    119         int32_t low;
    120         int32_t high;
    121     };
    122 
    123     int32_t exposureCompensation;
    124     bool autoExposureLock;
    125     bool autoExposureLockAvailable;
    126     bool autoWhiteBalanceLock;
    127     bool autoWhiteBalanceLockAvailable;
    128 
    129     // 3A region types, for use with ANDROID_CONTROL_MAX_REGIONS
    130     enum region_t {
    131         REGION_AE = 0,
    132         REGION_AWB,
    133         REGION_AF,
    134         NUM_REGION // Number of region types
    135     } region;
    136 
    137     Vector<Area> meteringAreas;
    138 
    139     int zoom;
    140     bool zoomAvailable;
    141 
    142     int videoWidth, videoHeight, videoFormat;
    143     android_dataspace videoDataSpace;
    144 
    145     bool recordingHint;
    146     bool videoStabilization;
    147 
    148     CameraParameters2 params;
    149     String8 paramsFlattened;
    150 
    151     // These parameters are also part of the camera API-visible state, but not
    152     // directly listed in Camera.Parameters
    153     // One of ICamera::VIDEO_BUFFER_MODE_*
    154     int32_t videoBufferMode;
    155     bool playShutterSound;
    156     bool enableFaceDetect;
    157 
    158     bool enableFocusMoveMessages;
    159     int afTriggerCounter;
    160     int afStateCounter;
    161     int currentAfTriggerId;
    162     bool afInMotion;
    163 
    164     int precaptureTriggerCounter;
    165 
    166     int takePictureCounter;
    167 
    168     uint32_t previewCallbackFlags;
    169     bool previewCallbackOneShot;
    170     bool previewCallbackSurface;
    171 
    172     bool allowZslMode;
    173     // Whether the jpeg stream is slower than 30FPS and can slow down preview.
    174     // When slowJpegMode is true, allowZslMode must be false to avoid slowing down preview.
    175     bool slowJpegMode;
    176     // Whether ZSL reprocess is supported by the device.
    177     bool isZslReprocessPresent;
    178 
    179     // Overall camera state
    180     enum State {
    181         DISCONNECTED,
    182         STOPPED,
    183         WAITING_FOR_PREVIEW_WINDOW,
    184         PREVIEW,
    185         RECORD,
    186         STILL_CAPTURE,
    187         VIDEO_SNAPSHOT
    188     } state;
    189 
    190     // Number of zoom steps to simulate
    191     static const unsigned int NUM_ZOOM_STEPS = 100;
    192     // Max preview size allowed
    193     // This is set to a 1:1 value to allow for any aspect ratio that has
    194     // a max long side of 1920 pixels
    195     static const unsigned int MAX_PREVIEW_WIDTH = 1920;
    196     static const unsigned int MAX_PREVIEW_HEIGHT = 1920;
    197     // Initial max preview/recording size bound
    198     static const int MAX_INITIAL_PREVIEW_WIDTH = 1920;
    199     static const int MAX_INITIAL_PREVIEW_HEIGHT = 1080;
    200     // Aspect ratio tolerance
    201     static const CONSTEXPR float ASPECT_RATIO_TOLERANCE = 0.001;
    202     // Threshold for slow jpeg mode
    203     static const int64_t kSlowJpegModeThreshold = 33400000LL; // 33.4 ms
    204     // Margin for checking FPS
    205     static const int32_t FPS_MARGIN = 1;
    206     // Max FPS for default parameters
    207     static const int32_t MAX_DEFAULT_FPS = 30;
    208 
    209     // Full static camera info, object owned by someone else, such as
    210     // Camera2Device.
    211     const CameraMetadata *info;
    212 
    213     // Fast-access static device information; this is a subset of the
    214     // information available through the staticInfo() method, used for
    215     // frequently-accessed values or values that have to be calculated from the
    216     // static information.
    217     struct DeviceInfo {
    218         int32_t arrayWidth;
    219         int32_t arrayHeight;
    220         int32_t bestStillCaptureFpsRange[2];
    221         uint8_t bestFaceDetectMode;
    222         int32_t maxFaces;
    223         struct OverrideModes {
    224             flashMode_t flashMode;
    225             uint8_t     wbMode;
    226             focusMode_t focusMode;
    227             OverrideModes():
    228                     flashMode(FLASH_MODE_INVALID),
    229                     wbMode(ANDROID_CONTROL_AWB_MODE_OFF),
    230                     focusMode(FOCUS_MODE_INVALID) {
    231             }
    232         };
    233         DefaultKeyedVector<uint8_t, OverrideModes> sceneModeOverrides;
    234         float minFocalLength;
    235         bool useFlexibleYuv;
    236         Size maxJpegSize;
    237     } fastInfo;
    238 
    239     // Quirks information; these are short-lived flags to enable workarounds for
    240     // incomplete HAL implementations
    241     struct Quirks {
    242         bool triggerAfWithAuto;
    243         bool useZslFormat;
    244         bool meteringCropRegion;
    245         bool partialResults;
    246     } quirks;
    247 
    248     /**
    249      * Parameter manipulation and setup methods
    250      */
    251 
    252     Parameters(int cameraId, int cameraFacing);
    253     ~Parameters();
    254 
    255     // Sets up default parameters
    256     status_t initialize(const CameraMetadata *info, int deviceVersion);
    257 
    258     // Build fast-access device static info from static info
    259     status_t buildFastInfo();
    260     // Query for quirks from static info
    261     status_t buildQuirks();
    262 
    263     // Get entry from camera static characteristics information. min/maxCount
    264     // are used for error checking the number of values in the entry. 0 for
    265     // max/minCount means to do no bounds check in that direction. In case of
    266     // error, the entry data pointer is null and the count is 0.
    267     camera_metadata_ro_entry_t staticInfo(uint32_t tag,
    268             size_t minCount=0, size_t maxCount=0, bool required=true) const;
    269 
    270     // Validate and update camera parameters based on new settings
    271     status_t set(const String8 &paramString);
    272 
    273     // Retrieve the current settings
    274     String8 get() const;
    275 
    276     // Update passed-in request for common parameters
    277     status_t updateRequest(CameraMetadata *request) const;
    278 
    279     // Add/update JPEG entries in metadata
    280     status_t updateRequestJpeg(CameraMetadata *request) const;
    281 
    282     /* Helper functions to override jpeg size for video snapshot */
    283     // Override jpeg size by video size. Called during startRecording.
    284     status_t overrideJpegSizeByVideoSize();
    285     // Recover overridden jpeg size.  Called during stopRecording.
    286     status_t recoverOverriddenJpegSize();
    287     // if video snapshot size is currently overridden
    288     bool isJpegSizeOverridden();
    289     // whether zero shutter lag should be used for non-recording operation
    290     bool useZeroShutterLag() const;
    291 
    292     // Calculate the crop region rectangle, either tightly about the preview
    293     // resolution, or a region just based on the active array; both take
    294     // into account the current zoom level.
    295     struct CropRegion {
    296         float left;
    297         float top;
    298         float width;
    299         float height;
    300     };
    301     CropRegion calculateCropRegion(bool previewOnly) const;
    302 
    303     // Calculate the field of view of the high-resolution JPEG capture
    304     status_t calculatePictureFovs(float *horizFov, float *vertFov) const;
    305 
    306     // Static methods for debugging and converting between camera1 and camera2
    307     // parameters
    308 
    309     static const char *getStateName(State state);
    310 
    311     static int formatStringToEnum(const char *format);
    312     static const char *formatEnumToString(int format);
    313 
    314     static int wbModeStringToEnum(const char *wbMode);
    315     static const char* wbModeEnumToString(uint8_t wbMode);
    316     static int effectModeStringToEnum(const char *effectMode);
    317     static int abModeStringToEnum(const char *abMode);
    318     static int sceneModeStringToEnum(const char *sceneMode);
    319     static flashMode_t flashModeStringToEnum(const char *flashMode);
    320     static const char* flashModeEnumToString(flashMode_t flashMode);
    321     static focusMode_t focusModeStringToEnum(const char *focusMode);
    322     static const char* focusModeEnumToString(focusMode_t focusMode);
    323 
    324     static status_t parseAreas(const char *areasCStr,
    325             Vector<Area> *areas);
    326 
    327     enum AreaKind
    328     {
    329         AREA_KIND_FOCUS,
    330         AREA_KIND_METERING
    331     };
    332     status_t validateAreas(const Vector<Area> &areas,
    333                                   size_t maxRegions,
    334                                   AreaKind areaKind) const;
    335     static bool boolFromString(const char *boolStr);
    336 
    337     // Map from camera orientation + facing to gralloc transform enum
    338     static int degToTransform(int degrees, bool mirror);
    339 
    340     // API specifies FPS ranges are done in fixed point integer, with LSB = 0.001.
    341     // Note that this doesn't apply to the (deprecated) single FPS value.
    342     static const int kFpsToApiScale = 1000;
    343 
    344     // Transform from (-1000,-1000)-(1000,1000) normalized coords from camera
    345     // API to HAL3 (0,0)-(activePixelArray.width/height) coordinates
    346     int normalizedXToArray(int x) const;
    347     int normalizedYToArray(int y) const;
    348 
    349     // Transform from HAL3 (0,0)-(activePixelArray.width/height) coordinates to
    350     // (-1000,-1000)-(1000,1000) normalized coordinates given a scaler crop
    351     // region.
    352     int arrayXToNormalizedWithCrop(int x, const CropRegion &scalerCrop) const;
    353     int arrayYToNormalizedWithCrop(int y, const CropRegion &scalerCrop) const;
    354 
    355     struct Range {
    356         int min;
    357         int max;
    358     };
    359 
    360     int32_t fpsFromRange(int32_t min, int32_t max) const;
    361 
    362 private:
    363 
    364     // Convert from viewfinder crop-region relative array coordinates
    365     // to HAL3 sensor array coordinates
    366     int cropXToArray(int x) const;
    367     int cropYToArray(int y) const;
    368 
    369     // Convert from camera API (-1000,1000)-(1000,1000) normalized coords
    370     // to viewfinder crop-region relative array coordinates
    371     int normalizedXToCrop(int x) const;
    372     int normalizedYToCrop(int y) const;
    373 
    374     // Given a scaler crop region, calculate preview crop region based on
    375     // preview aspect ratio.
    376     CropRegion calculatePreviewCrop(const CropRegion &scalerCrop) const;
    377 
    378     Vector<Size> availablePreviewSizes;
    379     Vector<Size> availableVideoSizes;
    380     // Get size list (that are no larger than limit) from static metadata.
    381     status_t getFilteredSizes(Size limit, Vector<Size> *sizes);
    382     // Get max size (from the size array) that matches the given aspect ratio.
    383     Size getMaxSizeForRatio(float ratio, const int32_t* sizeArray, size_t count);
    384 
    385     // Helper function for overriding jpeg size for video snapshot
    386     // Check if overridden jpeg size needs to be updated after Parameters::set.
    387     // The behavior of this function is tailored to the implementation of Parameters::set.
    388     // Do not use this function for other purpose.
    389     status_t updateOverriddenJpegSize();
    390 
    391     struct StreamConfiguration {
    392         int32_t format;
    393         int32_t width;
    394         int32_t height;
    395         int32_t isInput;
    396     };
    397 
    398     // Helper function extract available stream configuration
    399     // Only valid since device HAL version 3.2
    400     // returns an empty Vector if device HAL version does support it
    401     Vector<StreamConfiguration> getStreamConfigurations();
    402 
    403     // Helper function to get minimum frame duration for a jpeg size
    404     // return -1 if input jpeg size cannot be found in supported size list
    405     int64_t getJpegStreamMinFrameDurationNs(Parameters::Size size);
    406 
    407     // Helper function to get minimum frame duration for a size/format combination
    408     // return -1 if input size/format combination cannot be found.
    409     int64_t getMinFrameDurationNs(Parameters::Size size, int format);
    410 
    411     // Helper function to check if a given fps is supported by all the sizes with
    412     // the same format.
    413     // return true if the device doesn't support min frame duration metadata tag.
    414     bool isFpsSupported(const Vector<Size> &size, int format, int32_t fps);
    415 
    416     // Helper function to get non-duplicated available output formats
    417     SortedVector<int32_t> getAvailableOutputFormats();
    418     // Helper function to get available output jpeg sizes
    419     Vector<Size> getAvailableJpegSizes();
    420     // Helper function to get maximum size in input Size vector.
    421     // The maximum size is defined by comparing width first, when width ties comparing height.
    422     Size getMaxSize(const Vector<Size>& sizes);
    423 
    424     int mDeviceVersion;
    425 };
    426 
    427 // This class encapsulates the Parameters class so that it can only be accessed
    428 // by constructing a Lock object, which locks the SharedParameter's mutex.
    429 class SharedParameters {
    430   public:
    431     SharedParameters(int cameraId, int cameraFacing):
    432             mParameters(cameraId, cameraFacing) {
    433     }
    434 
    435     template<typename S, typename P>
    436     class BaseLock {
    437       public:
    438         explicit BaseLock(S &p):
    439                 mParameters(p.mParameters),
    440                 mSharedParameters(p) {
    441             mSharedParameters.mLock.lock();
    442         }
    443 
    444         ~BaseLock() {
    445             mSharedParameters.mLock.unlock();
    446         }
    447         P &mParameters;
    448       private:
    449         // Disallow copying, default construction
    450         BaseLock();
    451         BaseLock(const BaseLock &);
    452         BaseLock &operator=(const BaseLock &);
    453         S &mSharedParameters;
    454     };
    455     typedef BaseLock<SharedParameters, Parameters> Lock;
    456     typedef BaseLock<const SharedParameters, const Parameters> ReadLock;
    457 
    458     // Access static info, read-only and immutable, so no lock needed
    459     camera_metadata_ro_entry_t staticInfo(uint32_t tag,
    460             size_t minCount=0, size_t maxCount=0) const {
    461         return mParameters.staticInfo(tag, minCount, maxCount);
    462     }
    463 
    464     // Only use for dumping or other debugging
    465     const Parameters &unsafeAccess() {
    466         return mParameters;
    467     }
    468   private:
    469     Parameters mParameters;
    470     mutable Mutex mLock;
    471 };
    472 
    473 
    474 }; // namespace camera2
    475 }; // namespace android
    476 
    477 #endif
    478