1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
|
/*
**
** Copyright (C) 2008, The Android Open Source Project
** Copyright (C) 2008 HTC Inc.
**
** Licensed under the Apache License, Version 2.0 (the "License");
** you may not use this file except in compliance with the License.
** You may obtain a copy of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** Unless required by applicable law or agreed to in writing, software
** distributed under the License is distributed on an "AS IS" BASIS,
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
** See the License for the specific language governing permissions and
** limitations under the License.
*/
#ifndef ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
#define ANDROID_SERVERS_CAMERA_CAMERASERVICE_H
#include <ui/ICameraService.h>
#include <ui/CameraHardwareInterface.h>
#include <ui/Camera.h>
class android::MemoryHeapBase;
namespace android {
// ----------------------------------------------------------------------------
#define LIKELY( exp ) (__builtin_expect( (exp) != 0, true ))
#define UNLIKELY( exp ) (__builtin_expect( (exp) != 0, false ))
// When enabled, this feature allows you to send an event to the CameraService
// so that you can cause all references to the heap object gWeakHeap, defined
// below, to be printed. You will also need to set DEBUG_REFS=1 and
// DEBUG_REFS_ENABLED_BY_DEFAULT=0 in libutils/RefBase.cpp. You just have to
// set gWeakHeap to the appropriate heap you want to track.
#define DEBUG_HEAP_LEAKS 0
// ----------------------------------------------------------------------------
class CameraService : public BnCameraService
{
class Client;
public:
static void instantiate();
// ICameraService interface
virtual sp<ICamera> connect(const sp<ICameraClient>& cameraClient);
virtual status_t dump(int fd, const Vector<String16>& args);
void removeClient(const sp<ICameraClient>& cameraClient);
#if DEBUG_HEAP_LEAKS
virtual status_t onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags);
#endif
private:
// ----------------------------------------------------------------------------
class Client : public BnCamera {
public:
virtual void disconnect();
// connect new client with existing camera remote
virtual status_t connect(const sp<ICameraClient>& client);
// prevent other processes from using this ICamera interface
virtual status_t lock();
// allow other processes to use this ICamera interface
virtual status_t unlock();
// pass the buffered ISurface to the camera service
virtual status_t setPreviewDisplay(const sp<ISurface>& surface);
// set the preview callback flag to affect how the received frames from
// preview are handled.
virtual void setPreviewCallbackFlag(int callback_flag);
// start preview mode, must call setPreviewDisplay first
virtual status_t startPreview();
// stop preview mode
virtual void stopPreview();
// get preview state
virtual bool previewEnabled();
// start recording mode
virtual status_t startRecording();
// stop recording mode
virtual void stopRecording();
// get recording state
virtual bool recordingEnabled();
// release a recording frame
virtual void releaseRecordingFrame(const sp<IMemory>& mem);
// auto focus
virtual status_t autoFocus();
// take a picture - returns an IMemory (ref-counted mmap)
virtual status_t takePicture();
// set preview/capture parameters - key/value pairs
virtual status_t setParameters(const String8& params);
// get preview/capture parameters - key/value pairs
virtual String8 getParameters() const;
// our client...
const sp<ICameraClient>& getCameraClient() const { return mCameraClient; }
private:
friend class CameraService;
Client(const sp<CameraService>& cameraService,
const sp<ICameraClient>& cameraClient,
pid_t clientPid);
Client();
virtual ~Client();
status_t checkPid();
static void recordingCallback(const sp<IMemory>& mem, void* user);
static void previewCallback(const sp<IMemory>& mem, void* user);
static void shutterCallback(void *user);
static void yuvPictureCallback(const sp<IMemory>& mem, void* user);
static void jpegPictureCallback(const sp<IMemory>& mem, void* user);
static void autoFocusCallback(bool focused, void* user);
static sp<Client> getClientFromCookie(void* user);
void postShutter();
void postRaw(const sp<IMemory>& mem);
void postJpeg(const sp<IMemory>& mem);
void postPreviewFrame(const sp<IMemory>& mem);
void postRecordingFrame(const sp<IMemory>& frame);
void copyFrameAndPostCopiedFrame(sp<IMemoryHeap> heap, size_t offset, size_t size);
void postError(status_t error);
void postAutoFocus(bool focused);
// camera operation mode
enum camera_mode {
CAMERA_PREVIEW_MODE = 0, // frame automatically released
CAMERA_RECORDING_MODE = 1, // frame has to be explicitly released by releaseRecordingFrame()
};
status_t startCameraMode(camera_mode mode);
status_t startPreviewMode();
status_t startRecordingMode();
// Ensures atomicity among the public methods
mutable Mutex mLock;
// mSurfaceLock synchronizes access to mSurface between
// setPreviewSurface() and postPreviewFrame(). Note that among
// the public methods, all accesses to mSurface are
// syncrhonized by mLock. However, postPreviewFrame() is called
// by the CameraHardwareInterface callback, and needs to
// access mSurface. It cannot hold mLock, however, because
// stopPreview() may be holding that lock while attempting
// to stop preview, and stopPreview itself will block waiting
// for a callback from CameraHardwareInterface. If this
// happens, it will cause a deadlock.
mutable Mutex mSurfaceLock;
// mBufferLock synchronizes buffer registration between takePicture()
// and yuvPictureCallback().
mutable Mutex mBufferLock;
mutable Condition mReady;
sp<CameraService> mCameraService;
sp<ISurface> mSurface;
sp<MemoryHeapBase> mPreviewBuffer;
int mPreviewCallbackFlag;
// these are immutable once the object is created,
// they don't need to be protected by a lock
sp<ICameraClient> mCameraClient;
sp<CameraHardwareInterface> mHardware;
pid_t mClientPid;
bool mUseOverlay;
};
// ----------------------------------------------------------------------------
CameraService();
virtual ~CameraService();
mutable Mutex mLock;
wp<Client> mClient;
#if DEBUG_HEAP_LEAKS
wp<IMemoryHeap> gWeakHeap;
#endif
};
// ----------------------------------------------------------------------------
}; // namespace android
#endif
|
