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