Camera.h revision 108dddf924d714c811dd565b8f4c7a0178cca2f2
1/* 2 * Copyright (C) 2008 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_HARDWARE_CAMERA_H 18#define ANDROID_HARDWARE_CAMERA_H 19 20#include <utils/Timers.h> 21#include <camera/ICameraClient.h> 22#include <gui/ISurfaceTexture.h> 23 24namespace android { 25 26/* 27 * A set of bit masks for specifying how the received preview frames are 28 * handled before the previewCallback() call. 29 * 30 * The least significant 3 bits of an "int" value are used for this purpose: 31 * 32 * ..... 0 0 0 33 * ^ ^ ^ 34 * | | |---------> determine whether the callback is enabled or not 35 * | |-----------> determine whether the callback is one-shot or not 36 * |-------------> determine whether the frame is copied out or not 37 * 38 * WARNING: 39 * When a frame is sent directly without copying, it is the frame receiver's 40 * responsiblity to make sure that the frame data won't get corrupted by 41 * subsequent preview frames filled by the camera. This flag is recommended 42 * only when copying out data brings significant performance price and the 43 * handling/processing of the received frame data is always faster than 44 * the preview frame rate so that data corruption won't occur. 45 * 46 * For instance, 47 * 1. 0x00 disables the callback. In this case, copy out and one shot bits 48 * are ignored. 49 * 2. 0x01 enables a callback without copying out the received frames. A 50 * typical use case is the Camcorder application to avoid making costly 51 * frame copies. 52 * 3. 0x05 is enabling a callback with frame copied out repeatedly. A typical 53 * use case is the Camera application. 54 * 4. 0x07 is enabling a callback with frame copied out only once. A typical use 55 * case is the Barcode scanner application. 56 */ 57#define FRAME_CALLBACK_FLAG_ENABLE_MASK 0x01 58#define FRAME_CALLBACK_FLAG_ONE_SHOT_MASK 0x02 59#define FRAME_CALLBACK_FLAG_COPY_OUT_MASK 0x04 60 61// Typical use cases 62#define FRAME_CALLBACK_FLAG_NOOP 0x00 63#define FRAME_CALLBACK_FLAG_CAMCORDER 0x01 64#define FRAME_CALLBACK_FLAG_CAMERA 0x05 65#define FRAME_CALLBACK_FLAG_BARCODE_SCANNER 0x07 66 67// msgType in notifyCallback and dataCallback functions 68enum { 69 CAMERA_MSG_ERROR = 0x0001, 70 CAMERA_MSG_SHUTTER = 0x0002, 71 CAMERA_MSG_FOCUS = 0x0004, 72 CAMERA_MSG_ZOOM = 0x0008, 73 CAMERA_MSG_PREVIEW_FRAME = 0x0010, 74 CAMERA_MSG_VIDEO_FRAME = 0x0020, 75 CAMERA_MSG_POSTVIEW_FRAME = 0x0040, 76 CAMERA_MSG_RAW_IMAGE = 0x0080, 77 CAMERA_MSG_COMPRESSED_IMAGE = 0x0100, 78 CAMERA_MSG_RAW_IMAGE_NOTIFY = 0x0200, 79 CAMERA_MSG_ALL_MSGS = 0xFFFF 80}; 81 82// cmdType in sendCommand functions 83enum { 84 CAMERA_CMD_START_SMOOTH_ZOOM = 1, 85 CAMERA_CMD_STOP_SMOOTH_ZOOM = 2, 86 // Set the clockwise rotation of preview display (setPreviewDisplay) in 87 // degrees. This affects the preview frames and the picture displayed after 88 // snapshot. This method is useful for portrait mode applications. Note that 89 // preview display of front-facing cameras is flipped horizontally before 90 // the rotation, that is, the image is reflected along the central vertical 91 // axis of the camera sensor. So the users can see themselves as looking 92 // into a mirror. 93 // 94 // This does not affect the order of byte array of CAMERA_MSG_PREVIEW_FRAME, 95 // CAMERA_MSG_VIDEO_FRAME, CAMERA_MSG_POSTVIEW_FRAME, CAMERA_MSG_RAW_IMAGE, 96 // or CAMERA_MSG_COMPRESSED_IMAGE. This is not allowed to be set during 97 // preview. 98 CAMERA_CMD_SET_DISPLAY_ORIENTATION = 3, 99 100 // cmdType to disable/enable shutter sound. 101 // In sendCommand passing arg1 = 0 will disable, 102 // while passing arg1 = 1 will enable the shutter sound. 103 CAMERA_CMD_ENABLE_SHUTTER_SOUND = 4, 104 105 // cmdType to play recording sound. 106 CAMERA_CMD_PLAY_RECORDING_SOUND = 5, 107}; 108 109// camera fatal errors 110enum { 111 CAMERA_ERROR_UNKNOWN = 1, 112 CAMERA_ERROR_SERVER_DIED = 100 113}; 114 115enum { 116 CAMERA_FACING_BACK = 0, /* The facing of the camera is opposite to that of the screen. */ 117 CAMERA_FACING_FRONT = 1 /* The facing of the camera is the same as that of the screen. */ 118}; 119 120struct CameraInfo { 121 122 /** 123 * The direction that the camera faces to. It should be 124 * CAMERA_FACING_BACK or CAMERA_FACING_FRONT. 125 */ 126 int facing; 127 128 /** 129 * The orientation of the camera image. The value is the angle that the 130 * camera image needs to be rotated clockwise so it shows correctly on 131 * the display in its natural orientation. It should be 0, 90, 180, or 270. 132 * 133 * For example, suppose a device has a naturally tall screen. The 134 * back-facing camera sensor is mounted in landscape. You are looking at 135 * the screen. If the top side of the camera sensor is aligned with the 136 * right edge of the screen in natural orientation, the value should be 137 * 90. If the top side of a front-facing camera sensor is aligned with 138 * the right of the screen, the value should be 270. 139 */ 140 int orientation; 141}; 142 143class ICameraService; 144class ICamera; 145class Surface; 146class Mutex; 147class String8; 148 149// ref-counted object for callbacks 150class CameraListener: virtual public RefBase 151{ 152public: 153 virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2) = 0; 154 virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr) = 0; 155 virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) = 0; 156}; 157 158class Camera : public BnCameraClient, public IBinder::DeathRecipient 159{ 160public: 161 // construct a camera client from an existing remote 162 static sp<Camera> create(const sp<ICamera>& camera); 163 static int32_t getNumberOfCameras(); 164 static status_t getCameraInfo(int cameraId, 165 struct CameraInfo* cameraInfo); 166 static sp<Camera> connect(int cameraId); 167 ~Camera(); 168 void init(); 169 170 status_t reconnect(); 171 void disconnect(); 172 status_t lock(); 173 status_t unlock(); 174 175 status_t getStatus() { return mStatus; } 176 177 // pass the buffered Surface to the camera service 178 status_t setPreviewDisplay(const sp<Surface>& surface); 179 180 // pass the buffered ISurfaceTexture to the camera service 181 status_t setPreviewTexture(const sp<ISurfaceTexture>& surfaceTexture); 182 183 // start preview mode, must call setPreviewDisplay first 184 status_t startPreview(); 185 186 // stop preview mode 187 void stopPreview(); 188 189 // get preview state 190 bool previewEnabled(); 191 192 // start recording mode, must call setPreviewDisplay first 193 status_t startRecording(); 194 195 // stop recording mode 196 void stopRecording(); 197 198 // get recording state 199 bool recordingEnabled(); 200 201 // release a recording frame 202 void releaseRecordingFrame(const sp<IMemory>& mem); 203 204 // autoFocus - status returned from callback 205 status_t autoFocus(); 206 207 // cancel auto focus 208 status_t cancelAutoFocus(); 209 210 // take a picture - picture returned from callback 211 status_t takePicture(int msgType); 212 213 // set preview/capture parameters - key/value pairs 214 status_t setParameters(const String8& params); 215 216 // get preview/capture parameters - key/value pairs 217 String8 getParameters() const; 218 219 // send command to camera driver 220 status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); 221 222 // tell camera hal to store meta data or real YUV in video buffers. 223 status_t storeMetaDataInBuffers(bool enabled); 224 225 void setListener(const sp<CameraListener>& listener); 226 void setPreviewCallbackFlags(int preview_callback_flag); 227 228 // ICameraClient interface 229 virtual void notifyCallback(int32_t msgType, int32_t ext, int32_t ext2); 230 virtual void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr); 231 virtual void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr); 232 233 sp<ICamera> remote(); 234 235private: 236 Camera(); 237 Camera(const Camera&); 238 Camera& operator=(const Camera); 239 virtual void binderDied(const wp<IBinder>& who); 240 241 class DeathNotifier: public IBinder::DeathRecipient 242 { 243 public: 244 DeathNotifier() { 245 } 246 247 virtual void binderDied(const wp<IBinder>& who); 248 }; 249 250 static sp<DeathNotifier> mDeathNotifier; 251 252 // helper function to obtain camera service handle 253 static const sp<ICameraService>& getCameraService(); 254 255 sp<ICamera> mCamera; 256 status_t mStatus; 257 258 sp<CameraListener> mListener; 259 260 friend class DeathNotifier; 261 262 static Mutex mLock; 263 static sp<ICameraService> mCameraService; 264 265}; 266 267}; // namespace android 268 269#endif 270