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