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
33namespace android {
34namespace 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 */
43struct 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    int32_t exposureCompensation;
119    bool autoExposureLock;
120    bool autoWhiteBalanceLock;
121
122    // 3A region types, for use with ANDROID_CONTROL_MAX_REGIONS
123    enum region_t {
124        REGION_AE = 0,
125        REGION_AWB,
126        REGION_AF,
127        NUM_REGION // Number of region types
128    } region;
129
130    Vector<Area> meteringAreas;
131
132    int zoom;
133
134    int videoWidth, videoHeight, videoFormat;
135    android_dataspace videoDataSpace;
136
137    bool recordingHint;
138    bool videoStabilization;
139
140    CameraParameters2 params;
141    String8 paramsFlattened;
142
143    // These parameters are also part of the camera API-visible state, but not
144    // directly listed in Camera.Parameters
145    // One of ICamera::VIDEO_BUFFER_MODE_*
146    int32_t videoBufferMode;
147    bool playShutterSound;
148    bool enableFaceDetect;
149
150    bool enableFocusMoveMessages;
151    int afTriggerCounter;
152    int afStateCounter;
153    int currentAfTriggerId;
154    bool afInMotion;
155
156    int precaptureTriggerCounter;
157
158    int takePictureCounter;
159
160    uint32_t previewCallbackFlags;
161    bool previewCallbackOneShot;
162    bool previewCallbackSurface;
163
164    bool zslMode;
165    // Whether the jpeg stream is slower than 30FPS and can slow down preview.
166    // When slowJpegMode is true, zslMode must be false to avoid slowing down preview.
167    bool slowJpegMode;
168
169    // Overall camera state
170    enum State {
171        DISCONNECTED,
172        STOPPED,
173        WAITING_FOR_PREVIEW_WINDOW,
174        PREVIEW,
175        RECORD,
176        STILL_CAPTURE,
177        VIDEO_SNAPSHOT
178    } state;
179
180    // Number of zoom steps to simulate
181    static const unsigned int NUM_ZOOM_STEPS = 100;
182    // Max preview size allowed
183    // This is set to a 1:1 value to allow for any aspect ratio that has
184    // a max long side of 1920 pixels
185    static const unsigned int MAX_PREVIEW_WIDTH = 1920;
186    static const unsigned int MAX_PREVIEW_HEIGHT = 1920;
187    // Initial max preview/recording size bound
188    static const int MAX_INITIAL_PREVIEW_WIDTH = 1920;
189    static const int MAX_INITIAL_PREVIEW_HEIGHT = 1080;
190    // Aspect ratio tolerance
191    static const CONSTEXPR float ASPECT_RATIO_TOLERANCE = 0.001;
192    // Threshold for slow jpeg mode
193    static const int64_t kSlowJpegModeThreshold = 33400000LL; // 33.4 ms
194
195    // Full static camera info, object owned by someone else, such as
196    // Camera2Device.
197    const CameraMetadata *info;
198
199    // Fast-access static device information; this is a subset of the
200    // information available through the staticInfo() method, used for
201    // frequently-accessed values or values that have to be calculated from the
202    // static information.
203    struct DeviceInfo {
204        int32_t arrayWidth;
205        int32_t arrayHeight;
206        int32_t bestStillCaptureFpsRange[2];
207        uint8_t bestFaceDetectMode;
208        int32_t maxFaces;
209        struct OverrideModes {
210            flashMode_t flashMode;
211            uint8_t     wbMode;
212            focusMode_t focusMode;
213            OverrideModes():
214                    flashMode(FLASH_MODE_INVALID),
215                    wbMode(ANDROID_CONTROL_AWB_MODE_OFF),
216                    focusMode(FOCUS_MODE_INVALID) {
217            }
218        };
219        DefaultKeyedVector<uint8_t, OverrideModes> sceneModeOverrides;
220        float minFocalLength;
221        bool useFlexibleYuv;
222    } fastInfo;
223
224    // Quirks information; these are short-lived flags to enable workarounds for
225    // incomplete HAL implementations
226    struct Quirks {
227        bool triggerAfWithAuto;
228        bool useZslFormat;
229        bool meteringCropRegion;
230        bool partialResults;
231    } quirks;
232
233    /**
234     * Parameter manipulation and setup methods
235     */
236
237    Parameters(int cameraId, int cameraFacing);
238    ~Parameters();
239
240    // Sets up default parameters
241    status_t initialize(const CameraMetadata *info, int deviceVersion);
242
243    // Build fast-access device static info from static info
244    status_t buildFastInfo();
245    // Query for quirks from static info
246    status_t buildQuirks();
247
248    // Get entry from camera static characteristics information. min/maxCount
249    // are used for error checking the number of values in the entry. 0 for
250    // max/minCount means to do no bounds check in that direction. In case of
251    // error, the entry data pointer is null and the count is 0.
252    camera_metadata_ro_entry_t staticInfo(uint32_t tag,
253            size_t minCount=0, size_t maxCount=0, bool required=true) const;
254
255    // Validate and update camera parameters based on new settings
256    status_t set(const String8 &paramString);
257
258    // Retrieve the current settings
259    String8 get() const;
260
261    // Update passed-in request for common parameters
262    status_t updateRequest(CameraMetadata *request) const;
263
264    // Add/update JPEG entries in metadata
265    status_t updateRequestJpeg(CameraMetadata *request) const;
266
267    /* Helper functions to override jpeg size for video snapshot */
268    // Override jpeg size by video size. Called during startRecording.
269    status_t overrideJpegSizeByVideoSize();
270    // Recover overridden jpeg size.  Called during stopRecording.
271    status_t recoverOverriddenJpegSize();
272    // if video snapshot size is currently overridden
273    bool isJpegSizeOverridden();
274
275    // Calculate the crop region rectangle, either tightly about the preview
276    // resolution, or a region just based on the active array; both take
277    // into account the current zoom level.
278    struct CropRegion {
279        float left;
280        float top;
281        float width;
282        float height;
283    };
284    CropRegion calculateCropRegion(bool previewOnly) const;
285
286    // Calculate the field of view of the high-resolution JPEG capture
287    status_t calculatePictureFovs(float *horizFov, float *vertFov) const;
288
289    // Static methods for debugging and converting between camera1 and camera2
290    // parameters
291
292    static const char *getStateName(State state);
293
294    static int formatStringToEnum(const char *format);
295    static const char *formatEnumToString(int format);
296
297    static int wbModeStringToEnum(const char *wbMode);
298    static const char* wbModeEnumToString(uint8_t wbMode);
299    static int effectModeStringToEnum(const char *effectMode);
300    static int abModeStringToEnum(const char *abMode);
301    static int sceneModeStringToEnum(const char *sceneMode);
302    static flashMode_t flashModeStringToEnum(const char *flashMode);
303    static const char* flashModeEnumToString(flashMode_t flashMode);
304    static focusMode_t focusModeStringToEnum(const char *focusMode);
305    static const char* focusModeEnumToString(focusMode_t focusMode);
306
307    static status_t parseAreas(const char *areasCStr,
308            Vector<Area> *areas);
309
310    enum AreaKind
311    {
312        AREA_KIND_FOCUS,
313        AREA_KIND_METERING
314    };
315    status_t validateAreas(const Vector<Area> &areas,
316                                  size_t maxRegions,
317                                  AreaKind areaKind) const;
318    static bool boolFromString(const char *boolStr);
319
320    // Map from camera orientation + facing to gralloc transform enum
321    static int degToTransform(int degrees, bool mirror);
322
323    // API specifies FPS ranges are done in fixed point integer, with LSB = 0.001.
324    // Note that this doesn't apply to the (deprecated) single FPS value.
325    static const int kFpsToApiScale = 1000;
326
327    // Transform from (-1000,-1000)-(1000,1000) normalized coords from camera
328    // API to HAL3 (0,0)-(activePixelArray.width/height) coordinates
329    int normalizedXToArray(int x) const;
330    int normalizedYToArray(int y) const;
331
332    // Transform from HAL3 (0,0)-(activePixelArray.width/height) coordinates to
333    // (-1000,-1000)-(1000,1000) normalized coordinates given a scaler crop
334    // region.
335    int arrayXToNormalizedWithCrop(int x, const CropRegion &scalerCrop) const;
336    int arrayYToNormalizedWithCrop(int y, const CropRegion &scalerCrop) const;
337
338    struct Range {
339        int min;
340        int max;
341    };
342
343    int32_t fpsFromRange(int32_t min, int32_t max) const;
344
345private:
346
347    // Convert from viewfinder crop-region relative array coordinates
348    // to HAL3 sensor array coordinates
349    int cropXToArray(int x) const;
350    int cropYToArray(int y) const;
351
352    // Convert from camera API (-1000,1000)-(1000,1000) normalized coords
353    // to viewfinder crop-region relative array coordinates
354    int normalizedXToCrop(int x) const;
355    int normalizedYToCrop(int y) const;
356
357    // Given a scaler crop region, calculate preview crop region based on
358    // preview aspect ratio.
359    CropRegion calculatePreviewCrop(const CropRegion &scalerCrop) const;
360
361    Vector<Size> availablePreviewSizes;
362    Vector<Size> availableVideoSizes;
363    // Get size list (that are no larger than limit) from static metadata.
364    status_t getFilteredSizes(Size limit, Vector<Size> *sizes);
365    // Get max size (from the size array) that matches the given aspect ratio.
366    Size getMaxSizeForRatio(float ratio, const int32_t* sizeArray, size_t count);
367
368    // Helper function for overriding jpeg size for video snapshot
369    // Check if overridden jpeg size needs to be updated after Parameters::set.
370    // The behavior of this function is tailored to the implementation of Parameters::set.
371    // Do not use this function for other purpose.
372    status_t updateOverriddenJpegSize();
373
374    struct StreamConfiguration {
375        int32_t format;
376        int32_t width;
377        int32_t height;
378        int32_t isInput;
379    };
380
381    // Helper function extract available stream configuration
382    // Only valid since device HAL version 3.2
383    // returns an empty Vector if device HAL version does support it
384    Vector<StreamConfiguration> getStreamConfigurations();
385
386    // Helper function to get minimum frame duration for a jpeg size
387    // return -1 if input jpeg size cannot be found in supported size list
388    int64_t getJpegStreamMinFrameDurationNs(Parameters::Size size);
389
390    // Helper function to get non-duplicated available output formats
391    SortedVector<int32_t> getAvailableOutputFormats();
392    // Helper function to get available output jpeg sizes
393    Vector<Size> getAvailableJpegSizes();
394    // Helper function to get maximum size in input Size vector.
395    // The maximum size is defined by comparing width first, when width ties comparing height.
396    Size getMaxSize(const Vector<Size>& sizes);
397
398    int mDeviceVersion;
399};
400
401// This class encapsulates the Parameters class so that it can only be accessed
402// by constructing a Lock object, which locks the SharedParameter's mutex.
403class SharedParameters {
404  public:
405    SharedParameters(int cameraId, int cameraFacing):
406            mParameters(cameraId, cameraFacing) {
407    }
408
409    template<typename S, typename P>
410    class BaseLock {
411      public:
412        BaseLock(S &p):
413                mParameters(p.mParameters),
414                mSharedParameters(p) {
415            mSharedParameters.mLock.lock();
416        }
417
418        ~BaseLock() {
419            mSharedParameters.mLock.unlock();
420        }
421        P &mParameters;
422      private:
423        // Disallow copying, default construction
424        BaseLock();
425        BaseLock(const BaseLock &);
426        BaseLock &operator=(const BaseLock &);
427        S &mSharedParameters;
428    };
429    typedef BaseLock<SharedParameters, Parameters> Lock;
430    typedef BaseLock<const SharedParameters, const Parameters> ReadLock;
431
432    // Access static info, read-only and immutable, so no lock needed
433    camera_metadata_ro_entry_t staticInfo(uint32_t tag,
434            size_t minCount=0, size_t maxCount=0) const {
435        return mParameters.staticInfo(tag, minCount, maxCount);
436    }
437
438    // Only use for dumping or other debugging
439    const Parameters &unsafeAccess() {
440        return mParameters;
441    }
442  private:
443    Parameters mParameters;
444    mutable Mutex mLock;
445};
446
447
448}; // namespace camera2
449}; // namespace android
450
451#endif
452