1 /*
2 * Copyright (C) 2012 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 #include <cstdlib>
18 #include <stdio.h>
19 #include <hardware/camera3.h>
20 #include <sync/sync.h>
21 #include <system/camera_metadata.h>
22 #include <system/graphics.h>
23 #include <utils/Mutex.h>
24 #include "CameraHAL.h"
25 #include "Metadata.h"
26 #include "Stream.h"
27
28 //#define LOG_NDEBUG 0
29 #define LOG_TAG "Camera"
30 #include <cutils/log.h>
31
32 #define ATRACE_TAG (ATRACE_TAG_CAMERA | ATRACE_TAG_HAL)
33 #include <utils/Trace.h>
34
35 #include "Camera.h"
36
37 #define CAMERA_SYNC_TIMEOUT 5000 // in msecs
38
39 namespace default_camera_hal {
40
41 extern "C" {
42 // Shim passed to the framework to close an opened device.
close_device(hw_device_t * dev)43 static int close_device(hw_device_t* dev)
44 {
45 camera3_device_t* cam_dev = reinterpret_cast<camera3_device_t*>(dev);
46 Camera* cam = static_cast<Camera*>(cam_dev->priv);
47 return cam->close();
48 }
49 } // extern "C"
50
Camera(int id)51 Camera::Camera(int id)
52 : mId(id),
53 mStaticInfo(NULL),
54 mBusy(false),
55 mCallbackOps(NULL),
56 mStreams(NULL),
57 mNumStreams(0),
58 mSettings(NULL)
59 {
60 memset(&mTemplates, 0, sizeof(mTemplates));
61 memset(&mDevice, 0, sizeof(mDevice));
62 mDevice.common.tag = HARDWARE_DEVICE_TAG;
63 mDevice.common.version = CAMERA_DEVICE_API_VERSION_3_0;
64 mDevice.common.close = close_device;
65 mDevice.ops = const_cast<camera3_device_ops_t*>(&sOps);
66 mDevice.priv = this;
67 }
68
~Camera()69 Camera::~Camera()
70 {
71 if (mStaticInfo != NULL) {
72 free_camera_metadata(mStaticInfo);
73 }
74 }
75
open(const hw_module_t * module,hw_device_t ** device)76 int Camera::open(const hw_module_t *module, hw_device_t **device)
77 {
78 ALOGI("%s:%d: Opening camera device", __func__, mId);
79 ATRACE_CALL();
80 android::Mutex::Autolock al(mDeviceLock);
81
82 if (mBusy) {
83 ALOGE("%s:%d: Error! Camera device already opened", __func__, mId);
84 return -EBUSY;
85 }
86
87 // TODO: open camera dev nodes, etc
88 mBusy = true;
89 mDevice.common.module = const_cast<hw_module_t*>(module);
90 *device = &mDevice.common;
91 return 0;
92 }
93
getInfo(struct camera_info * info)94 int Camera::getInfo(struct camera_info *info)
95 {
96 android::Mutex::Autolock al(mStaticInfoLock);
97
98 info->facing = CAMERA_FACING_FRONT;
99 info->orientation = 0;
100 info->device_version = mDevice.common.version;
101 if (mStaticInfo == NULL) {
102 mStaticInfo = initStaticInfo();
103 }
104 info->static_camera_characteristics = mStaticInfo;
105 return 0;
106 }
107
close()108 int Camera::close()
109 {
110 ALOGI("%s:%d: Closing camera device", __func__, mId);
111 ATRACE_CALL();
112 android::Mutex::Autolock al(mDeviceLock);
113
114 if (!mBusy) {
115 ALOGE("%s:%d: Error! Camera device not open", __func__, mId);
116 return -EINVAL;
117 }
118
119 // TODO: close camera dev nodes, etc
120 mBusy = false;
121 return 0;
122 }
123
initialize(const camera3_callback_ops_t * callback_ops)124 int Camera::initialize(const camera3_callback_ops_t *callback_ops)
125 {
126 int res;
127
128 ALOGV("%s:%d: callback_ops=%p", __func__, mId, callback_ops);
129 mCallbackOps = callback_ops;
130 // per-device specific initialization
131 res = initDevice();
132 if (res != 0) {
133 ALOGE("%s:%d: Failed to initialize device!", __func__, mId);
134 return res;
135 }
136 return 0;
137 }
138
configureStreams(camera3_stream_configuration_t * stream_config)139 int Camera::configureStreams(camera3_stream_configuration_t *stream_config)
140 {
141 camera3_stream_t *astream;
142 Stream **newStreams = NULL;
143
144 ALOGV("%s:%d: stream_config=%p", __func__, mId, stream_config);
145 ATRACE_CALL();
146 android::Mutex::Autolock al(mDeviceLock);
147
148 if (stream_config == NULL) {
149 ALOGE("%s:%d: NULL stream configuration array", __func__, mId);
150 return -EINVAL;
151 }
152 if (stream_config->num_streams == 0) {
153 ALOGE("%s:%d: Empty stream configuration array", __func__, mId);
154 return -EINVAL;
155 }
156
157 // Create new stream array
158 newStreams = new Stream*[stream_config->num_streams];
159 ALOGV("%s:%d: Number of Streams: %d", __func__, mId,
160 stream_config->num_streams);
161
162 // Mark all current streams unused for now
163 for (int i = 0; i < mNumStreams; i++)
164 mStreams[i]->mReuse = false;
165 // Fill new stream array with reused streams and new streams
166 for (unsigned int i = 0; i < stream_config->num_streams; i++) {
167 astream = stream_config->streams[i];
168 if (astream->max_buffers > 0) {
169 ALOGV("%s:%d: Reusing stream %d", __func__, mId, i);
170 newStreams[i] = reuseStream(astream);
171 } else {
172 ALOGV("%s:%d: Creating new stream %d", __func__, mId, i);
173 newStreams[i] = new Stream(mId, astream);
174 }
175
176 if (newStreams[i] == NULL) {
177 ALOGE("%s:%d: Error processing stream %d", __func__, mId, i);
178 goto err_out;
179 }
180 astream->priv = newStreams[i];
181 }
182
183 // Verify the set of streams in aggregate
184 if (!isValidStreamSet(newStreams, stream_config->num_streams)) {
185 ALOGE("%s:%d: Invalid stream set", __func__, mId);
186 goto err_out;
187 }
188
189 // Set up all streams (calculate usage/max_buffers for each)
190 setupStreams(newStreams, stream_config->num_streams);
191
192 // Destroy all old streams and replace stream array with new one
193 destroyStreams(mStreams, mNumStreams);
194 mStreams = newStreams;
195 mNumStreams = stream_config->num_streams;
196
197 // Clear out last seen settings metadata
198 setSettings(NULL);
199 return 0;
200
201 err_out:
202 // Clean up temporary streams, preserve existing mStreams/mNumStreams
203 destroyStreams(newStreams, stream_config->num_streams);
204 return -EINVAL;
205 }
206
destroyStreams(Stream ** streams,int count)207 void Camera::destroyStreams(Stream **streams, int count)
208 {
209 if (streams == NULL)
210 return;
211 for (int i = 0; i < count; i++) {
212 // Only destroy streams that weren't reused
213 if (streams[i] != NULL && !streams[i]->mReuse)
214 delete streams[i];
215 }
216 delete [] streams;
217 }
218
reuseStream(camera3_stream_t * astream)219 Stream *Camera::reuseStream(camera3_stream_t *astream)
220 {
221 Stream *priv = reinterpret_cast<Stream*>(astream->priv);
222 // Verify the re-used stream's parameters match
223 if (!priv->isValidReuseStream(mId, astream)) {
224 ALOGE("%s:%d: Mismatched parameter in reused stream", __func__, mId);
225 return NULL;
226 }
227 // Mark stream to be reused
228 priv->mReuse = true;
229 return priv;
230 }
231
isValidStreamSet(Stream ** streams,int count)232 bool Camera::isValidStreamSet(Stream **streams, int count)
233 {
234 int inputs = 0;
235 int outputs = 0;
236
237 if (streams == NULL) {
238 ALOGE("%s:%d: NULL stream configuration streams", __func__, mId);
239 return false;
240 }
241 if (count == 0) {
242 ALOGE("%s:%d: Zero count stream configuration streams", __func__, mId);
243 return false;
244 }
245 // Validate there is at most one input stream and at least one output stream
246 for (int i = 0; i < count; i++) {
247 // A stream may be both input and output (bidirectional)
248 if (streams[i]->isInputType())
249 inputs++;
250 if (streams[i]->isOutputType())
251 outputs++;
252 }
253 ALOGV("%s:%d: Configuring %d output streams and %d input streams",
254 __func__, mId, outputs, inputs);
255 if (outputs < 1) {
256 ALOGE("%s:%d: Stream config must have >= 1 output", __func__, mId);
257 return false;
258 }
259 if (inputs > 1) {
260 ALOGE("%s:%d: Stream config must have <= 1 input", __func__, mId);
261 return false;
262 }
263 // TODO: check for correct number of Bayer/YUV/JPEG/Encoder streams
264 return true;
265 }
266
setupStreams(Stream ** streams,int count)267 void Camera::setupStreams(Stream **streams, int count)
268 {
269 /*
270 * This is where the HAL has to decide internally how to handle all of the
271 * streams, and then produce usage and max_buffer values for each stream.
272 * Note, the stream array has been checked before this point for ALL invalid
273 * conditions, so it must find a successful configuration for this stream
274 * array. The HAL may not return an error from this point.
275 *
276 * In this demo HAL, we just set all streams to be the same dummy values;
277 * real implementations will want to avoid USAGE_SW_{READ|WRITE}_OFTEN.
278 */
279 for (int i = 0; i < count; i++) {
280 uint32_t usage = 0;
281
282 if (streams[i]->isOutputType())
283 usage |= GRALLOC_USAGE_SW_WRITE_OFTEN |
284 GRALLOC_USAGE_HW_CAMERA_WRITE;
285 if (streams[i]->isInputType())
286 usage |= GRALLOC_USAGE_SW_READ_OFTEN |
287 GRALLOC_USAGE_HW_CAMERA_READ;
288
289 streams[i]->setUsage(usage);
290 streams[i]->setMaxBuffers(1);
291 }
292 }
293
registerStreamBuffers(const camera3_stream_buffer_set_t * buf_set)294 int Camera::registerStreamBuffers(const camera3_stream_buffer_set_t *buf_set)
295 {
296 ALOGV("%s:%d: buffer_set=%p", __func__, mId, buf_set);
297 if (buf_set == NULL) {
298 ALOGE("%s:%d: NULL buffer set", __func__, mId);
299 return -EINVAL;
300 }
301 if (buf_set->stream == NULL) {
302 ALOGE("%s:%d: NULL stream handle", __func__, mId);
303 return -EINVAL;
304 }
305 Stream *stream = reinterpret_cast<Stream*>(buf_set->stream->priv);
306 return stream->registerBuffers(buf_set);
307 }
308
isValidTemplateType(int type)309 bool Camera::isValidTemplateType(int type)
310 {
311 return type < 1 || type >= CAMERA3_TEMPLATE_COUNT;
312 }
313
constructDefaultRequestSettings(int type)314 const camera_metadata_t* Camera::constructDefaultRequestSettings(int type)
315 {
316 ALOGV("%s:%d: type=%d", __func__, mId, type);
317
318 if (!isValidTemplateType(type)) {
319 ALOGE("%s:%d: Invalid template request type: %d", __func__, mId, type);
320 return NULL;
321 }
322 return mTemplates[type];
323 }
324
processCaptureRequest(camera3_capture_request_t * request)325 int Camera::processCaptureRequest(camera3_capture_request_t *request)
326 {
327 camera3_capture_result result;
328
329 ALOGV("%s:%d: request=%p", __func__, mId, request);
330 ATRACE_CALL();
331
332 if (request == NULL) {
333 ALOGE("%s:%d: NULL request recieved", __func__, mId);
334 return -EINVAL;
335 }
336
337 ALOGV("%s:%d: Request Frame:%d Settings:%p", __func__, mId,
338 request->frame_number, request->settings);
339
340 // NULL indicates use last settings
341 if (request->settings == NULL) {
342 if (mSettings == NULL) {
343 ALOGE("%s:%d: NULL settings without previous set Frame:%d Req:%p",
344 __func__, mId, request->frame_number, request);
345 return -EINVAL;
346 }
347 } else {
348 setSettings(request->settings);
349 }
350
351 if (request->input_buffer != NULL) {
352 ALOGV("%s:%d: Reprocessing input buffer %p", __func__, mId,
353 request->input_buffer);
354
355 if (!isValidReprocessSettings(request->settings)) {
356 ALOGE("%s:%d: Invalid settings for reprocess request: %p",
357 __func__, mId, request->settings);
358 return -EINVAL;
359 }
360 } else {
361 ALOGV("%s:%d: Capturing new frame.", __func__, mId);
362
363 if (!isValidCaptureSettings(request->settings)) {
364 ALOGE("%s:%d: Invalid settings for capture request: %p",
365 __func__, mId, request->settings);
366 return -EINVAL;
367 }
368 }
369
370 if (request->num_output_buffers <= 0) {
371 ALOGE("%s:%d: Invalid number of output buffers: %d", __func__, mId,
372 request->num_output_buffers);
373 return -EINVAL;
374 }
375 result.num_output_buffers = request->num_output_buffers;
376 result.output_buffers = new camera3_stream_buffer_t[result.num_output_buffers];
377 for (unsigned int i = 0; i < request->num_output_buffers; i++) {
378 int res = processCaptureBuffer(&request->output_buffers[i],
379 const_cast<camera3_stream_buffer_t*>(&result.output_buffers[i]));
380 if (res)
381 goto err_out;
382 }
383
384 result.frame_number = request->frame_number;
385 // TODO: return actual captured/reprocessed settings
386 result.result = request->settings;
387 // TODO: asynchronously return results
388 notifyShutter(request->frame_number, 0);
389 mCallbackOps->process_capture_result(mCallbackOps, &result);
390
391 return 0;
392
393 err_out:
394 delete [] result.output_buffers;
395 // TODO: this should probably be a total device failure; transient for now
396 return -EINVAL;
397 }
398
setSettings(const camera_metadata_t * new_settings)399 void Camera::setSettings(const camera_metadata_t *new_settings)
400 {
401 if (mSettings != NULL) {
402 free_camera_metadata(mSettings);
403 mSettings = NULL;
404 }
405
406 if (new_settings != NULL)
407 mSettings = clone_camera_metadata(new_settings);
408 }
409
isValidReprocessSettings(const camera_metadata_t *)410 bool Camera::isValidReprocessSettings(const camera_metadata_t* /*settings*/)
411 {
412 // TODO: reject settings that cannot be reprocessed
413 // input buffers unimplemented, use this to reject reprocessing requests
414 ALOGE("%s:%d: Input buffer reprocessing not implemented", __func__, mId);
415 return false;
416 }
417
processCaptureBuffer(const camera3_stream_buffer_t * in,camera3_stream_buffer_t * out)418 int Camera::processCaptureBuffer(const camera3_stream_buffer_t *in,
419 camera3_stream_buffer_t *out)
420 {
421 if (in->acquire_fence != -1) {
422 int res = sync_wait(in->acquire_fence, CAMERA_SYNC_TIMEOUT);
423 if (res == -ETIME) {
424 ALOGE("%s:%d: Timeout waiting on buffer acquire fence",
425 __func__, mId);
426 return res;
427 } else if (res) {
428 ALOGE("%s:%d: Error waiting on buffer acquire fence: %s(%d)",
429 __func__, mId, strerror(-res), res);
430 return res;
431 }
432 }
433
434 out->stream = in->stream;
435 out->buffer = in->buffer;
436 out->status = CAMERA3_BUFFER_STATUS_OK;
437 // TODO: use driver-backed release fences
438 out->acquire_fence = -1;
439 out->release_fence = -1;
440
441 // TODO: lock and software-paint buffer
442 return 0;
443 }
444
notifyShutter(uint32_t frame_number,uint64_t timestamp)445 void Camera::notifyShutter(uint32_t frame_number, uint64_t timestamp)
446 {
447 int res;
448 struct timespec ts;
449
450 // If timestamp is 0, get timestamp from right now instead
451 if (timestamp == 0) {
452 ALOGW("%s:%d: No timestamp provided, using CLOCK_BOOTTIME",
453 __func__, mId);
454 res = clock_gettime(CLOCK_BOOTTIME, &ts);
455 if (res == 0) {
456 timestamp = ts.tv_sec * 1000000000ULL + ts.tv_nsec;
457 } else {
458 ALOGE("%s:%d: No timestamp and failed to get CLOCK_BOOTTIME %s(%d)",
459 __func__, mId, strerror(errno), errno);
460 }
461 }
462 camera3_notify_msg_t m;
463 memset(&m, 0, sizeof(m));
464 m.type = CAMERA3_MSG_SHUTTER;
465 m.message.shutter.frame_number = frame_number;
466 m.message.shutter.timestamp = timestamp;
467 mCallbackOps->notify(mCallbackOps, &m);
468 }
469
dump(int fd)470 void Camera::dump(int fd)
471 {
472 ALOGV("%s:%d: Dumping to fd %d", __func__, mId, fd);
473 ATRACE_CALL();
474 android::Mutex::Autolock al(mDeviceLock);
475
476 dprintf(fd, "Camera ID: %d (Busy: %d)\n", mId, mBusy);
477
478 // TODO: dump all settings
479 dprintf(fd, "Most Recent Settings: (%p)\n", mSettings);
480
481 dprintf(fd, "Number of streams: %d\n", mNumStreams);
482 for (int i = 0; i < mNumStreams; i++) {
483 dprintf(fd, "Stream %d/%d:\n", i, mNumStreams);
484 mStreams[i]->dump(fd);
485 }
486 }
487
templateToString(int type)488 const char* Camera::templateToString(int type)
489 {
490 switch (type) {
491 case CAMERA3_TEMPLATE_PREVIEW:
492 return "CAMERA3_TEMPLATE_PREVIEW";
493 case CAMERA3_TEMPLATE_STILL_CAPTURE:
494 return "CAMERA3_TEMPLATE_STILL_CAPTURE";
495 case CAMERA3_TEMPLATE_VIDEO_RECORD:
496 return "CAMERA3_TEMPLATE_VIDEO_RECORD";
497 case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT:
498 return "CAMERA3_TEMPLATE_VIDEO_SNAPSHOT";
499 case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG:
500 return "CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG";
501 }
502 // TODO: support vendor templates
503 return "Invalid template type!";
504 }
505
setTemplate(int type,camera_metadata_t * settings)506 int Camera::setTemplate(int type, camera_metadata_t *settings)
507 {
508 android::Mutex::Autolock al(mDeviceLock);
509
510 if (!isValidTemplateType(type)) {
511 ALOGE("%s:%d: Invalid template request type: %d", __func__, mId, type);
512 return -EINVAL;
513 }
514
515 if (mTemplates[type] != NULL) {
516 ALOGE("%s:%d: Setting already constructed template type %s(%d)",
517 __func__, mId, templateToString(type), type);
518 return -EINVAL;
519 }
520
521 // Make a durable copy of the underlying metadata
522 mTemplates[type] = clone_camera_metadata(settings);
523 if (mTemplates[type] == NULL) {
524 ALOGE("%s:%d: Failed to clone metadata %p for template type %s(%d)",
525 __func__, mId, settings, templateToString(type), type);
526 return -EINVAL;
527 }
528 return 0;
529 }
530
531 extern "C" {
532 // Get handle to camera from device priv data
camdev_to_camera(const camera3_device_t * dev)533 static Camera *camdev_to_camera(const camera3_device_t *dev)
534 {
535 return reinterpret_cast<Camera*>(dev->priv);
536 }
537
initialize(const camera3_device_t * dev,const camera3_callback_ops_t * callback_ops)538 static int initialize(const camera3_device_t *dev,
539 const camera3_callback_ops_t *callback_ops)
540 {
541 return camdev_to_camera(dev)->initialize(callback_ops);
542 }
543
configure_streams(const camera3_device_t * dev,camera3_stream_configuration_t * stream_list)544 static int configure_streams(const camera3_device_t *dev,
545 camera3_stream_configuration_t *stream_list)
546 {
547 return camdev_to_camera(dev)->configureStreams(stream_list);
548 }
549
register_stream_buffers(const camera3_device_t * dev,const camera3_stream_buffer_set_t * buffer_set)550 static int register_stream_buffers(const camera3_device_t *dev,
551 const camera3_stream_buffer_set_t *buffer_set)
552 {
553 return camdev_to_camera(dev)->registerStreamBuffers(buffer_set);
554 }
555
construct_default_request_settings(const camera3_device_t * dev,int type)556 static const camera_metadata_t *construct_default_request_settings(
557 const camera3_device_t *dev, int type)
558 {
559 return camdev_to_camera(dev)->constructDefaultRequestSettings(type);
560 }
561
process_capture_request(const camera3_device_t * dev,camera3_capture_request_t * request)562 static int process_capture_request(const camera3_device_t *dev,
563 camera3_capture_request_t *request)
564 {
565 return camdev_to_camera(dev)->processCaptureRequest(request);
566 }
567
dump(const camera3_device_t * dev,int fd)568 static void dump(const camera3_device_t *dev, int fd)
569 {
570 camdev_to_camera(dev)->dump(fd);
571 }
572
flush(const camera3_device_t *)573 static int flush(const camera3_device_t*)
574 {
575 ALOGE("%s: unimplemented.", __func__);
576 return -1;
577 }
578
579 } // extern "C"
580
581 const camera3_device_ops_t Camera::sOps = {
582 .initialize = default_camera_hal::initialize,
583 .configure_streams = default_camera_hal::configure_streams,
584 .register_stream_buffers = default_camera_hal::register_stream_buffers,
585 .construct_default_request_settings
586 = default_camera_hal::construct_default_request_settings,
587 .process_capture_request = default_camera_hal::process_capture_request,
588 .get_metadata_vendor_tag_ops = NULL,
589 .dump = default_camera_hal::dump,
590 .flush = default_camera_hal::flush,
591 .reserved = {0},
592 };
593
594 } // namespace default_camera_hal
595