blob: 0fae598ef6a9412977a190fb268e8247e2f18133 [file] [log] [blame]
Yin-Chia Yeh4717c472017-02-13 10:56:40 -08001/*
2 * Copyright (C) 2017 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#define LOG_TAG "CameraHardwareInterface"
17//#define LOG_NDEBUG 0
18
19#include <inttypes.h>
Yin-Chia Yeh06760662017-04-17 17:37:03 -070020#include <media/hardware/HardwareAPI.h> // For VideoNativeHandleMetadata
Yin-Chia Yeh4717c472017-02-13 10:56:40 -080021#include "CameraHardwareInterface.h"
22
23namespace android {
24
25using namespace hardware::camera::device::V1_0;
26using namespace hardware::camera::common::V1_0;
27using hardware::hidl_handle;
28
29CameraHardwareInterface::~CameraHardwareInterface()
30{
31 ALOGI("Destroying camera %s", mName.string());
32 if (mDevice) {
33 int rc = mDevice->common.close(&mDevice->common);
34 if (rc != OK)
35 ALOGE("Could not close camera %s: %d", mName.string(), rc);
36 }
37 if (mHidlDevice != nullptr) {
38 mHidlDevice->close();
39 mHidlDevice.clear();
40 cleanupCirculatingBuffers();
41 }
42}
43
Yin-Chia Yeh4717c472017-02-13 10:56:40 -080044status_t CameraHardwareInterface::initialize(sp<CameraProviderManager> manager) {
45 if (mDevice) {
46 ALOGE("%s: camera hardware interface has been initialized to libhardware path!",
47 __FUNCTION__);
48 return INVALID_OPERATION;
49 }
50
51 ALOGI("Opening camera %s", mName.string());
52
Steven Moreland5ff9c912017-03-09 23:13:00 -080053 status_t ret = manager->openSession(mName.string(), this, &mHidlDevice);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -080054 if (ret != OK) {
55 ALOGE("%s: openSession failed! %s (%d)", __FUNCTION__, strerror(-ret), ret);
56 }
57 return ret;
58}
59
60status_t CameraHardwareInterface::setPreviewScalingMode(int scalingMode)
61{
62 int rc = OK;
63 mPreviewScalingMode = scalingMode;
64 if (mPreviewWindow != nullptr) {
65 rc = native_window_set_scaling_mode(mPreviewWindow.get(),
66 scalingMode);
67 }
68 return rc;
69}
70
71status_t CameraHardwareInterface::setPreviewTransform(int transform) {
72 int rc = OK;
73 mPreviewTransform = transform;
74 if (mPreviewWindow != nullptr) {
75 rc = native_window_set_buffers_transform(mPreviewWindow.get(),
76 mPreviewTransform);
77 }
78 return rc;
79}
80
81/**
82 * Implementation of android::hardware::camera::device::V1_0::ICameraDeviceCallback
83 */
84hardware::Return<void> CameraHardwareInterface::notifyCallback(
85 NotifyCallbackMsg msgType, int32_t ext1, int32_t ext2) {
86 sNotifyCb((int32_t) msgType, ext1, ext2, (void*) this);
87 return hardware::Void();
88}
89
90hardware::Return<uint32_t> CameraHardwareInterface::registerMemory(
91 const hardware::hidl_handle& descriptor,
92 uint32_t bufferSize, uint32_t bufferCount) {
93 if (descriptor->numFds != 1) {
94 ALOGE("%s: camera memory descriptor has numFds %d (expect 1)",
95 __FUNCTION__, descriptor->numFds);
96 return 0;
97 }
98 if (descriptor->data[0] < 0) {
99 ALOGE("%s: camera memory descriptor has FD %d (expect >= 0)",
100 __FUNCTION__, descriptor->data[0]);
101 return 0;
102 }
103
104 camera_memory_t* mem = sGetMemory(descriptor->data[0], bufferSize, bufferCount, this);
105 sp<CameraHeapMemory> camMem(static_cast<CameraHeapMemory *>(mem->handle));
106 int memPoolId = camMem->mHeap->getHeapID();
107 if (memPoolId < 0) {
108 ALOGE("%s: CameraHeapMemory has FD %d (expect >= 0)", __FUNCTION__, memPoolId);
109 return 0;
110 }
Yin-Chia Yehb2a65612017-09-07 16:30:46 -0700111 std::lock_guard<std::mutex> lock(mHidlMemPoolMapLock);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800112 mHidlMemPoolMap.insert(std::make_pair(memPoolId, mem));
113 return memPoolId;
114}
115
116hardware::Return<void> CameraHardwareInterface::unregisterMemory(uint32_t memId) {
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700117 camera_memory_t* mem = nullptr;
118 {
119 std::lock_guard<std::mutex> lock(mHidlMemPoolMapLock);
120 if (mHidlMemPoolMap.count(memId) == 0) {
121 ALOGE("%s: memory pool ID %d not found", __FUNCTION__, memId);
122 return hardware::Void();
123 }
124 mem = mHidlMemPoolMap.at(memId);
125 mHidlMemPoolMap.erase(memId);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800126 }
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800127 sPutMemory(mem);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800128 return hardware::Void();
129}
130
131hardware::Return<void> CameraHardwareInterface::dataCallback(
132 DataCallbackMsg msgType, uint32_t data, uint32_t bufferIndex,
133 const hardware::camera::device::V1_0::CameraFrameMetadata& metadata) {
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700134 camera_memory_t* mem = nullptr;
135 {
136 std::lock_guard<std::mutex> lock(mHidlMemPoolMapLock);
137 if (mHidlMemPoolMap.count(data) == 0) {
138 ALOGE("%s: memory pool ID %d not found", __FUNCTION__, data);
139 return hardware::Void();
140 }
141 mem = mHidlMemPoolMap.at(data);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800142 }
143 camera_frame_metadata_t md;
144 md.number_of_faces = metadata.faces.size();
145 md.faces = (camera_face_t*) metadata.faces.data();
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700146 sDataCb((int32_t) msgType, mem, bufferIndex, &md, this);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800147 return hardware::Void();
148}
149
150hardware::Return<void> CameraHardwareInterface::dataCallbackTimestamp(
151 DataCallbackMsg msgType, uint32_t data,
152 uint32_t bufferIndex, int64_t timestamp) {
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700153 camera_memory_t* mem = nullptr;
154 {
155 std::lock_guard<std::mutex> lock(mHidlMemPoolMapLock);
156 if (mHidlMemPoolMap.count(data) == 0) {
157 ALOGE("%s: memory pool ID %d not found", __FUNCTION__, data);
158 return hardware::Void();
159 }
160 mem = mHidlMemPoolMap.at(data);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800161 }
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700162 sDataCbTimestamp(timestamp, (int32_t) msgType, mem, bufferIndex, this);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800163 return hardware::Void();
164}
165
166hardware::Return<void> CameraHardwareInterface::handleCallbackTimestamp(
167 DataCallbackMsg msgType, const hidl_handle& frameData, uint32_t data,
168 uint32_t bufferIndex, int64_t timestamp) {
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700169 camera_memory_t* mem = nullptr;
170 {
171 std::lock_guard<std::mutex> lock(mHidlMemPoolMapLock);
172 if (mHidlMemPoolMap.count(data) == 0) {
173 ALOGE("%s: memory pool ID %d not found", __FUNCTION__, data);
174 return hardware::Void();
175 }
176 mem = mHidlMemPoolMap.at(data);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800177 }
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700178 sp<CameraHeapMemory> heapMem(static_cast<CameraHeapMemory *>(mem->handle));
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800179 VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*)
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700180 heapMem->mBuffers[bufferIndex]->pointer();
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800181 md->pHandle = const_cast<native_handle_t*>(frameData.getNativeHandle());
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700182 sDataCbTimestamp(timestamp, (int32_t) msgType, mem, bufferIndex, this);
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800183 return hardware::Void();
184}
185
Yin-Chia Yehb5df5472017-03-20 19:32:19 -0700186hardware::Return<void> CameraHardwareInterface::handleCallbackTimestampBatch(
187 DataCallbackMsg msgType,
188 const hardware::hidl_vec<hardware::camera::device::V1_0::HandleTimestampMessage>& messages) {
189 std::vector<android::HandleTimestampMessage> msgs;
190 msgs.reserve(messages.size());
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700191 {
192 std::lock_guard<std::mutex> lock(mHidlMemPoolMapLock);
193 for (const auto& hidl_msg : messages) {
194 if (mHidlMemPoolMap.count(hidl_msg.data) == 0) {
195 ALOGE("%s: memory pool ID %d not found", __FUNCTION__, hidl_msg.data);
196 return hardware::Void();
197 }
198 sp<CameraHeapMemory> mem(
199 static_cast<CameraHeapMemory *>(mHidlMemPoolMap.at(hidl_msg.data)->handle));
Yin-Chia Yehb5df5472017-03-20 19:32:19 -0700200
Yin-Chia Yehb111f9e2017-09-22 11:32:53 -0700201 if (hidl_msg.bufferIndex >= mem->mNumBufs) {
202 ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
203 hidl_msg.bufferIndex, mem->mNumBufs);
204 return hardware::Void();
205 }
206 VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*)
207 mem->mBuffers[hidl_msg.bufferIndex]->pointer();
208 md->pHandle = const_cast<native_handle_t*>(hidl_msg.frameData.getNativeHandle());
209
210 msgs.push_back({hidl_msg.timestamp, mem->mBuffers[hidl_msg.bufferIndex]});
Yin-Chia Yehb5df5472017-03-20 19:32:19 -0700211 }
Yin-Chia Yehb5df5472017-03-20 19:32:19 -0700212 }
Yin-Chia Yehb5df5472017-03-20 19:32:19 -0700213 mDataCbTimestampBatch((int32_t) msgType, msgs, mCbUser);
214 return hardware::Void();
215}
216
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800217std::pair<bool, uint64_t> CameraHardwareInterface::getBufferId(
218 ANativeWindowBuffer* anb) {
219 std::lock_guard<std::mutex> lock(mBufferIdMapLock);
220
221 buffer_handle_t& buf = anb->handle;
222 auto it = mBufferIdMap.find(buf);
223 if (it == mBufferIdMap.end()) {
224 uint64_t bufId = mNextBufferId++;
225 mBufferIdMap[buf] = bufId;
226 mReversedBufMap[bufId] = anb;
227 return std::make_pair(true, bufId);
228 } else {
229 return std::make_pair(false, it->second);
230 }
231}
232
233void CameraHardwareInterface::cleanupCirculatingBuffers() {
234 std::lock_guard<std::mutex> lock(mBufferIdMapLock);
235 mBufferIdMap.clear();
236 mReversedBufMap.clear();
237}
238
239hardware::Return<void>
240CameraHardwareInterface::dequeueBuffer(dequeueBuffer_cb _hidl_cb) {
241 ANativeWindow *a = mPreviewWindow.get();
242 if (a == nullptr) {
243 ALOGE("%s: preview window is null", __FUNCTION__);
244 return hardware::Void();
245 }
246 ANativeWindowBuffer* anb;
247 int rc = native_window_dequeue_buffer_and_wait(a, &anb);
248 Status s = Status::INTERNAL_ERROR;
249 uint64_t bufferId = 0;
250 uint32_t stride = 0;
251 hidl_handle buf = nullptr;
252 if (rc == OK) {
253 s = Status::OK;
254 auto pair = getBufferId(anb);
255 buf = (pair.first) ? anb->handle : nullptr;
256 bufferId = pair.second;
257 stride = anb->stride;
258 }
259
260 _hidl_cb(s, bufferId, buf, stride);
261 return hardware::Void();
262}
263
264hardware::Return<Status>
265CameraHardwareInterface::enqueueBuffer(uint64_t bufferId) {
266 ANativeWindow *a = mPreviewWindow.get();
267 if (a == nullptr) {
268 ALOGE("%s: preview window is null", __FUNCTION__);
269 return Status::INTERNAL_ERROR;
270 }
271 if (mReversedBufMap.count(bufferId) == 0) {
272 ALOGE("%s: bufferId %" PRIu64 " not found", __FUNCTION__, bufferId);
273 return Status::ILLEGAL_ARGUMENT;
274 }
275 int rc = a->queueBuffer(a, mReversedBufMap.at(bufferId), -1);
276 if (rc == 0) {
277 return Status::OK;
278 }
279 return Status::INTERNAL_ERROR;
280}
281
282hardware::Return<Status>
283CameraHardwareInterface::cancelBuffer(uint64_t bufferId) {
284 ANativeWindow *a = mPreviewWindow.get();
285 if (a == nullptr) {
286 ALOGE("%s: preview window is null", __FUNCTION__);
287 return Status::INTERNAL_ERROR;
288 }
289 if (mReversedBufMap.count(bufferId) == 0) {
290 ALOGE("%s: bufferId %" PRIu64 " not found", __FUNCTION__, bufferId);
291 return Status::ILLEGAL_ARGUMENT;
292 }
293 int rc = a->cancelBuffer(a, mReversedBufMap.at(bufferId), -1);
294 if (rc == 0) {
295 return Status::OK;
296 }
297 return Status::INTERNAL_ERROR;
298}
299
300hardware::Return<Status>
301CameraHardwareInterface::setBufferCount(uint32_t count) {
302 ANativeWindow *a = mPreviewWindow.get();
303 if (a != nullptr) {
304 // Workaround for b/27039775
305 // Previously, setting the buffer count would reset the buffer
306 // queue's flag that allows for all buffers to be dequeued on the
307 // producer side, instead of just the producer's declared max count,
308 // if no filled buffers have yet been queued by the producer. This
309 // reset no longer happens, but some HALs depend on this behavior,
310 // so it needs to be maintained for HAL backwards compatibility.
311 // Simulate the prior behavior by disconnecting/reconnecting to the
312 // window and setting the values again. This has the drawback of
313 // actually causing memory reallocation, which may not have happened
314 // in the past.
315 native_window_api_disconnect(a, NATIVE_WINDOW_API_CAMERA);
316 native_window_api_connect(a, NATIVE_WINDOW_API_CAMERA);
317 if (mPreviewScalingMode != NOT_SET) {
318 native_window_set_scaling_mode(a, mPreviewScalingMode);
319 }
320 if (mPreviewTransform != NOT_SET) {
321 native_window_set_buffers_transform(a, mPreviewTransform);
322 }
323 if (mPreviewWidth != NOT_SET) {
324 native_window_set_buffers_dimensions(a,
325 mPreviewWidth, mPreviewHeight);
326 native_window_set_buffers_format(a, mPreviewFormat);
327 }
328 if (mPreviewUsage != 0) {
329 native_window_set_usage(a, mPreviewUsage);
330 }
331 if (mPreviewSwapInterval != NOT_SET) {
332 a->setSwapInterval(a, mPreviewSwapInterval);
333 }
334 if (mPreviewCrop.left != NOT_SET) {
335 native_window_set_crop(a, &(mPreviewCrop));
336 }
337 }
338 int rc = native_window_set_buffer_count(a, count);
339 if (rc == OK) {
340 cleanupCirculatingBuffers();
341 return Status::OK;
342 }
343 return Status::INTERNAL_ERROR;
344}
345
346hardware::Return<Status>
347CameraHardwareInterface::setBuffersGeometry(
348 uint32_t w, uint32_t h, hardware::graphics::common::V1_0::PixelFormat format) {
349 Status s = Status::INTERNAL_ERROR;
350 ANativeWindow *a = mPreviewWindow.get();
351 if (a == nullptr) {
352 ALOGE("%s: preview window is null", __FUNCTION__);
353 return s;
354 }
355 mPreviewWidth = w;
356 mPreviewHeight = h;
357 mPreviewFormat = (int) format;
358 int rc = native_window_set_buffers_dimensions(a, w, h);
359 if (rc == OK) {
360 rc = native_window_set_buffers_format(a, mPreviewFormat);
361 }
362 if (rc == OK) {
363 cleanupCirculatingBuffers();
364 s = Status::OK;
365 }
366 return s;
367}
368
369hardware::Return<Status>
370CameraHardwareInterface::setCrop(int32_t left, int32_t top, int32_t right, int32_t bottom) {
371 Status s = Status::INTERNAL_ERROR;
372 ANativeWindow *a = mPreviewWindow.get();
373 if (a == nullptr) {
374 ALOGE("%s: preview window is null", __FUNCTION__);
375 return s;
376 }
377 mPreviewCrop.left = left;
378 mPreviewCrop.top = top;
379 mPreviewCrop.right = right;
380 mPreviewCrop.bottom = bottom;
381 int rc = native_window_set_crop(a, &mPreviewCrop);
382 if (rc == OK) {
383 s = Status::OK;
384 }
385 return s;
386}
387
388hardware::Return<Status>
Chia-I Wu67a0c0e2017-04-06 13:37:01 -0700389CameraHardwareInterface::setUsage(hardware::graphics::common::V1_0::BufferUsage usage) {
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800390 Status s = Status::INTERNAL_ERROR;
391 ANativeWindow *a = mPreviewWindow.get();
392 if (a == nullptr) {
393 ALOGE("%s: preview window is null", __FUNCTION__);
394 return s;
395 }
Yin-Chia Yeh47cf8e62017-04-04 13:00:03 -0700396 mPreviewUsage = (int) usage;
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800397 int rc = native_window_set_usage(a, mPreviewUsage);
398 if (rc == OK) {
399 cleanupCirculatingBuffers();
400 s = Status::OK;
401 }
402 return s;
403}
404
405hardware::Return<Status>
406CameraHardwareInterface::setSwapInterval(int32_t interval) {
407 Status s = Status::INTERNAL_ERROR;
408 ANativeWindow *a = mPreviewWindow.get();
409 if (a == nullptr) {
410 ALOGE("%s: preview window is null", __FUNCTION__);
411 return s;
412 }
413 mPreviewSwapInterval = interval;
414 int rc = a->setSwapInterval(a, interval);
415 if (rc == OK) {
416 s = Status::OK;
417 }
418 return s;
419}
420
421hardware::Return<void>
422CameraHardwareInterface::getMinUndequeuedBufferCount(getMinUndequeuedBufferCount_cb _hidl_cb) {
423 ANativeWindow *a = mPreviewWindow.get();
424 if (a == nullptr) {
425 ALOGE("%s: preview window is null", __FUNCTION__);
426 return hardware::Void();
427 }
428 int count = 0;
429 int rc = a->query(a, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &count);
430 Status s = Status::INTERNAL_ERROR;
431 if (rc == OK) {
432 s = Status::OK;
433 }
434 _hidl_cb(s, count);
435 return hardware::Void();
436}
437
438hardware::Return<Status>
439CameraHardwareInterface::setTimestamp(int64_t timestamp) {
440 Status s = Status::INTERNAL_ERROR;
441 ANativeWindow *a = mPreviewWindow.get();
442 if (a == nullptr) {
443 ALOGE("%s: preview window is null", __FUNCTION__);
444 return s;
445 }
446 int rc = native_window_set_buffers_timestamp(a, timestamp);
447 if (rc == OK) {
448 s = Status::OK;
449 }
450 return s;
451}
452
453status_t CameraHardwareInterface::setPreviewWindow(const sp<ANativeWindow>& buf)
454{
455 ALOGV("%s(%s) buf %p", __FUNCTION__, mName.string(), buf.get());
456 if (CC_LIKELY(mHidlDevice != nullptr)) {
457 mPreviewWindow = buf;
458 if (buf != nullptr) {
459 if (mPreviewScalingMode != NOT_SET) {
460 setPreviewScalingMode(mPreviewScalingMode);
461 }
462 if (mPreviewTransform != NOT_SET) {
463 setPreviewTransform(mPreviewTransform);
464 }
465 }
466 return CameraProviderManager::mapToStatusT(
467 mHidlDevice->setPreviewWindow(buf.get() ? this : nullptr));
468 } else if (mDevice) {
469 if (mDevice->ops->set_preview_window) {
470 mPreviewWindow = buf;
471 if (buf != nullptr) {
472 if (mPreviewScalingMode != NOT_SET) {
473 setPreviewScalingMode(mPreviewScalingMode);
474 }
475 if (mPreviewTransform != NOT_SET) {
476 setPreviewTransform(mPreviewTransform);
477 }
478 }
479 mHalPreviewWindow.user = this;
480 ALOGV("%s &mHalPreviewWindow %p mHalPreviewWindow.user %p",__FUNCTION__,
481 &mHalPreviewWindow, mHalPreviewWindow.user);
482 return mDevice->ops->set_preview_window(mDevice,
483 buf.get() ? &mHalPreviewWindow.nw : 0);
484 }
485 }
486 return INVALID_OPERATION;
487}
488
489void CameraHardwareInterface::setCallbacks(notify_callback notify_cb,
490 data_callback data_cb,
491 data_callback_timestamp data_cb_timestamp,
Yin-Chia Yehb5df5472017-03-20 19:32:19 -0700492 data_callback_timestamp_batch data_cb_timestamp_batch,
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800493 void* user)
494{
495 mNotifyCb = notify_cb;
496 mDataCb = data_cb;
497 mDataCbTimestamp = data_cb_timestamp;
Yin-Chia Yehb5df5472017-03-20 19:32:19 -0700498 mDataCbTimestampBatch = data_cb_timestamp_batch;
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800499 mCbUser = user;
500
501 ALOGV("%s(%s)", __FUNCTION__, mName.string());
502
503 if (mDevice && mDevice->ops->set_callbacks) {
504 mDevice->ops->set_callbacks(mDevice,
505 sNotifyCb,
506 sDataCb,
507 sDataCbTimestamp,
508 sGetMemory,
509 this);
510 }
511}
512
513void CameraHardwareInterface::enableMsgType(int32_t msgType)
514{
515 ALOGV("%s(%s)", __FUNCTION__, mName.string());
516 if (CC_LIKELY(mHidlDevice != nullptr)) {
517 mHidlDevice->enableMsgType(msgType);
518 } else if (mDevice && mDevice->ops->enable_msg_type) {
519 mDevice->ops->enable_msg_type(mDevice, msgType);
520 }
521}
522
523void CameraHardwareInterface::disableMsgType(int32_t msgType)
524{
525 ALOGV("%s(%s)", __FUNCTION__, mName.string());
526 if (CC_LIKELY(mHidlDevice != nullptr)) {
527 mHidlDevice->disableMsgType(msgType);
528 } else if (mDevice && mDevice->ops->disable_msg_type) {
529 mDevice->ops->disable_msg_type(mDevice, msgType);
530 }
531}
532
533int CameraHardwareInterface::msgTypeEnabled(int32_t msgType)
534{
535 ALOGV("%s(%s)", __FUNCTION__, mName.string());
536 if (CC_LIKELY(mHidlDevice != nullptr)) {
537 return mHidlDevice->msgTypeEnabled(msgType);
538 } else if (mDevice && mDevice->ops->msg_type_enabled) {
539 return mDevice->ops->msg_type_enabled(mDevice, msgType);
540 }
541 return false;
542}
543
544status_t CameraHardwareInterface::startPreview()
545{
546 ALOGV("%s(%s)", __FUNCTION__, mName.string());
547 if (CC_LIKELY(mHidlDevice != nullptr)) {
548 return CameraProviderManager::mapToStatusT(
549 mHidlDevice->startPreview());
550 } else if (mDevice && mDevice->ops->start_preview) {
551 return mDevice->ops->start_preview(mDevice);
552 }
553 return INVALID_OPERATION;
554}
555
556void CameraHardwareInterface::stopPreview()
557{
558 ALOGV("%s(%s)", __FUNCTION__, mName.string());
559 if (CC_LIKELY(mHidlDevice != nullptr)) {
560 mHidlDevice->stopPreview();
561 } else if (mDevice && mDevice->ops->stop_preview) {
562 mDevice->ops->stop_preview(mDevice);
563 }
564}
565
566int CameraHardwareInterface::previewEnabled()
567{
568 ALOGV("%s(%s)", __FUNCTION__, mName.string());
569 if (CC_LIKELY(mHidlDevice != nullptr)) {
570 return mHidlDevice->previewEnabled();
571 } else if (mDevice && mDevice->ops->preview_enabled) {
572 return mDevice->ops->preview_enabled(mDevice);
573 }
574 return false;
575}
576
577status_t CameraHardwareInterface::storeMetaDataInBuffers(int enable)
578{
579 ALOGV("%s(%s)", __FUNCTION__, mName.string());
580 if (CC_LIKELY(mHidlDevice != nullptr)) {
581 return CameraProviderManager::mapToStatusT(
582 mHidlDevice->storeMetaDataInBuffers(enable));
583 } else if (mDevice && mDevice->ops->store_meta_data_in_buffers) {
584 return mDevice->ops->store_meta_data_in_buffers(mDevice, enable);
585 }
586 return enable ? INVALID_OPERATION: OK;
587}
588
589status_t CameraHardwareInterface::startRecording()
590{
591 ALOGV("%s(%s)", __FUNCTION__, mName.string());
592 if (CC_LIKELY(mHidlDevice != nullptr)) {
593 return CameraProviderManager::mapToStatusT(
594 mHidlDevice->startRecording());
595 } else if (mDevice && mDevice->ops->start_recording) {
596 return mDevice->ops->start_recording(mDevice);
597 }
598 return INVALID_OPERATION;
599}
600
601/**
602 * Stop a previously started recording.
603 */
604void CameraHardwareInterface::stopRecording()
605{
606 ALOGV("%s(%s)", __FUNCTION__, mName.string());
607 if (CC_LIKELY(mHidlDevice != nullptr)) {
608 mHidlDevice->stopRecording();
609 } else if (mDevice && mDevice->ops->stop_recording) {
610 mDevice->ops->stop_recording(mDevice);
611 }
612}
613
614/**
615 * Returns true if recording is enabled.
616 */
617int CameraHardwareInterface::recordingEnabled()
618{
619 ALOGV("%s(%s)", __FUNCTION__, mName.string());
620 if (CC_LIKELY(mHidlDevice != nullptr)) {
621 return mHidlDevice->recordingEnabled();
622 } else if (mDevice && mDevice->ops->recording_enabled) {
623 return mDevice->ops->recording_enabled(mDevice);
624 }
625 return false;
626}
627
628void CameraHardwareInterface::releaseRecordingFrame(const sp<IMemory>& mem)
629{
630 ALOGV("%s(%s)", __FUNCTION__, mName.string());
631 ssize_t offset;
632 size_t size;
633 sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
634 int heapId = heap->getHeapID();
635 int bufferIndex = offset / size;
636 if (CC_LIKELY(mHidlDevice != nullptr)) {
637 if (size == sizeof(VideoNativeHandleMetadata)) {
638 VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) mem->pointer();
639 // Caching the handle here because md->pHandle will be subject to HAL's edit
640 native_handle_t* nh = md->pHandle;
641 hidl_handle frame = nh;
642 mHidlDevice->releaseRecordingFrameHandle(heapId, bufferIndex, frame);
643 native_handle_close(nh);
644 native_handle_delete(nh);
645 } else {
646 mHidlDevice->releaseRecordingFrame(heapId, bufferIndex);
647 }
648 } else if (mDevice && mDevice->ops->release_recording_frame) {
649 void *data = ((uint8_t *)heap->base()) + offset;
650 return mDevice->ops->release_recording_frame(mDevice, data);
651 }
652}
653
Yin-Chia Yehb5df5472017-03-20 19:32:19 -0700654void CameraHardwareInterface::releaseRecordingFrameBatch(const std::vector<sp<IMemory>>& frames)
655{
656 ALOGV("%s(%s)", __FUNCTION__, mName.string());
657 size_t n = frames.size();
658 std::vector<VideoFrameMessage> msgs;
659 msgs.reserve(n);
660 for (auto& mem : frames) {
661 if (CC_LIKELY(mHidlDevice != nullptr)) {
662 ssize_t offset;
663 size_t size;
664 sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
665 if (size == sizeof(VideoNativeHandleMetadata)) {
666 uint32_t heapId = heap->getHeapID();
667 uint32_t bufferIndex = offset / size;
668 VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) mem->pointer();
669 // Caching the handle here because md->pHandle will be subject to HAL's edit
670 native_handle_t* nh = md->pHandle;
671 VideoFrameMessage msg;
672 msgs.push_back({nh, heapId, bufferIndex});
673 } else {
674 ALOGE("%s only supports VideoNativeHandleMetadata mode", __FUNCTION__);
675 return;
676 }
677 } else {
678 ALOGE("Non HIDL mode do not support %s", __FUNCTION__);
679 return;
680 }
681 }
682
683 mHidlDevice->releaseRecordingFrameHandleBatch(msgs);
684
685 for (auto& msg : msgs) {
686 native_handle_t* nh = const_cast<native_handle_t*>(msg.frameData.getNativeHandle());
687 native_handle_close(nh);
688 native_handle_delete(nh);
689 }
690}
691
Yin-Chia Yeh4717c472017-02-13 10:56:40 -0800692status_t CameraHardwareInterface::autoFocus()
693{
694 ALOGV("%s(%s)", __FUNCTION__, mName.string());
695 if (CC_LIKELY(mHidlDevice != nullptr)) {
696 return CameraProviderManager::mapToStatusT(
697 mHidlDevice->autoFocus());
698 } else if (mDevice && mDevice->ops->auto_focus) {
699 return mDevice->ops->auto_focus(mDevice);
700 }
701 return INVALID_OPERATION;
702}
703
704status_t CameraHardwareInterface::cancelAutoFocus()
705{
706 ALOGV("%s(%s)", __FUNCTION__, mName.string());
707 if (CC_LIKELY(mHidlDevice != nullptr)) {
708 return CameraProviderManager::mapToStatusT(
709 mHidlDevice->cancelAutoFocus());
710 } else if (mDevice && mDevice->ops->cancel_auto_focus) {
711 return mDevice->ops->cancel_auto_focus(mDevice);
712 }
713 return INVALID_OPERATION;
714}
715
716status_t CameraHardwareInterface::takePicture()
717{
718 ALOGV("%s(%s)", __FUNCTION__, mName.string());
719 if (CC_LIKELY(mHidlDevice != nullptr)) {
720 return CameraProviderManager::mapToStatusT(
721 mHidlDevice->takePicture());
722 } else if (mDevice && mDevice->ops->take_picture) {
723 return mDevice->ops->take_picture(mDevice);
724 }
725 return INVALID_OPERATION;
726}
727
728status_t CameraHardwareInterface::cancelPicture()
729{
730 ALOGV("%s(%s)", __FUNCTION__, mName.string());
731 if (CC_LIKELY(mHidlDevice != nullptr)) {
732 return CameraProviderManager::mapToStatusT(
733 mHidlDevice->cancelPicture());
734 } else if (mDevice && mDevice->ops->cancel_picture) {
735 return mDevice->ops->cancel_picture(mDevice);
736 }
737 return INVALID_OPERATION;
738}
739
740status_t CameraHardwareInterface::setParameters(const CameraParameters &params)
741{
742 ALOGV("%s(%s)", __FUNCTION__, mName.string());
743 if (CC_LIKELY(mHidlDevice != nullptr)) {
744 return CameraProviderManager::mapToStatusT(
745 mHidlDevice->setParameters(params.flatten().string()));
746 } else if (mDevice && mDevice->ops->set_parameters) {
747 return mDevice->ops->set_parameters(mDevice, params.flatten().string());
748 }
749 return INVALID_OPERATION;
750}
751
752CameraParameters CameraHardwareInterface::getParameters() const
753{
754 ALOGV("%s(%s)", __FUNCTION__, mName.string());
755 CameraParameters parms;
756 if (CC_LIKELY(mHidlDevice != nullptr)) {
757 hardware::hidl_string outParam;
758 mHidlDevice->getParameters(
759 [&outParam](const auto& outStr) {
760 outParam = outStr;
761 });
762 String8 tmp(outParam.c_str());
763 parms.unflatten(tmp);
764 } else if (mDevice && mDevice->ops->get_parameters) {
765 char *temp = mDevice->ops->get_parameters(mDevice);
766 String8 str_parms(temp);
767 if (mDevice->ops->put_parameters)
768 mDevice->ops->put_parameters(mDevice, temp);
769 else
770 free(temp);
771 parms.unflatten(str_parms);
772 }
773 return parms;
774}
775
776status_t CameraHardwareInterface::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
777{
778 ALOGV("%s(%s)", __FUNCTION__, mName.string());
779 if (CC_LIKELY(mHidlDevice != nullptr)) {
780 return CameraProviderManager::mapToStatusT(
781 mHidlDevice->sendCommand((CommandType) cmd, arg1, arg2));
782 } else if (mDevice && mDevice->ops->send_command) {
783 return mDevice->ops->send_command(mDevice, cmd, arg1, arg2);
784 }
785 return INVALID_OPERATION;
786}
787
788/**
789 * Release the hardware resources owned by this object. Note that this is
790 * *not* done in the destructor.
791 */
792void CameraHardwareInterface::release() {
793 ALOGV("%s(%s)", __FUNCTION__, mName.string());
794 if (CC_LIKELY(mHidlDevice != nullptr)) {
795 mHidlDevice->close();
796 mHidlDevice.clear();
797 } else if (mDevice && mDevice->ops->release) {
798 mDevice->ops->release(mDevice);
799 }
800}
801
802/**
803 * Dump state of the camera hardware
804 */
805status_t CameraHardwareInterface::dump(int fd, const Vector<String16>& /*args*/) const
806{
807 ALOGV("%s(%s)", __FUNCTION__, mName.string());
808 if (CC_LIKELY(mHidlDevice != nullptr)) {
809 native_handle_t* handle = native_handle_create(1,0);
810 handle->data[0] = fd;
811 Status s = mHidlDevice->dumpState(handle);
812 native_handle_delete(handle);
813 return CameraProviderManager::mapToStatusT(s);
814 } else if (mDevice && mDevice->ops->dump) {
815 return mDevice->ops->dump(mDevice, fd);
816 }
817 return OK; // It's fine if the HAL doesn't implement dump()
818}
819
820/**
821 * Methods for legacy (non-HIDL) path follows
822 */
823void CameraHardwareInterface::sNotifyCb(int32_t msg_type, int32_t ext1,
824 int32_t ext2, void *user)
825{
826 ALOGV("%s", __FUNCTION__);
827 CameraHardwareInterface *object =
828 static_cast<CameraHardwareInterface *>(user);
829 object->mNotifyCb(msg_type, ext1, ext2, object->mCbUser);
830}
831
832void CameraHardwareInterface::sDataCb(int32_t msg_type,
833 const camera_memory_t *data, unsigned int index,
834 camera_frame_metadata_t *metadata,
835 void *user)
836{
837 ALOGV("%s", __FUNCTION__);
838 CameraHardwareInterface *object =
839 static_cast<CameraHardwareInterface *>(user);
840 sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle));
841 if (index >= mem->mNumBufs) {
842 ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
843 index, mem->mNumBufs);
844 return;
845 }
846 object->mDataCb(msg_type, mem->mBuffers[index], metadata, object->mCbUser);
847}
848
849void CameraHardwareInterface::sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type,
850 const camera_memory_t *data, unsigned index,
851 void *user)
852{
853 ALOGV("%s", __FUNCTION__);
854 CameraHardwareInterface *object =
855 static_cast<CameraHardwareInterface *>(user);
856 // Start refcounting the heap object from here on. When the clients
857 // drop all references, it will be destroyed (as well as the enclosed
858 // MemoryHeapBase.
859 sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle));
860 if (index >= mem->mNumBufs) {
861 ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__,
862 index, mem->mNumBufs);
863 return;
864 }
865 object->mDataCbTimestamp(timestamp, msg_type, mem->mBuffers[index], object->mCbUser);
866}
867
868camera_memory_t* CameraHardwareInterface::sGetMemory(
869 int fd, size_t buf_size, uint_t num_bufs,
870 void *user __attribute__((unused)))
871{
872 CameraHeapMemory *mem;
873 if (fd < 0) {
874 mem = new CameraHeapMemory(buf_size, num_bufs);
875 } else {
876 mem = new CameraHeapMemory(fd, buf_size, num_bufs);
877 }
878 mem->incStrong(mem);
879 return &mem->handle;
880}
881
882void CameraHardwareInterface::sPutMemory(camera_memory_t *data)
883{
884 if (!data) {
885 return;
886 }
887
888 CameraHeapMemory *mem = static_cast<CameraHeapMemory *>(data->handle);
889 mem->decStrong(mem);
890}
891
892ANativeWindow* CameraHardwareInterface::sToAnw(void *user)
893{
894 CameraHardwareInterface *object =
895 reinterpret_cast<CameraHardwareInterface *>(user);
896 return object->mPreviewWindow.get();
897}
898#define anw(n) sToAnw(((struct camera_preview_window *)(n))->user)
899#define hwi(n) reinterpret_cast<CameraHardwareInterface *>(\
900 ((struct camera_preview_window *)(n))->user)
901
902int CameraHardwareInterface::sDequeueBuffer(struct preview_stream_ops* w,
903 buffer_handle_t** buffer, int *stride)
904{
905 int rc;
906 ANativeWindow *a = anw(w);
907 ANativeWindowBuffer* anb;
908 rc = native_window_dequeue_buffer_and_wait(a, &anb);
909 if (rc == OK) {
910 *buffer = &anb->handle;
911 *stride = anb->stride;
912 }
913 return rc;
914}
915
916#ifndef container_of
917#define container_of(ptr, type, member) ({ \
918 const __typeof__(((type *) 0)->member) *__mptr = (ptr); \
919 (type *) ((char *) __mptr - (char *)(&((type *)0)->member)); })
920#endif
921
922int CameraHardwareInterface::sLockBuffer(struct preview_stream_ops* w,
923 buffer_handle_t* /*buffer*/)
924{
925 ANativeWindow *a = anw(w);
926 (void)a;
927 return 0;
928}
929
930int CameraHardwareInterface::sEnqueueBuffer(struct preview_stream_ops* w,
931 buffer_handle_t* buffer)
932{
933 ANativeWindow *a = anw(w);
934 return a->queueBuffer(a,
935 container_of(buffer, ANativeWindowBuffer, handle), -1);
936}
937
938int CameraHardwareInterface::sCancelBuffer(struct preview_stream_ops* w,
939 buffer_handle_t* buffer)
940{
941 ANativeWindow *a = anw(w);
942 return a->cancelBuffer(a,
943 container_of(buffer, ANativeWindowBuffer, handle), -1);
944}
945
946int CameraHardwareInterface::sSetBufferCount(struct preview_stream_ops* w, int count)
947{
948 ANativeWindow *a = anw(w);
949
950 if (a != nullptr) {
951 // Workaround for b/27039775
952 // Previously, setting the buffer count would reset the buffer
953 // queue's flag that allows for all buffers to be dequeued on the
954 // producer side, instead of just the producer's declared max count,
955 // if no filled buffers have yet been queued by the producer. This
956 // reset no longer happens, but some HALs depend on this behavior,
957 // so it needs to be maintained for HAL backwards compatibility.
958 // Simulate the prior behavior by disconnecting/reconnecting to the
959 // window and setting the values again. This has the drawback of
960 // actually causing memory reallocation, which may not have happened
961 // in the past.
962 CameraHardwareInterface *hw = hwi(w);
963 native_window_api_disconnect(a, NATIVE_WINDOW_API_CAMERA);
964 native_window_api_connect(a, NATIVE_WINDOW_API_CAMERA);
965 if (hw->mPreviewScalingMode != NOT_SET) {
966 native_window_set_scaling_mode(a, hw->mPreviewScalingMode);
967 }
968 if (hw->mPreviewTransform != NOT_SET) {
969 native_window_set_buffers_transform(a, hw->mPreviewTransform);
970 }
971 if (hw->mPreviewWidth != NOT_SET) {
972 native_window_set_buffers_dimensions(a,
973 hw->mPreviewWidth, hw->mPreviewHeight);
974 native_window_set_buffers_format(a, hw->mPreviewFormat);
975 }
976 if (hw->mPreviewUsage != 0) {
977 native_window_set_usage(a, hw->mPreviewUsage);
978 }
979 if (hw->mPreviewSwapInterval != NOT_SET) {
980 a->setSwapInterval(a, hw->mPreviewSwapInterval);
981 }
982 if (hw->mPreviewCrop.left != NOT_SET) {
983 native_window_set_crop(a, &(hw->mPreviewCrop));
984 }
985 }
986
987 return native_window_set_buffer_count(a, count);
988}
989
990int CameraHardwareInterface::sSetBuffersGeometry(struct preview_stream_ops* w,
991 int width, int height, int format)
992{
993 int rc;
994 ANativeWindow *a = anw(w);
995 CameraHardwareInterface *hw = hwi(w);
996 hw->mPreviewWidth = width;
997 hw->mPreviewHeight = height;
998 hw->mPreviewFormat = format;
999 rc = native_window_set_buffers_dimensions(a, width, height);
1000 if (rc == OK) {
1001 rc = native_window_set_buffers_format(a, format);
1002 }
1003 return rc;
1004}
1005
1006int CameraHardwareInterface::sSetCrop(struct preview_stream_ops *w,
1007 int left, int top, int right, int bottom)
1008{
1009 ANativeWindow *a = anw(w);
1010 CameraHardwareInterface *hw = hwi(w);
1011 hw->mPreviewCrop.left = left;
1012 hw->mPreviewCrop.top = top;
1013 hw->mPreviewCrop.right = right;
1014 hw->mPreviewCrop.bottom = bottom;
1015 return native_window_set_crop(a, &(hw->mPreviewCrop));
1016}
1017
1018int CameraHardwareInterface::sSetTimestamp(struct preview_stream_ops *w,
1019 int64_t timestamp) {
1020 ANativeWindow *a = anw(w);
1021 return native_window_set_buffers_timestamp(a, timestamp);
1022}
1023
1024int CameraHardwareInterface::sSetUsage(struct preview_stream_ops* w, int usage)
1025{
1026 ANativeWindow *a = anw(w);
1027 CameraHardwareInterface *hw = hwi(w);
1028 hw->mPreviewUsage = usage;
1029 return native_window_set_usage(a, usage);
1030}
1031
1032int CameraHardwareInterface::sSetSwapInterval(struct preview_stream_ops *w, int interval)
1033{
1034 ANativeWindow *a = anw(w);
1035 CameraHardwareInterface *hw = hwi(w);
1036 hw->mPreviewSwapInterval = interval;
1037 return a->setSwapInterval(a, interval);
1038}
1039
1040int CameraHardwareInterface::sGetMinUndequeuedBufferCount(
1041 const struct preview_stream_ops *w,
1042 int *count)
1043{
1044 ANativeWindow *a = anw(w);
1045 return a->query(a, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, count);
1046}
1047
1048void CameraHardwareInterface::initHalPreviewWindow()
1049{
1050 mHalPreviewWindow.nw.cancel_buffer = sCancelBuffer;
1051 mHalPreviewWindow.nw.lock_buffer = sLockBuffer;
1052 mHalPreviewWindow.nw.dequeue_buffer = sDequeueBuffer;
1053 mHalPreviewWindow.nw.enqueue_buffer = sEnqueueBuffer;
1054 mHalPreviewWindow.nw.set_buffer_count = sSetBufferCount;
1055 mHalPreviewWindow.nw.set_buffers_geometry = sSetBuffersGeometry;
1056 mHalPreviewWindow.nw.set_crop = sSetCrop;
1057 mHalPreviewWindow.nw.set_timestamp = sSetTimestamp;
1058 mHalPreviewWindow.nw.set_usage = sSetUsage;
1059 mHalPreviewWindow.nw.set_swap_interval = sSetSwapInterval;
1060
1061 mHalPreviewWindow.nw.get_min_undequeued_buffer_count =
1062 sGetMinUndequeuedBufferCount;
1063}
1064
1065}; // namespace android