Camera.h revision 35a055b8bfc6f3cbea409b2897caf936654519cb
1/* 2 * Copyright (C) 2008 The Android Open Source Project 3 * Copyright (C) 2008 HTC Inc. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18#ifndef ANDROID_HARDWARE_CAMERA_H 19#define ANDROID_HARDWARE_CAMERA_H 20 21#include <utils/Timers.h> 22#include <camera/ICameraClient.h> 23 24namespace android { 25 26class ISurface; 27 28/* 29 * A set of bit masks for specifying how the received preview frames are 30 * handled before the previewCallback() call. 31 * 32 * The least significant 3 bits of an "int" value are used for this purpose: 33 * 34 * ..... 0 0 0 35 * ^ ^ ^ 36 * | | |---------> determine whether the callback is enabled or not 37 * | |-----------> determine whether the callback is one-shot or not 38 * |-------------> determine whether the frame is copied out or not 39 * 40 * WARNING: 41 * When a frame is sent directly without copying, it is the frame receiver's 42 * responsiblity to make sure that the frame data won't get corrupted by 43 * subsequent preview frames filled by the camera. This flag is recommended 44 * only when copying out data brings significant performance price and the 45 * handling/processing of the received frame data is always faster than 46 * the preview frame rate so that data corruption won't occur. 47 * 48 * For instance, 49 * 1. 0x00 disables the callback. In this case, copy out and one shot bits 50 * are ignored. 51 * 2. 0x01 enables a callback without copying out the received frames. A 52 * typical use case is the Camcorder application to avoid making costly 53 * frame copies. 54 * 3. 0x05 is enabling a callback with frame copied out repeatedly. A typical 55 * use case is the Camera application. 56 * 4. 0x07 is enabling a callback with frame copied out only once. A typical use 57 * case is the Barcode scanner application. 58 */ 59#define FRAME_CALLBACK_FLAG_ENABLE_MASK 0x01 60#define FRAME_CALLBACK_FLAG_ONE_SHOT_MASK 0x02 61#define FRAME_CALLBACK_FLAG_COPY_OUT_MASK 0x04 62 63// Typical use cases 64#define FRAME_CALLBACK_FLAG_NOOP 0x00 65#define FRAME_CALLBACK_FLAG_CAMCORDER 0x01 66#define FRAME_CALLBACK_FLAG_CAMERA 0x05 67#define FRAME_CALLBACK_FLAG_BARCODE_SCANNER 0x07 68 69// msgType in notifyCallback and dataCallback functions 70enum { 71 CAMERA_MSG_ERROR = 0x001, 72 CAMERA_MSG_SHUTTER = 0x002, 73 CAMERA_MSG_FOCUS = 0x004, 74 CAMERA_MSG_ZOOM = 0x008, 75 CAMERA_MSG_PREVIEW_FRAME = 0x010, 76 CAMERA_MSG_VIDEO_FRAME = 0x020, 77 CAMERA_MSG_POSTVIEW_FRAME = 0x040, 78 CAMERA_MSG_RAW_IMAGE = 0x080, 79 CAMERA_MSG_COMPRESSED_IMAGE = 0x100, 80 CAMERA_MSG_ALL_MSGS = 0x1FF 81}; 82 83// cmdType in sendCommand functions 84enum { 85 CAMERA_CMD_START_SMOOTH_ZOOM = 1, 86 CAMERA_CMD_STOP_SMOOTH_ZOOM = 2, 87 CAMERA_CMD_SET_DISPLAY_ORIENTATION = 3, 88}; 89 90// camera fatal errors 91enum { 92 CAMERA_ERROR_UKNOWN = 1, 93 CAMERA_ERROR_SERVER_DIED = 100 94}; 95 96class ICameraService; 97class ICamera; 98class Surface; 99class Mutex; 100class String8; 101 102// ref-counted object for callbacks 103class CameraListener: virtual public RefBase 104{ 105public: 106 virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2) = 0; 107 virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr) = 0; 108 virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) = 0; 109}; 110 111class Camera : public BnCameraClient, public IBinder::DeathRecipient 112{ 113public: 114 // construct a camera client from an existing remote 115 static sp<Camera> create(const sp<ICamera>& camera); 116 static int32_t getNumberOfCameras(); 117 static sp<Camera> connect(int cameraId); 118 ~Camera(); 119 void init(); 120 121 status_t reconnect(); 122 void disconnect(); 123 status_t lock(); 124 status_t unlock(); 125 126 status_t getStatus() { return mStatus; } 127 128 // pass the buffered ISurface to the camera service 129 status_t setPreviewDisplay(const sp<Surface>& surface); 130 status_t setPreviewDisplay(const sp<ISurface>& surface); 131 132 // start preview mode, must call setPreviewDisplay first 133 status_t startPreview(); 134 135 // stop preview mode 136 void stopPreview(); 137 138 // get preview state 139 bool previewEnabled(); 140 141 // start recording mode, must call setPreviewDisplay first 142 status_t startRecording(); 143 144 // stop recording mode 145 void stopRecording(); 146 147 // get recording state 148 bool recordingEnabled(); 149 150 // release a recording frame 151 void releaseRecordingFrame(const sp<IMemory>& mem); 152 153 // autoFocus - status returned from callback 154 status_t autoFocus(); 155 156 // cancel auto focus 157 status_t cancelAutoFocus(); 158 159 // take a picture - picture returned from callback 160 status_t takePicture(); 161 162 // set preview/capture parameters - key/value pairs 163 status_t setParameters(const String8& params); 164 165 // get preview/capture parameters - key/value pairs 166 String8 getParameters() const; 167 168 // send command to camera driver 169 status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2); 170 171 void setListener(const sp<CameraListener>& listener); 172 void setPreviewCallbackFlags(int preview_callback_flag); 173 174 // ICameraClient interface 175 virtual void notifyCallback(int32_t msgType, int32_t ext, int32_t ext2); 176 virtual void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr); 177 virtual void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr); 178 179 sp<ICamera> remote(); 180 181private: 182 Camera(); 183 Camera(const Camera&); 184 Camera& operator=(const Camera); 185 virtual void binderDied(const wp<IBinder>& who); 186 187 class DeathNotifier: public IBinder::DeathRecipient 188 { 189 public: 190 DeathNotifier() { 191 } 192 193 virtual void binderDied(const wp<IBinder>& who); 194 }; 195 196 static sp<DeathNotifier> mDeathNotifier; 197 198 // helper function to obtain camera service handle 199 static const sp<ICameraService>& getCameraService(); 200 201 sp<ICamera> mCamera; 202 status_t mStatus; 203 204 sp<CameraListener> mListener; 205 206 friend class DeathNotifier; 207 208 static Mutex mLock; 209 static sp<ICameraService> mCameraService; 210 211}; 212 213}; // namespace android 214 215#endif 216