Camera2Client.h revision 228a53805808a24cb19fcf13b1f0bdc2ed89bbe1
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_CAMERA2CLIENT_H 18#define ANDROID_SERVERS_CAMERA_CAMERA2CLIENT_H 19 20#include "Camera2Device.h" 21#include "CameraService.h" 22#include "camera/CameraParameters.h" 23#include <binder/MemoryBase.h> 24#include <binder/MemoryHeapBase.h> 25#include <gui/CpuConsumer.h> 26#include "MediaConsumer.h" 27 28namespace android { 29 30/** 31 * Implements the android.hardware.camera API on top of 32 * camera device HAL version 2. 33 */ 34class Camera2Client : 35 public CameraService::Client, 36 public Camera2Device::NotificationListener, 37 public Camera2Device::FrameListener 38{ 39public: 40 // ICamera interface (see ICamera for details) 41 42 virtual void disconnect(); 43 virtual status_t connect(const sp<ICameraClient>& client); 44 virtual status_t lock(); 45 virtual status_t unlock(); 46 virtual status_t setPreviewDisplay(const sp<Surface>& surface); 47 virtual status_t setPreviewTexture( 48 const sp<ISurfaceTexture>& surfaceTexture); 49 virtual void setPreviewCallbackFlag(int flag); 50 virtual status_t startPreview(); 51 virtual void stopPreview(); 52 virtual bool previewEnabled(); 53 virtual status_t storeMetaDataInBuffers(bool enabled); 54 virtual status_t startRecording(); 55 virtual void stopRecording(); 56 virtual bool recordingEnabled(); 57 virtual void releaseRecordingFrame(const sp<IMemory>& mem); 58 virtual status_t autoFocus(); 59 virtual status_t cancelAutoFocus(); 60 virtual status_t takePicture(int msgType); 61 virtual status_t setParameters(const String8& params); 62 virtual String8 getParameters() const; 63 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); 64 65 // Interface used by CameraService 66 67 Camera2Client(const sp<CameraService>& cameraService, 68 const sp<ICameraClient>& cameraClient, 69 int cameraId, 70 int cameraFacing, 71 int clientPid); 72 virtual ~Camera2Client(); 73 74 status_t initialize(camera_module_t *module); 75 76 virtual status_t dump(int fd, const Vector<String16>& args); 77 78 // Interface used by CameraDevice 79 80 virtual void notifyError(int errorCode, int arg1, int arg2); 81 virtual void notifyShutter(int frameNumber, nsecs_t timestamp); 82 virtual void notifyAutoFocus(uint8_t newState, int triggerId); 83 virtual void notifyAutoExposure(uint8_t newState, int triggerId); 84 virtual void notifyAutoWhitebalance(uint8_t newState, int triggerId); 85 86 virtual void onNewFrameAvailable(); 87private: 88 enum State { 89 DISCONNECTED, 90 STOPPED, 91 WAITING_FOR_PREVIEW_WINDOW, 92 PREVIEW, 93 RECORD, 94 STILL_CAPTURE, 95 VIDEO_SNAPSHOT 96 }; 97 static const char *getStateName(State state); 98 99 /** ICamera interface-related private members */ 100 101 // Mutex that must be locked by methods implementing the ICamera interface. 102 // Ensures serialization between incoming ICamera calls. All methods below 103 // that append 'L' to the name assume that mICameraLock is locked when 104 // they're called 105 mutable Mutex mICameraLock; 106 107 // Mutex that must be locked by methods accessing the base Client's 108 // mCameraClient ICameraClient interface member, for sending notifications 109 // up to the camera user 110 mutable Mutex mICameraClientLock; 111 112 class Parameters; 113 114 status_t setPreviewWindowL(const sp<IBinder>& binder, 115 sp<ANativeWindow> window); 116 status_t startPreviewL(Parameters ¶ms, bool restart); 117 void stopPreviewL(); 118 status_t startRecordingL(Parameters ¶ms, bool restart); 119 bool recordingEnabledL(); 120 121 // Individual commands for sendCommand() 122 status_t commandStartSmoothZoomL(); 123 status_t commandStopSmoothZoomL(); 124 status_t commandSetDisplayOrientationL(int degrees); 125 status_t commandEnableShutterSoundL(bool enable); 126 status_t commandPlayRecordingSoundL(); 127 status_t commandStartFaceDetectionL(int type); 128 status_t commandStopFaceDetectionL(Parameters ¶ms); 129 status_t commandEnableFocusMoveMsgL(bool enable); 130 status_t commandPingL(); 131 status_t commandSetVideoBufferCountL(size_t count); 132 133 // Current camera state; this is the contents of the CameraParameters object 134 // in a more-efficient format. The enum values are mostly based off the 135 // corresponding camera2 enums, not the camera1 strings. A few are defined 136 // here if they don't cleanly map to camera2 values. 137 struct Parameters { 138 int previewWidth, previewHeight; 139 int32_t previewFpsRange[2]; 140 int previewFps; // deprecated, here only for tracking changes 141 int previewFormat; 142 143 int previewTransform; // set by CAMERA_CMD_SET_DISPLAY_ORIENTATION 144 145 int pictureWidth, pictureHeight; 146 147 int32_t jpegThumbSize[2]; 148 int32_t jpegQuality, jpegThumbQuality; 149 int32_t jpegRotation; 150 151 bool gpsEnabled; 152 double gpsCoordinates[3]; 153 int64_t gpsTimestamp; 154 String8 gpsProcessingMethod; 155 156 int wbMode; 157 int effectMode; 158 int antibandingMode; 159 int sceneMode; 160 161 enum flashMode_t { 162 FLASH_MODE_OFF = 0, 163 FLASH_MODE_AUTO, 164 FLASH_MODE_ON, 165 FLASH_MODE_TORCH, 166 FLASH_MODE_RED_EYE = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE, 167 FLASH_MODE_INVALID = -1 168 } flashMode; 169 170 enum focusMode_t { 171 FOCUS_MODE_AUTO = ANDROID_CONTROL_AF_AUTO, 172 FOCUS_MODE_MACRO = ANDROID_CONTROL_AF_MACRO, 173 FOCUS_MODE_CONTINUOUS_VIDEO = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO, 174 FOCUS_MODE_CONTINUOUS_PICTURE = 175 ANDROID_CONTROL_AF_CONTINUOUS_PICTURE, 176 FOCUS_MODE_EDOF = ANDROID_CONTROL_AF_EDOF, 177 FOCUS_MODE_INFINITY, 178 FOCUS_MODE_FIXED, 179 FOCUS_MODE_INVALID = -1 180 } focusMode; 181 182 struct Area { 183 int left, top, right, bottom; 184 int weight; 185 Area() {} 186 Area(int left, int top, int right, int bottom, int weight): 187 left(left), top(top), right(right), bottom(bottom), 188 weight(weight) {} 189 }; 190 Vector<Area> focusingAreas; 191 192 int32_t exposureCompensation; 193 bool autoExposureLock; 194 bool autoWhiteBalanceLock; 195 196 Vector<Area> meteringAreas; 197 198 int zoom; 199 200 int videoWidth, videoHeight; 201 202 bool recordingHint; 203 bool videoStabilization; 204 205 String8 paramsFlattened; 206 207 // These parameters are also part of the camera API-visible state, but not directly 208 // listed in Camera.Parameters 209 bool storeMetadataInBuffers; 210 bool playShutterSound; 211 bool enableFaceDetect; 212 213 bool enableFocusMoveMessages; 214 int afTriggerCounter; 215 int currentAfTriggerId; 216 bool afInMotion; 217 218 uint32_t previewCallbackFlags; 219 bool previewCallbackOneShot; 220 221 // Overall camera state 222 State state; 223 }; 224 225 // This class encapsulates the Parameters class so that it can only be accessed 226 // by constructing a Key object, which locks the LockedParameter's mutex. 227 class LockedParameters { 228 public: 229 class Key { 230 public: 231 Key(LockedParameters &p): 232 mParameters(p.mParameters), 233 mLockedParameters(p) { 234 mLockedParameters.mLock.lock(); 235 } 236 237 ~Key() { 238 mLockedParameters.mLock.unlock(); 239 } 240 Parameters &mParameters; 241 private: 242 // Disallow copying, default construction 243 Key(); 244 Key(const Key &); 245 Key &operator=(const Key &); 246 LockedParameters &mLockedParameters; 247 }; 248 class ReadKey { 249 public: 250 ReadKey(const LockedParameters &p): 251 mParameters(p.mParameters), 252 mLockedParameters(p) { 253 mLockedParameters.mLock.lock(); 254 } 255 256 ~ReadKey() { 257 mLockedParameters.mLock.unlock(); 258 } 259 const Parameters &mParameters; 260 private: 261 // Disallow copying, default construction 262 ReadKey(); 263 ReadKey(const ReadKey &); 264 ReadKey &operator=(const ReadKey &); 265 const LockedParameters &mLockedParameters; 266 }; 267 268 // Only use for dumping or other debugging 269 const Parameters &unsafeUnlock() { 270 return mParameters; 271 } 272 private: 273 Parameters mParameters; 274 mutable Mutex mLock; 275 276 } mParameters; 277 278 // Static device information; this is a subset of the information 279 // available through the staticInfo() method, used for frequently-accessed 280 // values or values that have to be calculated from the static information. 281 struct DeviceInfo { 282 int32_t arrayWidth; 283 int32_t arrayHeight; 284 uint8_t bestFaceDetectMode; 285 int32_t maxFaces; 286 }; 287 const DeviceInfo *mDeviceInfo; 288 289 /** Camera device-related private members */ 290 291 class Camera2Heap; 292 293 void setPreviewCallbackFlagL(Parameters ¶ms, int flag); 294 status_t updateRequests(const Parameters ¶ms); 295 296 // Number of zoom steps to simulate 297 static const unsigned int NUM_ZOOM_STEPS = 10; 298 // Used with stream IDs 299 static const int NO_STREAM = -1; 300 301 /* Output frame metadata processing methods */ 302 303 status_t processFrameFaceDetect(camera_metadata_t *frame); 304 305 /* Preview related members */ 306 307 int mPreviewStreamId; 308 camera_metadata_t *mPreviewRequest; 309 sp<IBinder> mPreviewSurface; 310 sp<ANativeWindow> mPreviewWindow; 311 312 status_t updatePreviewRequest(const Parameters ¶ms); 313 status_t updatePreviewStream(const Parameters ¶ms); 314 315 /** Preview callback related members */ 316 317 int mCallbackStreamId; 318 static const size_t kCallbackHeapCount = 6; 319 sp<CpuConsumer> mCallbackConsumer; 320 sp<ANativeWindow> mCallbackWindow; 321 // Simple listener that forwards frame available notifications from 322 // a CPU consumer to the callback notification 323 class CallbackWaiter: public CpuConsumer::FrameAvailableListener { 324 public: 325 CallbackWaiter(Camera2Client *parent) : mParent(parent) {} 326 void onFrameAvailable() { mParent->onCallbackAvailable(); } 327 private: 328 Camera2Client *mParent; 329 }; 330 sp<CallbackWaiter> mCallbackWaiter; 331 sp<Camera2Heap> mCallbackHeap; 332 int mCallbackHeapId; 333 size_t mCallbackHeapHead, mCallbackHeapFree; 334 // Handle callback image buffers 335 void onCallbackAvailable(); 336 337 status_t updateCallbackStream(const Parameters ¶ms); 338 339 /* Still image capture related members */ 340 341 int mCaptureStreamId; 342 sp<CpuConsumer> mCaptureConsumer; 343 sp<ANativeWindow> mCaptureWindow; 344 // Simple listener that forwards frame available notifications from 345 // a CPU consumer to the capture notification 346 class CaptureWaiter: public CpuConsumer::FrameAvailableListener { 347 public: 348 CaptureWaiter(Camera2Client *parent) : mParent(parent) {} 349 void onFrameAvailable() { mParent->onCaptureAvailable(); } 350 private: 351 Camera2Client *mParent; 352 }; 353 sp<CaptureWaiter> mCaptureWaiter; 354 camera_metadata_t *mCaptureRequest; 355 sp<Camera2Heap> mCaptureHeap; 356 // Handle captured image buffers 357 void onCaptureAvailable(); 358 359 status_t updateCaptureRequest(const Parameters ¶ms); 360 status_t updateCaptureStream(const Parameters ¶ms); 361 362 /* Recording related members */ 363 364 int mRecordingStreamId; 365 int mRecordingFrameCount; 366 sp<MediaConsumer> mRecordingConsumer; 367 sp<ANativeWindow> mRecordingWindow; 368 // Simple listener that forwards frame available notifications from 369 // a CPU consumer to the recording notification 370 class RecordingWaiter: public MediaConsumer::FrameAvailableListener { 371 public: 372 RecordingWaiter(Camera2Client *parent) : mParent(parent) {} 373 void onFrameAvailable() { mParent->onRecordingFrameAvailable(); } 374 private: 375 Camera2Client *mParent; 376 }; 377 sp<RecordingWaiter> mRecordingWaiter; 378 camera_metadata_t *mRecordingRequest; 379 sp<Camera2Heap> mRecordingHeap; 380 381 static const size_t kDefaultRecordingHeapCount = 8; 382 size_t mRecordingHeapCount; 383 size_t mRecordingHeapHead, mRecordingHeapFree; 384 // Handle new recording image buffers 385 void onRecordingFrameAvailable(); 386 387 status_t updateRecordingRequest(const Parameters ¶ms); 388 status_t updateRecordingStream(const Parameters ¶ms); 389 390 /** Notification-related members */ 391 392 bool mAfInMotion; 393 394 /** Camera2Device instance wrapping HAL2 entry */ 395 396 sp<Camera2Device> mDevice; 397 398 /** Utility members */ 399 400 // Verify that caller is the owner of the camera 401 status_t checkPid(const char *checkLocation) const; 402 403 // Utility class for managing a set of IMemory blocks 404 class Camera2Heap : public RefBase { 405 public: 406 Camera2Heap(size_t buf_size, uint_t num_buffers = 1, 407 const char *name = NULL) : 408 mBufSize(buf_size), 409 mNumBufs(num_buffers) { 410 mHeap = new MemoryHeapBase(buf_size * num_buffers, 0, name); 411 mBuffers = new sp<MemoryBase>[mNumBufs]; 412 for (uint_t i = 0; i < mNumBufs; i++) 413 mBuffers[i] = new MemoryBase(mHeap, 414 i * mBufSize, 415 mBufSize); 416 } 417 418 virtual ~Camera2Heap() 419 { 420 delete [] mBuffers; 421 } 422 423 size_t mBufSize; 424 uint_t mNumBufs; 425 sp<MemoryHeapBase> mHeap; 426 sp<MemoryBase> *mBuffers; 427 }; 428 429 // Get values for static camera info entry. min/maxCount are used for error 430 // checking the number of values in the entry. 0 for max/minCount means to 431 // do no bounds check in that direction. In case of error, the entry data 432 // pointer is null and the count is 0. 433 camera_metadata_entry_t staticInfo(uint32_t tag, 434 size_t minCount=0, size_t maxCount=0); 435 436 // Extract frequently-used camera static information into mDeviceInfo 437 status_t buildDeviceInfo(); 438 // Convert static camera info from a camera2 device to the 439 // old API parameter map. 440 status_t buildDefaultParameters(); 441 442 // Update parameters all requests use, based on mParameters 443 status_t updateRequestCommon(camera_metadata_t *request, const Parameters ¶ms); 444 445 // Map from sensor active array pixel coordinates to normalized camera parameter coordinates 446 // The former are (0,0)-(array width - 1, array height - 1), the latter from 447 // (-1000,-1000)-(1000,1000) 448 int arrayXToNormalized(int width) const; 449 int arrayYToNormalized(int height) const; 450 451 // Update specific metadata entry with new values. Adds entry if it does not 452 // exist, which will invalidate sorting 453 static status_t updateEntry(camera_metadata_t *buffer, 454 uint32_t tag, const void *data, size_t data_count); 455 456 // Remove metadata entry. Will invalidate sorting. If entry does not exist, 457 // does nothing. 458 static status_t deleteEntry(camera_metadata_t *buffer, 459 uint32_t tag); 460 461 // Convert camera1 preview format string to camera2 enum 462 static int formatStringToEnum(const char *format); 463 static const char *formatEnumToString(int format); 464 465 static int wbModeStringToEnum(const char *wbMode); 466 static int effectModeStringToEnum(const char *effectMode); 467 static int abModeStringToEnum(const char *abMode); 468 static int sceneModeStringToEnum(const char *sceneMode); 469 static Parameters::flashMode_t flashModeStringToEnum(const char *flashMode); 470 static Parameters::focusMode_t focusModeStringToEnum(const char *focusMode); 471 static status_t parseAreas(const char *areasCStr, 472 Vector<Parameters::Area> *areas); 473 static status_t validateAreas(const Vector<Parameters::Area> &areas, 474 size_t maxRegions); 475 static bool boolFromString(const char *boolStr); 476 477 // Map from camera orientation + facing to gralloc transform enum 478 static int degToTransform(int degrees, bool mirror); 479 480 static size_t calculateBufferSize(int width, int height, 481 int format, int stride); 482}; 483 484}; // namespace android 485 486#endif 487