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