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