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
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
|
/*
* Copyright (C) 2012 The Android Open Source Project
*
* 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_CAMERA2CLIENT_H
#define ANDROID_SERVERS_CAMERA_CAMERA2CLIENT_H
#include "Camera2Device.h"
#include "CameraService.h"
#include "camera/CameraParameters.h"
#include <binder/MemoryBase.h>
#include <binder/MemoryHeapBase.h>
#include <gui/CpuConsumer.h>
#include "MediaConsumer.h"
namespace android {
/**
* Implements the android.hardware.camera API on top of
* camera device HAL version 2.
*/
class Camera2Client : public CameraService::Client
{
public:
// ICamera interface (see ICamera for details)
virtual void disconnect();
virtual status_t connect(const sp<ICameraClient>& client);
virtual status_t lock();
virtual status_t unlock();
virtual status_t setPreviewDisplay(const sp<Surface>& surface);
virtual status_t setPreviewTexture(
const sp<ISurfaceTexture>& surfaceTexture);
virtual void setPreviewCallbackFlag(int flag);
virtual status_t startPreview();
virtual void stopPreview();
virtual bool previewEnabled();
virtual status_t storeMetaDataInBuffers(bool enabled);
virtual status_t startRecording();
virtual void stopRecording();
virtual bool recordingEnabled();
virtual void releaseRecordingFrame(const sp<IMemory>& mem);
virtual status_t autoFocus();
virtual status_t cancelAutoFocus();
virtual status_t takePicture(int msgType);
virtual status_t setParameters(const String8& params);
virtual String8 getParameters() const;
virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
// Interface used by CameraService
Camera2Client(const sp<CameraService>& cameraService,
const sp<ICameraClient>& cameraClient,
int cameraId,
int cameraFacing,
int clientPid);
~Camera2Client();
status_t initialize(camera_module_t *module);
virtual status_t dump(int fd, const Vector<String16>& args);
private:
enum State {
DISCONNECTED,
STOPPED,
WAITING_FOR_PREVIEW_WINDOW,
PREVIEW,
RECORD,
STILL_CAPTURE,
VIDEO_SNAPSHOT
} mState;
static const char *getStateName(State state);
/** ICamera interface-related private members */
// Mutex that must be locked by methods implementing the ICamera interface.
// Ensures serialization between incoming ICamera calls
mutable Mutex mICameraLock;
// The following must be called with mICameraLock already locked
status_t setPreviewWindowLocked(const sp<IBinder>& binder,
sp<ANativeWindow> window);
void stopPreviewLocked();
status_t startPreviewLocked();
// Current camera state; this is the contents of the CameraParameters object
// in a more-efficient format. The enum values are mostly based off the
// corresponding camera2 enums, not the camera1 strings. A few are defined
// here if they don't cleanly map to camera2 values.
struct Parameters {
int previewWidth, previewHeight;
int32_t previewFpsRange[2];
int previewFps; // deprecated, here only for tracking changes
int previewFormat;
int previewTransform; // set by CAMERA_CMD_SET_DISPLAY_ORIENTATION
int pictureWidth, pictureHeight;
int32_t jpegThumbSize[2];
int32_t jpegQuality, jpegThumbQuality;
int32_t jpegRotation;
bool gpsEnabled;
double gpsCoordinates[3];
int64_t gpsTimestamp;
String8 gpsProcessingMethod;
int wbMode;
int effectMode;
int antibandingMode;
int sceneMode;
enum flashMode_t {
FLASH_MODE_OFF = 0,
FLASH_MODE_AUTO,
FLASH_MODE_ON,
FLASH_MODE_TORCH,
FLASH_MODE_RED_EYE = ANDROID_CONTROL_AE_ON_AUTO_FLASH_REDEYE,
FLASH_MODE_INVALID = -1
} flashMode;
enum focusMode_t {
FOCUS_MODE_AUTO = ANDROID_CONTROL_AF_AUTO,
FOCUS_MODE_MACRO = ANDROID_CONTROL_AF_MACRO,
FOCUS_MODE_CONTINUOUS_VIDEO = ANDROID_CONTROL_AF_CONTINUOUS_VIDEO,
FOCUS_MODE_CONTINUOUS_PICTURE =
ANDROID_CONTROL_AF_CONTINUOUS_PICTURE,
FOCUS_MODE_EDOF = ANDROID_CONTROL_AF_EDOF,
FOCUS_MODE_INFINITY,
FOCUS_MODE_FIXED,
FOCUS_MODE_INVALID = -1
} focusMode;
struct Area {
int left, top, right, bottom;
int weight;
Area() {}
Area(int left, int top, int right, int bottom, int weight):
left(left), top(top), right(right), bottom(bottom),
weight(weight) {}
};
Vector<Area> focusingAreas;
int32_t exposureCompensation;
bool autoExposureLock;
bool autoWhiteBalanceLock;
Vector<Area> meteringAreas;
int zoom;
int videoWidth, videoHeight;
bool recordingHint;
bool videoStabilization;
bool storeMetadataInBuffers;
String8 paramsFlattened;
};
class LockedParameters {
public:
class Key {
public:
Key(LockedParameters &p):
mParameters(p.mParameters),
mLockedParameters(p) {
mLockedParameters.mLock.lock();
}
~Key() {
mLockedParameters.mLock.unlock();
}
Parameters &mParameters;
private:
// Disallow copying, default construction
Key();
Key(const Key &);
Key &operator=(const Key &);
LockedParameters &mLockedParameters;
};
class ReadKey {
public:
ReadKey(const LockedParameters &p):
mParameters(p.mParameters),
mLockedParameters(p) {
mLockedParameters.mLock.lock();
}
~ReadKey() {
mLockedParameters.mLock.unlock();
}
const Parameters &mParameters;
private:
// Disallow copying, default construction
ReadKey();
ReadKey(const ReadKey &);
ReadKey &operator=(const ReadKey &);
const LockedParameters &mLockedParameters;
};
// Only use for dumping or other debugging
const Parameters &unsafeUnlock() {
return mParameters;
}
private:
Parameters mParameters;
mutable Mutex mLock;
} mParameters;
/** Camera device-related private members */
class Camera2Heap;
// Number of zoom steps to simulate
static const unsigned int NUM_ZOOM_STEPS = 10;
// Used with stream IDs
static const int NO_STREAM = -1;
/* Preview related members */
int mPreviewStreamId;
camera_metadata_t *mPreviewRequest;
sp<IBinder> mPreviewSurface;
sp<ANativeWindow> mPreviewWindow;
status_t updatePreviewRequest(const Parameters ¶ms);
status_t updatePreviewStream(const Parameters ¶ms);
/* Still image capture related members */
int mCaptureStreamId;
sp<CpuConsumer> mCaptureConsumer;
sp<ANativeWindow> mCaptureWindow;
// Simple listener that forwards frame available notifications from
// a CPU consumer to the capture notification
class CaptureWaiter: public CpuConsumer::FrameAvailableListener {
public:
CaptureWaiter(Camera2Client *parent) : mParent(parent) {}
void onFrameAvailable() { mParent->onCaptureAvailable(); }
private:
Camera2Client *mParent;
};
sp<CaptureWaiter> mCaptureWaiter;
camera_metadata_t *mCaptureRequest;
sp<Camera2Heap> mCaptureHeap;
// Handle captured image buffers
void onCaptureAvailable();
status_t updateCaptureRequest(const Parameters ¶ms);
status_t updateCaptureStream(const Parameters ¶ms);
/* Recording related members */
int mRecordingStreamId;
sp<MediaConsumer> mRecordingConsumer;
sp<ANativeWindow> mRecordingWindow;
// Simple listener that forwards frame available notifications from
// a CPU consumer to the recording notification
class RecordingWaiter: public MediaConsumer::FrameAvailableListener {
public:
RecordingWaiter(Camera2Client *parent) : mParent(parent) {}
void onFrameAvailable() { mParent->onRecordingFrameAvailable(); }
private:
Camera2Client *mParent;
};
sp<RecordingWaiter> mRecordingWaiter;
camera_metadata_t *mRecordingRequest;
sp<Camera2Heap> mRecordingHeap;
// TODO: This needs to be queried from somewhere, or the BufferQueue needs
// to be passed all the way to stagefright. Right now, set to a large number
// to avoid starvation of the video encoders.
static const size_t kRecordingHeapCount = 8;
size_t mRecordingHeapHead, mRecordingHeapFree;
// Handle new recording image buffers
void onRecordingFrameAvailable();
status_t updateRecordingRequest(const Parameters ¶ms);
status_t updateRecordingStream(const Parameters ¶ms);
/** Camera2Device instance wrapping HAL2 entry */
sp<Camera2Device> mDevice;
/** Utility members */
// Verify that caller is the owner of the camera
status_t checkPid(const char *checkLocation) const;
// Utility class for managing a set of IMemory blocks
class Camera2Heap : public RefBase {
public:
Camera2Heap(size_t buf_size, uint_t num_buffers = 1,
const char *name = NULL) :
mBufSize(buf_size),
mNumBufs(num_buffers) {
mHeap = new MemoryHeapBase(buf_size * num_buffers, 0, name);
mBuffers = new sp<MemoryBase>[mNumBufs];
for (uint_t i = 0; i < mNumBufs; i++)
mBuffers[i] = new MemoryBase(mHeap,
i * mBufSize,
mBufSize);
}
virtual ~Camera2Heap()
{
delete [] mBuffers;
}
size_t mBufSize;
uint_t mNumBufs;
sp<MemoryHeapBase> mHeap;
sp<MemoryBase> *mBuffers;
};
// Get values for static camera info entry. min/maxCount are used for error
// checking the number of values in the entry. 0 for max/minCount means to
// do no bounds check in that direction. In case of error, the entry data
// pointer is null and the count is 0.
camera_metadata_entry_t staticInfo(uint32_t tag,
size_t minCount=0, size_t maxCount=0);
// Convert static camera info from a camera2 device to the
// old API parameter map.
status_t buildDefaultParameters();
// Update parameters all requests use, based on mParameters
status_t updateRequestCommon(camera_metadata_t *request, const Parameters ¶ms);
// Update specific metadata entry with new values. Adds entry if it does not
// exist, which will invalidate sorting
static status_t updateEntry(camera_metadata_t *buffer,
uint32_t tag, const void *data, size_t data_count);
// Remove metadata entry. Will invalidate sorting. If entry does not exist,
// does nothing.
static status_t deleteEntry(camera_metadata_t *buffer,
uint32_t tag);
// Convert camera1 preview format string to camera2 enum
static int formatStringToEnum(const char *format);
static const char *formatEnumToString(int format);
static int wbModeStringToEnum(const char *wbMode);
static int effectModeStringToEnum(const char *effectMode);
static int abModeStringToEnum(const char *abMode);
static int sceneModeStringToEnum(const char *sceneMode);
static Parameters::flashMode_t flashModeStringToEnum(const char *flashMode);
static Parameters::focusMode_t focusModeStringToEnum(const char *focusMode);
static status_t parseAreas(const char *areasCStr,
Vector<Parameters::Area> *areas);
static status_t validateAreas(const Vector<Parameters::Area> &areas,
size_t maxRegions);
static bool boolFromString(const char *boolStr);
// Map from camera orientation + facing to gralloc transform enum
static int degToTransform(int degrees, bool mirror);
};
}; // namespace android
#endif
|