CameraHardwareInterface.cpp revision 5ff9c91a90d7d5fad49de38bc314910251b25774
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 "CameraHardwareInterface.h" 21 22namespace android { 23 24using namespace hardware::camera::device::V1_0; 25using namespace hardware::camera::common::V1_0; 26using hardware::hidl_handle; 27 28CameraHardwareInterface::~CameraHardwareInterface() 29{ 30 ALOGI("Destroying camera %s", mName.string()); 31 if (mDevice) { 32 int rc = mDevice->common.close(&mDevice->common); 33 if (rc != OK) 34 ALOGE("Could not close camera %s: %d", mName.string(), rc); 35 } 36 if (mHidlDevice != nullptr) { 37 mHidlDevice->close(); 38 mHidlDevice.clear(); 39 cleanupCirculatingBuffers(); 40 } 41} 42 43status_t CameraHardwareInterface::initialize(CameraModule *module) 44{ 45 if (mHidlDevice != nullptr) { 46 ALOGE("%s: camera hardware interface has been initialized to HIDL path!", __FUNCTION__); 47 return INVALID_OPERATION; 48 } 49 ALOGI("Opening camera %s", mName.string()); 50 camera_info info; 51 status_t res = module->getCameraInfo(atoi(mName.string()), &info); 52 if (res != OK) { 53 return res; 54 } 55 56 int rc = OK; 57 if (module->getModuleApiVersion() >= CAMERA_MODULE_API_VERSION_2_3 && 58 info.device_version > CAMERA_DEVICE_API_VERSION_1_0) { 59 // Open higher version camera device as HAL1.0 device. 60 rc = module->openLegacy(mName.string(), 61 CAMERA_DEVICE_API_VERSION_1_0, 62 (hw_device_t **)&mDevice); 63 } else { 64 rc = module->open(mName.string(), (hw_device_t **)&mDevice); 65 } 66 if (rc != OK) { 67 ALOGE("Could not open camera %s: %d", mName.string(), rc); 68 return rc; 69 } 70 initHalPreviewWindow(); 71 return rc; 72} 73 74status_t CameraHardwareInterface::initialize(sp<CameraProviderManager> manager) { 75 if (mDevice) { 76 ALOGE("%s: camera hardware interface has been initialized to libhardware path!", 77 __FUNCTION__); 78 return INVALID_OPERATION; 79 } 80 81 ALOGI("Opening camera %s", mName.string()); 82 83 status_t ret = manager->openSession(mName.string(), this, &mHidlDevice); 84 if (ret != OK) { 85 ALOGE("%s: openSession failed! %s (%d)", __FUNCTION__, strerror(-ret), ret); 86 } 87 return ret; 88} 89 90status_t CameraHardwareInterface::setPreviewScalingMode(int scalingMode) 91{ 92 int rc = OK; 93 mPreviewScalingMode = scalingMode; 94 if (mPreviewWindow != nullptr) { 95 rc = native_window_set_scaling_mode(mPreviewWindow.get(), 96 scalingMode); 97 } 98 return rc; 99} 100 101status_t CameraHardwareInterface::setPreviewTransform(int transform) { 102 int rc = OK; 103 mPreviewTransform = transform; 104 if (mPreviewWindow != nullptr) { 105 rc = native_window_set_buffers_transform(mPreviewWindow.get(), 106 mPreviewTransform); 107 } 108 return rc; 109} 110 111/** 112 * Implementation of android::hardware::camera::device::V1_0::ICameraDeviceCallback 113 */ 114hardware::Return<void> CameraHardwareInterface::notifyCallback( 115 NotifyCallbackMsg msgType, int32_t ext1, int32_t ext2) { 116 sNotifyCb((int32_t) msgType, ext1, ext2, (void*) this); 117 return hardware::Void(); 118} 119 120hardware::Return<uint32_t> CameraHardwareInterface::registerMemory( 121 const hardware::hidl_handle& descriptor, 122 uint32_t bufferSize, uint32_t bufferCount) { 123 if (descriptor->numFds != 1) { 124 ALOGE("%s: camera memory descriptor has numFds %d (expect 1)", 125 __FUNCTION__, descriptor->numFds); 126 return 0; 127 } 128 if (descriptor->data[0] < 0) { 129 ALOGE("%s: camera memory descriptor has FD %d (expect >= 0)", 130 __FUNCTION__, descriptor->data[0]); 131 return 0; 132 } 133 134 camera_memory_t* mem = sGetMemory(descriptor->data[0], bufferSize, bufferCount, this); 135 sp<CameraHeapMemory> camMem(static_cast<CameraHeapMemory *>(mem->handle)); 136 int memPoolId = camMem->mHeap->getHeapID(); 137 if (memPoolId < 0) { 138 ALOGE("%s: CameraHeapMemory has FD %d (expect >= 0)", __FUNCTION__, memPoolId); 139 return 0; 140 } 141 mHidlMemPoolMap.insert(std::make_pair(memPoolId, mem)); 142 return memPoolId; 143} 144 145hardware::Return<void> CameraHardwareInterface::unregisterMemory(uint32_t memId) { 146 if (mHidlMemPoolMap.count(memId) == 0) { 147 ALOGE("%s: memory pool ID %d not found", __FUNCTION__, memId); 148 return hardware::Void(); 149 } 150 camera_memory_t* mem = mHidlMemPoolMap.at(memId); 151 sPutMemory(mem); 152 mHidlMemPoolMap.erase(memId); 153 return hardware::Void(); 154} 155 156hardware::Return<void> CameraHardwareInterface::dataCallback( 157 DataCallbackMsg msgType, uint32_t data, uint32_t bufferIndex, 158 const hardware::camera::device::V1_0::CameraFrameMetadata& metadata) { 159 if (mHidlMemPoolMap.count(data) == 0) { 160 ALOGE("%s: memory pool ID %d not found", __FUNCTION__, data); 161 return hardware::Void(); 162 } 163 camera_frame_metadata_t md; 164 md.number_of_faces = metadata.faces.size(); 165 md.faces = (camera_face_t*) metadata.faces.data(); 166 sDataCb((int32_t) msgType, mHidlMemPoolMap.at(data), bufferIndex, &md, this); 167 return hardware::Void(); 168} 169 170hardware::Return<void> CameraHardwareInterface::dataCallbackTimestamp( 171 DataCallbackMsg msgType, uint32_t data, 172 uint32_t bufferIndex, int64_t timestamp) { 173 if (mHidlMemPoolMap.count(data) == 0) { 174 ALOGE("%s: memory pool ID %d not found", __FUNCTION__, data); 175 return hardware::Void(); 176 } 177 sDataCbTimestamp(timestamp, (int32_t) msgType, mHidlMemPoolMap.at(data), bufferIndex, this); 178 return hardware::Void(); 179} 180 181hardware::Return<void> CameraHardwareInterface::handleCallbackTimestamp( 182 DataCallbackMsg msgType, const hidl_handle& frameData, uint32_t data, 183 uint32_t bufferIndex, int64_t timestamp) { 184 if (mHidlMemPoolMap.count(data) == 0) { 185 ALOGE("%s: memory pool ID %d not found", __FUNCTION__, data); 186 return hardware::Void(); 187 } 188 sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(mHidlMemPoolMap.at(data)->handle)); 189 VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) 190 mem->mBuffers[bufferIndex]->pointer(); 191 md->pHandle = const_cast<native_handle_t*>(frameData.getNativeHandle()); 192 sDataCbTimestamp(timestamp, (int32_t) msgType, mHidlMemPoolMap.at(data), bufferIndex, this); 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::allocator::V2_0::ProducerUsage 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 void* user) 472{ 473 mNotifyCb = notify_cb; 474 mDataCb = data_cb; 475 mDataCbTimestamp = data_cb_timestamp; 476 mCbUser = user; 477 478 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 479 480 if (mDevice && mDevice->ops->set_callbacks) { 481 mDevice->ops->set_callbacks(mDevice, 482 sNotifyCb, 483 sDataCb, 484 sDataCbTimestamp, 485 sGetMemory, 486 this); 487 } 488} 489 490void CameraHardwareInterface::enableMsgType(int32_t msgType) 491{ 492 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 493 if (CC_LIKELY(mHidlDevice != nullptr)) { 494 mHidlDevice->enableMsgType(msgType); 495 } else if (mDevice && mDevice->ops->enable_msg_type) { 496 mDevice->ops->enable_msg_type(mDevice, msgType); 497 } 498} 499 500void CameraHardwareInterface::disableMsgType(int32_t msgType) 501{ 502 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 503 if (CC_LIKELY(mHidlDevice != nullptr)) { 504 mHidlDevice->disableMsgType(msgType); 505 } else if (mDevice && mDevice->ops->disable_msg_type) { 506 mDevice->ops->disable_msg_type(mDevice, msgType); 507 } 508} 509 510int CameraHardwareInterface::msgTypeEnabled(int32_t msgType) 511{ 512 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 513 if (CC_LIKELY(mHidlDevice != nullptr)) { 514 return mHidlDevice->msgTypeEnabled(msgType); 515 } else if (mDevice && mDevice->ops->msg_type_enabled) { 516 return mDevice->ops->msg_type_enabled(mDevice, msgType); 517 } 518 return false; 519} 520 521status_t CameraHardwareInterface::startPreview() 522{ 523 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 524 if (CC_LIKELY(mHidlDevice != nullptr)) { 525 return CameraProviderManager::mapToStatusT( 526 mHidlDevice->startPreview()); 527 } else if (mDevice && mDevice->ops->start_preview) { 528 return mDevice->ops->start_preview(mDevice); 529 } 530 return INVALID_OPERATION; 531} 532 533void CameraHardwareInterface::stopPreview() 534{ 535 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 536 if (CC_LIKELY(mHidlDevice != nullptr)) { 537 mHidlDevice->stopPreview(); 538 } else if (mDevice && mDevice->ops->stop_preview) { 539 mDevice->ops->stop_preview(mDevice); 540 } 541} 542 543int CameraHardwareInterface::previewEnabled() 544{ 545 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 546 if (CC_LIKELY(mHidlDevice != nullptr)) { 547 return mHidlDevice->previewEnabled(); 548 } else if (mDevice && mDevice->ops->preview_enabled) { 549 return mDevice->ops->preview_enabled(mDevice); 550 } 551 return false; 552} 553 554status_t CameraHardwareInterface::storeMetaDataInBuffers(int enable) 555{ 556 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 557 if (CC_LIKELY(mHidlDevice != nullptr)) { 558 return CameraProviderManager::mapToStatusT( 559 mHidlDevice->storeMetaDataInBuffers(enable)); 560 } else if (mDevice && mDevice->ops->store_meta_data_in_buffers) { 561 return mDevice->ops->store_meta_data_in_buffers(mDevice, enable); 562 } 563 return enable ? INVALID_OPERATION: OK; 564} 565 566status_t CameraHardwareInterface::startRecording() 567{ 568 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 569 if (CC_LIKELY(mHidlDevice != nullptr)) { 570 return CameraProviderManager::mapToStatusT( 571 mHidlDevice->startRecording()); 572 } else if (mDevice && mDevice->ops->start_recording) { 573 return mDevice->ops->start_recording(mDevice); 574 } 575 return INVALID_OPERATION; 576} 577 578/** 579 * Stop a previously started recording. 580 */ 581void CameraHardwareInterface::stopRecording() 582{ 583 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 584 if (CC_LIKELY(mHidlDevice != nullptr)) { 585 mHidlDevice->stopRecording(); 586 } else if (mDevice && mDevice->ops->stop_recording) { 587 mDevice->ops->stop_recording(mDevice); 588 } 589} 590 591/** 592 * Returns true if recording is enabled. 593 */ 594int CameraHardwareInterface::recordingEnabled() 595{ 596 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 597 if (CC_LIKELY(mHidlDevice != nullptr)) { 598 return mHidlDevice->recordingEnabled(); 599 } else if (mDevice && mDevice->ops->recording_enabled) { 600 return mDevice->ops->recording_enabled(mDevice); 601 } 602 return false; 603} 604 605void CameraHardwareInterface::releaseRecordingFrame(const sp<IMemory>& mem) 606{ 607 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 608 ssize_t offset; 609 size_t size; 610 sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); 611 int heapId = heap->getHeapID(); 612 int bufferIndex = offset / size; 613 if (CC_LIKELY(mHidlDevice != nullptr)) { 614 if (size == sizeof(VideoNativeHandleMetadata)) { 615 VideoNativeHandleMetadata* md = (VideoNativeHandleMetadata*) mem->pointer(); 616 // Caching the handle here because md->pHandle will be subject to HAL's edit 617 native_handle_t* nh = md->pHandle; 618 hidl_handle frame = nh; 619 mHidlDevice->releaseRecordingFrameHandle(heapId, bufferIndex, frame); 620 native_handle_close(nh); 621 native_handle_delete(nh); 622 } else { 623 mHidlDevice->releaseRecordingFrame(heapId, bufferIndex); 624 } 625 } else if (mDevice && mDevice->ops->release_recording_frame) { 626 void *data = ((uint8_t *)heap->base()) + offset; 627 return mDevice->ops->release_recording_frame(mDevice, data); 628 } 629} 630 631status_t CameraHardwareInterface::autoFocus() 632{ 633 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 634 if (CC_LIKELY(mHidlDevice != nullptr)) { 635 return CameraProviderManager::mapToStatusT( 636 mHidlDevice->autoFocus()); 637 } else if (mDevice && mDevice->ops->auto_focus) { 638 return mDevice->ops->auto_focus(mDevice); 639 } 640 return INVALID_OPERATION; 641} 642 643status_t CameraHardwareInterface::cancelAutoFocus() 644{ 645 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 646 if (CC_LIKELY(mHidlDevice != nullptr)) { 647 return CameraProviderManager::mapToStatusT( 648 mHidlDevice->cancelAutoFocus()); 649 } else if (mDevice && mDevice->ops->cancel_auto_focus) { 650 return mDevice->ops->cancel_auto_focus(mDevice); 651 } 652 return INVALID_OPERATION; 653} 654 655status_t CameraHardwareInterface::takePicture() 656{ 657 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 658 if (CC_LIKELY(mHidlDevice != nullptr)) { 659 return CameraProviderManager::mapToStatusT( 660 mHidlDevice->takePicture()); 661 } else if (mDevice && mDevice->ops->take_picture) { 662 return mDevice->ops->take_picture(mDevice); 663 } 664 return INVALID_OPERATION; 665} 666 667status_t CameraHardwareInterface::cancelPicture() 668{ 669 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 670 if (CC_LIKELY(mHidlDevice != nullptr)) { 671 return CameraProviderManager::mapToStatusT( 672 mHidlDevice->cancelPicture()); 673 } else if (mDevice && mDevice->ops->cancel_picture) { 674 return mDevice->ops->cancel_picture(mDevice); 675 } 676 return INVALID_OPERATION; 677} 678 679status_t CameraHardwareInterface::setParameters(const CameraParameters ¶ms) 680{ 681 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 682 if (CC_LIKELY(mHidlDevice != nullptr)) { 683 return CameraProviderManager::mapToStatusT( 684 mHidlDevice->setParameters(params.flatten().string())); 685 } else if (mDevice && mDevice->ops->set_parameters) { 686 return mDevice->ops->set_parameters(mDevice, params.flatten().string()); 687 } 688 return INVALID_OPERATION; 689} 690 691CameraParameters CameraHardwareInterface::getParameters() const 692{ 693 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 694 CameraParameters parms; 695 if (CC_LIKELY(mHidlDevice != nullptr)) { 696 hardware::hidl_string outParam; 697 mHidlDevice->getParameters( 698 [&outParam](const auto& outStr) { 699 outParam = outStr; 700 }); 701 String8 tmp(outParam.c_str()); 702 parms.unflatten(tmp); 703 } else if (mDevice && mDevice->ops->get_parameters) { 704 char *temp = mDevice->ops->get_parameters(mDevice); 705 String8 str_parms(temp); 706 if (mDevice->ops->put_parameters) 707 mDevice->ops->put_parameters(mDevice, temp); 708 else 709 free(temp); 710 parms.unflatten(str_parms); 711 } 712 return parms; 713} 714 715status_t CameraHardwareInterface::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) 716{ 717 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 718 if (CC_LIKELY(mHidlDevice != nullptr)) { 719 return CameraProviderManager::mapToStatusT( 720 mHidlDevice->sendCommand((CommandType) cmd, arg1, arg2)); 721 } else if (mDevice && mDevice->ops->send_command) { 722 return mDevice->ops->send_command(mDevice, cmd, arg1, arg2); 723 } 724 return INVALID_OPERATION; 725} 726 727/** 728 * Release the hardware resources owned by this object. Note that this is 729 * *not* done in the destructor. 730 */ 731void CameraHardwareInterface::release() { 732 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 733 if (CC_LIKELY(mHidlDevice != nullptr)) { 734 mHidlDevice->close(); 735 mHidlDevice.clear(); 736 } else if (mDevice && mDevice->ops->release) { 737 mDevice->ops->release(mDevice); 738 } 739} 740 741/** 742 * Dump state of the camera hardware 743 */ 744status_t CameraHardwareInterface::dump(int fd, const Vector<String16>& /*args*/) const 745{ 746 ALOGV("%s(%s)", __FUNCTION__, mName.string()); 747 if (CC_LIKELY(mHidlDevice != nullptr)) { 748 native_handle_t* handle = native_handle_create(1,0); 749 handle->data[0] = fd; 750 Status s = mHidlDevice->dumpState(handle); 751 native_handle_delete(handle); 752 return CameraProviderManager::mapToStatusT(s); 753 } else if (mDevice && mDevice->ops->dump) { 754 return mDevice->ops->dump(mDevice, fd); 755 } 756 return OK; // It's fine if the HAL doesn't implement dump() 757} 758 759/** 760 * Methods for legacy (non-HIDL) path follows 761 */ 762void CameraHardwareInterface::sNotifyCb(int32_t msg_type, int32_t ext1, 763 int32_t ext2, void *user) 764{ 765 ALOGV("%s", __FUNCTION__); 766 CameraHardwareInterface *object = 767 static_cast<CameraHardwareInterface *>(user); 768 object->mNotifyCb(msg_type, ext1, ext2, object->mCbUser); 769} 770 771void CameraHardwareInterface::sDataCb(int32_t msg_type, 772 const camera_memory_t *data, unsigned int index, 773 camera_frame_metadata_t *metadata, 774 void *user) 775{ 776 ALOGV("%s", __FUNCTION__); 777 CameraHardwareInterface *object = 778 static_cast<CameraHardwareInterface *>(user); 779 sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle)); 780 if (index >= mem->mNumBufs) { 781 ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__, 782 index, mem->mNumBufs); 783 return; 784 } 785 object->mDataCb(msg_type, mem->mBuffers[index], metadata, object->mCbUser); 786} 787 788void CameraHardwareInterface::sDataCbTimestamp(nsecs_t timestamp, int32_t msg_type, 789 const camera_memory_t *data, unsigned index, 790 void *user) 791{ 792 ALOGV("%s", __FUNCTION__); 793 CameraHardwareInterface *object = 794 static_cast<CameraHardwareInterface *>(user); 795 // Start refcounting the heap object from here on. When the clients 796 // drop all references, it will be destroyed (as well as the enclosed 797 // MemoryHeapBase. 798 sp<CameraHeapMemory> mem(static_cast<CameraHeapMemory *>(data->handle)); 799 if (index >= mem->mNumBufs) { 800 ALOGE("%s: invalid buffer index %d, max allowed is %d", __FUNCTION__, 801 index, mem->mNumBufs); 802 return; 803 } 804 object->mDataCbTimestamp(timestamp, msg_type, mem->mBuffers[index], object->mCbUser); 805} 806 807camera_memory_t* CameraHardwareInterface::sGetMemory( 808 int fd, size_t buf_size, uint_t num_bufs, 809 void *user __attribute__((unused))) 810{ 811 CameraHeapMemory *mem; 812 if (fd < 0) { 813 mem = new CameraHeapMemory(buf_size, num_bufs); 814 } else { 815 mem = new CameraHeapMemory(fd, buf_size, num_bufs); 816 } 817 mem->incStrong(mem); 818 return &mem->handle; 819} 820 821void CameraHardwareInterface::sPutMemory(camera_memory_t *data) 822{ 823 if (!data) { 824 return; 825 } 826 827 CameraHeapMemory *mem = static_cast<CameraHeapMemory *>(data->handle); 828 mem->decStrong(mem); 829} 830 831ANativeWindow* CameraHardwareInterface::sToAnw(void *user) 832{ 833 CameraHardwareInterface *object = 834 reinterpret_cast<CameraHardwareInterface *>(user); 835 return object->mPreviewWindow.get(); 836} 837#define anw(n) sToAnw(((struct camera_preview_window *)(n))->user) 838#define hwi(n) reinterpret_cast<CameraHardwareInterface *>(\ 839 ((struct camera_preview_window *)(n))->user) 840 841int CameraHardwareInterface::sDequeueBuffer(struct preview_stream_ops* w, 842 buffer_handle_t** buffer, int *stride) 843{ 844 int rc; 845 ANativeWindow *a = anw(w); 846 ANativeWindowBuffer* anb; 847 rc = native_window_dequeue_buffer_and_wait(a, &anb); 848 if (rc == OK) { 849 *buffer = &anb->handle; 850 *stride = anb->stride; 851 } 852 return rc; 853} 854 855#ifndef container_of 856#define container_of(ptr, type, member) ({ \ 857 const __typeof__(((type *) 0)->member) *__mptr = (ptr); \ 858 (type *) ((char *) __mptr - (char *)(&((type *)0)->member)); }) 859#endif 860 861int CameraHardwareInterface::sLockBuffer(struct preview_stream_ops* w, 862 buffer_handle_t* /*buffer*/) 863{ 864 ANativeWindow *a = anw(w); 865 (void)a; 866 return 0; 867} 868 869int CameraHardwareInterface::sEnqueueBuffer(struct preview_stream_ops* w, 870 buffer_handle_t* buffer) 871{ 872 ANativeWindow *a = anw(w); 873 return a->queueBuffer(a, 874 container_of(buffer, ANativeWindowBuffer, handle), -1); 875} 876 877int CameraHardwareInterface::sCancelBuffer(struct preview_stream_ops* w, 878 buffer_handle_t* buffer) 879{ 880 ANativeWindow *a = anw(w); 881 return a->cancelBuffer(a, 882 container_of(buffer, ANativeWindowBuffer, handle), -1); 883} 884 885int CameraHardwareInterface::sSetBufferCount(struct preview_stream_ops* w, int count) 886{ 887 ANativeWindow *a = anw(w); 888 889 if (a != nullptr) { 890 // Workaround for b/27039775 891 // Previously, setting the buffer count would reset the buffer 892 // queue's flag that allows for all buffers to be dequeued on the 893 // producer side, instead of just the producer's declared max count, 894 // if no filled buffers have yet been queued by the producer. This 895 // reset no longer happens, but some HALs depend on this behavior, 896 // so it needs to be maintained for HAL backwards compatibility. 897 // Simulate the prior behavior by disconnecting/reconnecting to the 898 // window and setting the values again. This has the drawback of 899 // actually causing memory reallocation, which may not have happened 900 // in the past. 901 CameraHardwareInterface *hw = hwi(w); 902 native_window_api_disconnect(a, NATIVE_WINDOW_API_CAMERA); 903 native_window_api_connect(a, NATIVE_WINDOW_API_CAMERA); 904 if (hw->mPreviewScalingMode != NOT_SET) { 905 native_window_set_scaling_mode(a, hw->mPreviewScalingMode); 906 } 907 if (hw->mPreviewTransform != NOT_SET) { 908 native_window_set_buffers_transform(a, hw->mPreviewTransform); 909 } 910 if (hw->mPreviewWidth != NOT_SET) { 911 native_window_set_buffers_dimensions(a, 912 hw->mPreviewWidth, hw->mPreviewHeight); 913 native_window_set_buffers_format(a, hw->mPreviewFormat); 914 } 915 if (hw->mPreviewUsage != 0) { 916 native_window_set_usage(a, hw->mPreviewUsage); 917 } 918 if (hw->mPreviewSwapInterval != NOT_SET) { 919 a->setSwapInterval(a, hw->mPreviewSwapInterval); 920 } 921 if (hw->mPreviewCrop.left != NOT_SET) { 922 native_window_set_crop(a, &(hw->mPreviewCrop)); 923 } 924 } 925 926 return native_window_set_buffer_count(a, count); 927} 928 929int CameraHardwareInterface::sSetBuffersGeometry(struct preview_stream_ops* w, 930 int width, int height, int format) 931{ 932 int rc; 933 ANativeWindow *a = anw(w); 934 CameraHardwareInterface *hw = hwi(w); 935 hw->mPreviewWidth = width; 936 hw->mPreviewHeight = height; 937 hw->mPreviewFormat = format; 938 rc = native_window_set_buffers_dimensions(a, width, height); 939 if (rc == OK) { 940 rc = native_window_set_buffers_format(a, format); 941 } 942 return rc; 943} 944 945int CameraHardwareInterface::sSetCrop(struct preview_stream_ops *w, 946 int left, int top, int right, int bottom) 947{ 948 ANativeWindow *a = anw(w); 949 CameraHardwareInterface *hw = hwi(w); 950 hw->mPreviewCrop.left = left; 951 hw->mPreviewCrop.top = top; 952 hw->mPreviewCrop.right = right; 953 hw->mPreviewCrop.bottom = bottom; 954 return native_window_set_crop(a, &(hw->mPreviewCrop)); 955} 956 957int CameraHardwareInterface::sSetTimestamp(struct preview_stream_ops *w, 958 int64_t timestamp) { 959 ANativeWindow *a = anw(w); 960 return native_window_set_buffers_timestamp(a, timestamp); 961} 962 963int CameraHardwareInterface::sSetUsage(struct preview_stream_ops* w, int usage) 964{ 965 ANativeWindow *a = anw(w); 966 CameraHardwareInterface *hw = hwi(w); 967 hw->mPreviewUsage = usage; 968 return native_window_set_usage(a, usage); 969} 970 971int CameraHardwareInterface::sSetSwapInterval(struct preview_stream_ops *w, int interval) 972{ 973 ANativeWindow *a = anw(w); 974 CameraHardwareInterface *hw = hwi(w); 975 hw->mPreviewSwapInterval = interval; 976 return a->setSwapInterval(a, interval); 977} 978 979int CameraHardwareInterface::sGetMinUndequeuedBufferCount( 980 const struct preview_stream_ops *w, 981 int *count) 982{ 983 ANativeWindow *a = anw(w); 984 return a->query(a, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, count); 985} 986 987void CameraHardwareInterface::initHalPreviewWindow() 988{ 989 mHalPreviewWindow.nw.cancel_buffer = sCancelBuffer; 990 mHalPreviewWindow.nw.lock_buffer = sLockBuffer; 991 mHalPreviewWindow.nw.dequeue_buffer = sDequeueBuffer; 992 mHalPreviewWindow.nw.enqueue_buffer = sEnqueueBuffer; 993 mHalPreviewWindow.nw.set_buffer_count = sSetBufferCount; 994 mHalPreviewWindow.nw.set_buffers_geometry = sSetBuffersGeometry; 995 mHalPreviewWindow.nw.set_crop = sSetCrop; 996 mHalPreviewWindow.nw.set_timestamp = sSetTimestamp; 997 mHalPreviewWindow.nw.set_usage = sSetUsage; 998 mHalPreviewWindow.nw.set_swap_interval = sSetSwapInterval; 999 1000 mHalPreviewWindow.nw.get_min_undequeued_buffer_count = 1001 sGetMinUndequeuedBufferCount; 1002} 1003 1004}; // namespace android 1005