Camera2Client.h revision 3a609147811105d40766f8f8f5904bf71cb123cb
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 : public CameraService::Client 35{ 36public: 37 // ICamera interface (see ICamera for details) 38 virtual void disconnect(); 39 virtual status_t connect(const sp<ICameraClient>& client); 40 virtual status_t lock(); 41 virtual status_t unlock(); 42 virtual status_t setPreviewDisplay(const sp<Surface>& surface); 43 virtual status_t setPreviewTexture( 44 const sp<ISurfaceTexture>& surfaceTexture); 45 virtual void setPreviewCallbackFlag(int flag); 46 virtual status_t startPreview(); 47 virtual void stopPreview(); 48 virtual bool previewEnabled(); 49 virtual status_t storeMetaDataInBuffers(bool enabled); 50 virtual status_t startRecording(); 51 virtual void stopRecording(); 52 virtual bool recordingEnabled(); 53 virtual void releaseRecordingFrame(const sp<IMemory>& mem); 54 virtual status_t autoFocus(); 55 virtual status_t cancelAutoFocus(); 56 virtual status_t takePicture(int msgType); 57 virtual status_t setParameters(const String8& params); 58 virtual String8 getParameters() const; 59 virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); 60 61 // Interface used by CameraService 62 Camera2Client(const sp<CameraService>& cameraService, 63 const sp<ICameraClient>& cameraClient, 64 int cameraId, 65 int cameraFacing, 66 int clientPid); 67 ~Camera2Client(); 68 69 status_t initialize(camera_module_t *module); 70 71 virtual status_t dump(int fd, const Vector<String16>& args); 72 73private: 74 enum State { 75 DISCONNECTED, 76 STOPPED, 77 WAITING_FOR_PREVIEW_WINDOW, 78 PREVIEW, 79 RECORD, 80 STILL_CAPTURE, 81 VIDEO_SNAPSHOT 82 } mState; 83 84 static const char *getStateName(State state); 85 86 /** ICamera interface-related private members */ 87 88 // Mutex that must be locked by methods implementing the ICamera interface. 89 // Ensures serialization between incoming ICamera calls 90 mutable Mutex mICameraLock; 91 92 // The following must be called with mICameraLock already locked 93 94 status_t setPreviewWindowLocked(const sp<IBinder>& binder, 95 sp<ANativeWindow> window); 96 97 void stopPreviewLocked(); 98 status_t startPreviewLocked(); 99 100 // Current camera state; this is the contents of the CameraParameters object 101 // in a more-efficient format. The enum values are mostly based off the 102 // corresponding camera2 enums, not the camera1 strings. A few are defined 103 // here if they don't cleanly map to camera2 values. 104 struct Parameters { 105 int previewWidth, previewHeight; 106 int32_t previewFpsRange[2]; 107 int previewFps; // deprecated, here only for tracking changes 108 int previewFormat; 109 110 int previewTransform; // set by CAMERA_CMD_SET_DISPLAY_ORIENTATION 111 112 int pictureWidth, pictureHeight; 113 114 int32_t jpegThumbSize[2]; 115 int32_t jpegQuality, jpegThumbQuality; 116 int32_t jpegRotation; 117 118 bool gpsEnabled; 119 double gpsCoordinates[3]; 120 int64_t gpsTimestamp; 121 String8 gpsProcessingMethod; 122 123 int wbMode; 124 int effectMode; 125 int antibandingMode; 126 int sceneMode; 127 128 enum flashMode_t { 129 FLASH_MODE_OFF = 0, 130 FLASH_MODE_AUTO, 131 FLASH_MODE_ON, 132 FLASH_MODE_TORCH, 133 FLASH_MODE_RED_EYE = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE, 134 FLASH_MODE_INVALID = -1 135 } flashMode; 136 137 enum focusMode_t { 138 FOCUS_MODE_AUTO = ANDROID_CONTROL_AF_AUTO, 139 FOCUS_MODE_MACRO = ANDROID_CONTROL_AF_MACRO, 140 FOCUS_MODE_CONTINUOUS_VIDEO = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO, 141 FOCUS_MODE_CONTINUOUS_PICTURE = 142 ANDROID_CONTROL_AF_CONTINUOUS_PICTURE, 143 FOCUS_MODE_EDOF = ANDROID_CONTROL_AF_EDOF, 144 FOCUS_MODE_INFINITY, 145 FOCUS_MODE_FIXED, 146 FOCUS_MODE_INVALID = -1 147 } focusMode; 148 149 struct Area { 150 int left, top, right, bottom; 151 int weight; 152 Area() {} 153 Area(int left, int top, int right, int bottom, int weight): 154 left(left), top(top), right(right), bottom(bottom), 155 weight(weight) {} 156 }; 157 Vector<Area> focusingAreas; 158 159 int32_t exposureCompensation; 160 bool autoExposureLock; 161 bool autoWhiteBalanceLock; 162 163 Vector<Area> meteringAreas; 164 165 int zoom; 166 167 int videoWidth, videoHeight; 168 169 bool recordingHint; 170 bool videoStabilization; 171 172 bool storeMetadataInBuffers; 173 174 String8 paramsFlattened; 175 }; 176 177 class LockedParameters { 178 public: 179 class Key { 180 public: 181 Key(LockedParameters &p): 182 mParameters(p.mParameters), 183 mLockedParameters(p) { 184 mLockedParameters.mLock.lock(); 185 } 186 187 ~Key() { 188 mLockedParameters.mLock.unlock(); 189 } 190 Parameters &mParameters; 191 private: 192 // Disallow copying, default construction 193 Key(); 194 Key(const Key &); 195 Key &operator=(const Key &); 196 LockedParameters &mLockedParameters; 197 }; 198 class ReadKey { 199 public: 200 ReadKey(const LockedParameters &p): 201 mParameters(p.mParameters), 202 mLockedParameters(p) { 203 mLockedParameters.mLock.lock(); 204 } 205 206 ~ReadKey() { 207 mLockedParameters.mLock.unlock(); 208 } 209 const Parameters &mParameters; 210 private: 211 // Disallow copying, default construction 212 ReadKey(); 213 ReadKey(const ReadKey &); 214 ReadKey &operator=(const ReadKey &); 215 const LockedParameters &mLockedParameters; 216 }; 217 218 // Only use for dumping or other debugging 219 const Parameters &unsafeUnlock() { 220 return mParameters; 221 } 222 private: 223 Parameters mParameters; 224 mutable Mutex mLock; 225 226 } mParameters; 227 228 /** Camera device-related private members */ 229 230 class Camera2Heap; 231 232 // Number of zoom steps to simulate 233 static const unsigned int NUM_ZOOM_STEPS = 10; 234 // Used with stream IDs 235 static const int NO_STREAM = -1; 236 237 /* Preview related members */ 238 239 int mPreviewStreamId; 240 camera_metadata_t *mPreviewRequest; 241 sp<IBinder> mPreviewSurface; 242 sp<ANativeWindow> mPreviewWindow; 243 244 status_t updatePreviewRequest(const Parameters ¶ms); 245 status_t updatePreviewStream(const Parameters ¶ms); 246 247 /* Still image capture related members */ 248 249 int mCaptureStreamId; 250 sp<CpuConsumer> mCaptureConsumer; 251 sp<ANativeWindow> mCaptureWindow; 252 // Simple listener that forwards frame available notifications from 253 // a CPU consumer to the capture notification 254 class CaptureWaiter: public CpuConsumer::FrameAvailableListener { 255 public: 256 CaptureWaiter(Camera2Client *parent) : mParent(parent) {} 257 void onFrameAvailable() { mParent->onCaptureAvailable(); } 258 private: 259 Camera2Client *mParent; 260 }; 261 sp<CaptureWaiter> mCaptureWaiter; 262 camera_metadata_t *mCaptureRequest; 263 sp<Camera2Heap> mCaptureHeap; 264 // Handle captured image buffers 265 void onCaptureAvailable(); 266 267 status_t updateCaptureRequest(const Parameters ¶ms); 268 status_t updateCaptureStream(const Parameters ¶ms); 269 270 /* Recording related members */ 271 272 int mRecordingStreamId; 273 sp<MediaConsumer> mRecordingConsumer; 274 sp<ANativeWindow> mRecordingWindow; 275 // Simple listener that forwards frame available notifications from 276 // a CPU consumer to the recording notification 277 class RecordingWaiter: public MediaConsumer::FrameAvailableListener { 278 public: 279 RecordingWaiter(Camera2Client *parent) : mParent(parent) {} 280 void onFrameAvailable() { mParent->onRecordingFrameAvailable(); } 281 private: 282 Camera2Client *mParent; 283 }; 284 sp<RecordingWaiter> mRecordingWaiter; 285 camera_metadata_t *mRecordingRequest; 286 sp<Camera2Heap> mRecordingHeap; 287 288 // TODO: This needs to be queried from somewhere, or the BufferQueue needs 289 // to be passed all the way to stagefright. Right now, set to a large number 290 // to avoid starvation of the video encoders. 291 static const size_t kRecordingHeapCount = 8; 292 size_t mRecordingHeapHead, mRecordingHeapFree; 293 // Handle new recording image buffers 294 void onRecordingFrameAvailable(); 295 296 status_t updateRecordingRequest(const Parameters ¶ms); 297 status_t updateRecordingStream(const Parameters ¶ms); 298 299 /** Camera2Device instance wrapping HAL2 entry */ 300 301 sp<Camera2Device> mDevice; 302 303 /** Utility members */ 304 305 // Verify that caller is the owner of the camera 306 status_t checkPid(const char *checkLocation) const; 307 308 // Utility class for managing a set of IMemory blocks 309 class Camera2Heap : public RefBase { 310 public: 311 Camera2Heap(size_t buf_size, uint_t num_buffers = 1, 312 const char *name = NULL) : 313 mBufSize(buf_size), 314 mNumBufs(num_buffers) { 315 mHeap = new MemoryHeapBase(buf_size * num_buffers, 0, name); 316 mBuffers = new sp<MemoryBase>[mNumBufs]; 317 for (uint_t i = 0; i < mNumBufs; i++) 318 mBuffers[i] = new MemoryBase(mHeap, 319 i * mBufSize, 320 mBufSize); 321 } 322 323 virtual ~Camera2Heap() 324 { 325 delete [] mBuffers; 326 } 327 328 size_t mBufSize; 329 uint_t mNumBufs; 330 sp<MemoryHeapBase> mHeap; 331 sp<MemoryBase> *mBuffers; 332 }; 333 334 // Get values for static camera info entry. min/maxCount are used for error 335 // checking the number of values in the entry. 0 for max/minCount means to 336 // do no bounds check in that direction. In case of error, the entry data 337 // pointer is null and the count is 0. 338 camera_metadata_entry_t staticInfo(uint32_t tag, 339 size_t minCount=0, size_t maxCount=0); 340 341 // Convert static camera info from a camera2 device to the 342 // old API parameter map. 343 status_t buildDefaultParameters(); 344 345 // Update parameters all requests use, based on mParameters 346 status_t updateRequestCommon(camera_metadata_t *request, const Parameters ¶ms); 347 348 // Update specific metadata entry with new values. Adds entry if it does not 349 // exist, which will invalidate sorting 350 static status_t updateEntry(camera_metadata_t *buffer, 351 uint32_t tag, const void *data, size_t data_count); 352 353 // Remove metadata entry. Will invalidate sorting. If entry does not exist, 354 // does nothing. 355 static status_t deleteEntry(camera_metadata_t *buffer, 356 uint32_t tag); 357 358 // Convert camera1 preview format string to camera2 enum 359 static int formatStringToEnum(const char *format); 360 static const char *formatEnumToString(int format); 361 362 static int wbModeStringToEnum(const char *wbMode); 363 static int effectModeStringToEnum(const char *effectMode); 364 static int abModeStringToEnum(const char *abMode); 365 static int sceneModeStringToEnum(const char *sceneMode); 366 static Parameters::flashMode_t flashModeStringToEnum(const char *flashMode); 367 static Parameters::focusMode_t focusModeStringToEnum(const char *focusMode); 368 static status_t parseAreas(const char *areasCStr, 369 Vector<Parameters::Area> *areas); 370 static status_t validateAreas(const Vector<Parameters::Area> &areas, 371 size_t maxRegions); 372 static bool boolFromString(const char *boolStr); 373 374 // Map from camera orientation + facing to gralloc transform enum 375 static int degToTransform(int degrees, bool mirror); 376}; 377 378}; // namespace android 379 380#endif 381