QCamera3HWI.cpp revision e6ab32d89cf169705236988f0f74309f914c88b7
1/* Copyright (c) 2012-2013, The Linux Foundataion. All rights reserved. 2* 3* Redistribution and use in source and binary forms, with or without 4* modification, are permitted provided that the following conditions are 5* met: 6* * Redistributions of source code must retain the above copyright 7* notice, this list of conditions and the following disclaimer. 8* * Redistributions in binary form must reproduce the above 9* copyright notice, this list of conditions and the following 10* disclaimer in the documentation and/or other materials provided 11* with the distribution. 12* * Neither the name of The Linux Foundation nor the names of its 13* contributors may be used to endorse or promote products derived 14* from this software without specific prior written permission. 15* 16* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED 17* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 18* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT 19* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS 20* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 21* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 22* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 23* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 25* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN 26* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27* 28*/ 29 30#define LOG_TAG "QCamera3HWI" 31 32#include <cutils/properties.h> 33#include <hardware/camera3.h> 34#include <camera/CameraMetadata.h> 35#include <stdlib.h> 36#include <utils/Log.h> 37#include <utils/Errors.h> 38#include <ui/Fence.h> 39#include <gralloc_priv.h> 40#include "QCamera3HWI.h" 41#include "QCamera3Mem.h" 42#include "QCamera3Channel.h" 43 44using namespace android; 45 46//using namespace android; 47namespace qcamera { 48#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX ) 49cam_capability_t *gCamCapability[MM_CAMERA_MAX_NUM_SENSORS]; 50parm_buffer_t *prevSettings; 51const camera_metadata_t *gStaticMetadata; 52 53 54camera3_device_ops_t QCamera3HardwareInterface::mCameraOps = { 55 initialize: QCamera3HardwareInterface::initialize, 56 configure_streams: QCamera3HardwareInterface::configure_streams, 57 register_stream_buffers: QCamera3HardwareInterface::register_stream_buffers, 58 construct_default_request_settings: QCamera3HardwareInterface::construct_default_request_settings, 59 process_capture_request: QCamera3HardwareInterface::process_capture_request, 60 get_metadata_vendor_tag_ops: QCamera3HardwareInterface::get_metadata_vendor_tag_ops, 61 dump: QCamera3HardwareInterface::dump, 62}; 63 64 65/*=========================================================================== 66 * FUNCTION : QCamera3HardwareInterface 67 * 68 * DESCRIPTION: constructor of QCamera3HardwareInterface 69 * 70 * PARAMETERS : 71 * @cameraId : camera ID 72 * 73 * RETURN : none 74 *==========================================================================*/ 75QCamera3HardwareInterface::QCamera3HardwareInterface(int cameraId) 76 : mCameraId(cameraId), 77 mCameraHandle(NULL), 78 mCameraOpened(false), 79 mCallbackOps(NULL) 80{ 81 mCameraDevice.common.tag = HARDWARE_DEVICE_TAG; 82 mCameraDevice.common.version = CAMERA_DEVICE_API_VERSION_3_0; 83 mCameraDevice.common.close = close_camera_device; 84 mCameraDevice.ops = &mCameraOps; 85 mCameraDevice.priv = this; 86 gCamCapability[cameraId]->version = CAM_HAL_V3; 87 88 pthread_mutex_init(&mRequestLock, NULL); 89 pthread_cond_init(&mRequestCond, NULL); 90 mPendingRequest = 0; 91 92 pthread_mutex_init(&mMutex, NULL); 93} 94 95/*=========================================================================== 96 * FUNCTION : ~QCamera3HardwareInterface 97 * 98 * DESCRIPTION: destructor of QCamera2HardwareInterface 99 * 100 * PARAMETERS : none 101 * 102 * RETURN : none 103 *==========================================================================*/ 104QCamera3HardwareInterface::~QCamera3HardwareInterface() 105{ 106 closeCamera(); 107 108 pthread_mutex_destroy(&mRequestLock); 109 pthread_cond_destroy(&mRequestCond); 110 111 pthread_mutex_destroy(&mMutex); 112} 113 114/*=========================================================================== 115 * FUNCTION : openCamera 116 * 117 * DESCRIPTION: open camera 118 * 119 * PARAMETERS : 120 * @hw_device : double ptr for camera device struct 121 * 122 * RETURN : int32_t type of status 123 * NO_ERROR -- success 124 * none-zero failure code 125 *==========================================================================*/ 126int QCamera3HardwareInterface::openCamera(struct hw_device_t **hw_device) 127{ 128 //int rc = NO_ERROR; 129 int rc = 0; 130 if (mCameraOpened) { 131 *hw_device = NULL; 132 return PERMISSION_DENIED; 133 } 134 135 rc = openCamera(); 136 if (rc == 0) 137 *hw_device = &mCameraDevice.common; 138 else 139 *hw_device = NULL; 140 return rc; 141} 142 143/*=========================================================================== 144 * FUNCTION : openCamera 145 * 146 * DESCRIPTION: open camera 147 * 148 * PARAMETERS : none 149 * 150 * RETURN : int32_t type of status 151 * NO_ERROR -- success 152 * none-zero failure code 153 *==========================================================================*/ 154int QCamera3HardwareInterface::openCamera() 155{ 156 if (mCameraHandle) { 157 ALOGE("Failure: Camera already opened"); 158 return ALREADY_EXISTS; 159 } 160 mCameraHandle = camera_open(mCameraId); 161 if (!mCameraHandle) { 162 ALOGE("camera_open failed."); 163 return UNKNOWN_ERROR; 164 } 165 166 mCameraOpened = true; 167 168 return NO_ERROR; 169} 170 171/*=========================================================================== 172 * FUNCTION : closeCamera 173 * 174 * DESCRIPTION: close camera 175 * 176 * PARAMETERS : none 177 * 178 * RETURN : int32_t type of status 179 * NO_ERROR -- success 180 * none-zero failure code 181 *==========================================================================*/ 182int QCamera3HardwareInterface::closeCamera() 183{ 184 int rc = NO_ERROR; 185 186 rc = mCameraHandle->ops->close_camera(mCameraHandle->camera_handle); 187 mCameraHandle = NULL; 188 mCameraOpened = false; 189 190 return rc; 191} 192 193/*=========================================================================== 194 * FUNCTION : sendCaptureResult 195 * 196 * DESCRIPTION: send completed capture result metadata buffer along with possibly 197 * completed output stream buffers to the framework 198 * 199 * PARAMETERS : 200 * 201 * RETURN : 202 *==========================================================================*/ 203void QCamera3HardwareInterface::sendCaptureResult(const struct camera3_callback_ops *, 204 const camera3_capture_result_t *result) 205{ 206 //TODO - Implement 207} 208 209/*=========================================================================== 210 * FUNCTION : notify 211 * 212 * DESCRIPTION: Asynchronous notification callback to framework 213 * 214 * PARAMETERS : 215 * 216 * RETURN : 217 * 218 * 219 *==========================================================================*/ 220 221void QCamera3HardwareInterface::notify(const struct camera3_callback_ops *, 222 const camera3_notify_msg_t *msg) 223{ 224 //TODO - Implement 225} 226 227 228/*=========================================================================== 229 * FUNCTION : initialize 230 * 231 * DESCRIPTION: Initialize frameworks callback functions 232 * 233 * PARAMETERS : 234 * @callback_ops : callback function to frameworks 235 * 236 * RETURN : 237 * 238 *==========================================================================*/ 239int QCamera3HardwareInterface::initialize( 240 const struct camera3_callback_ops *callback_ops) 241{ 242 int rc; 243 244 pthread_mutex_lock(&mMutex); 245 246 //Create metadata channel and initialize it 247 mMetadataChannel = new QCamera3MetadataChannel(mCameraHandle->camera_handle, 248 mCameraHandle->ops, captureResultCb, 249 &gCamCapability[mCameraId]->padding_info, this); 250 if (mMetadataChannel == NULL) { 251 ALOGE("%s: failed to allocate metadata channel", __func__); 252 rc = -ENOMEM; 253 goto err1; 254 } 255 rc = mMetadataChannel->initialize(); 256 if (rc < 0) { 257 ALOGE("%s: metadata channel initialization failed", __func__); 258 goto err2; 259 } 260 261 /* Initialize parameter heap and structure */ 262 mParamHeap = new QCamera3HeapMemory(); 263 if (mParamHeap == NULL) { 264 ALOGE("%s: creation of mParamHeap failed", __func__); 265 goto err2; 266 } 267 rc = mParamHeap->allocate(1, sizeof(parm_buffer_t), false); 268 if (rc < 0) { 269 ALOGE("%s: allocation of mParamHeap failed", __func__); 270 goto err3; 271 } 272 rc = mCameraHandle->ops->map_buf(mCameraHandle->camera_handle, 273 CAM_MAPPING_BUF_TYPE_PARM_BUF, 274 mParamHeap->getFd(0), sizeof(parm_buffer_t)); 275 if (rc < 0) { 276 ALOGE("%s: map_buf failed for mParamHeap", __func__); 277 goto err4; 278 } 279 mParameters = (parm_buffer_t *)DATA_PTR(mParamHeap, 0); 280 281 mCallbackOps = callback_ops; 282 283 pthread_mutex_unlock(&mMutex); 284 return 0; 285 286err4: 287 mParamHeap->deallocate(); 288err3: 289 delete mParamHeap; 290 mParamHeap = NULL; 291err2: 292 delete mMetadataChannel; 293 mMetadataChannel = NULL; 294err1: 295 pthread_mutex_unlock(&mMutex); 296 return rc; 297} 298 299/*=========================================================================== 300 * FUNCTION : configureStreams 301 * 302 * DESCRIPTION: Reset HAL camera device processing pipeline and set up new input 303 * and output streams. 304 * 305 * PARAMETERS : 306 * @stream_list : streams to be configured 307 * 308 * RETURN : 309 * 310 *==========================================================================*/ 311int QCamera3HardwareInterface::configureStreams( 312 camera3_stream_configuration_t *streamList) 313{ 314 pthread_mutex_lock(&mMutex); 315 316 // Sanity check stream_list 317 if (streamList == NULL) { 318 ALOGE("%s: NULL stream configuration", __func__); 319 pthread_mutex_unlock(&mMutex); 320 return BAD_VALUE; 321 } 322 323 if (streamList->streams == NULL) { 324 ALOGE("%s: NULL stream list", __func__); 325 pthread_mutex_unlock(&mMutex); 326 return BAD_VALUE; 327 } 328 329 if (streamList->num_streams < 1) { 330 ALOGE("%s: Bad number of streams requested: %d", __func__, 331 streamList->num_streams); 332 pthread_mutex_unlock(&mMutex); 333 return BAD_VALUE; 334 } 335 336 camera3_stream_t *inputStream = NULL; 337 for (size_t i = 0; i < streamList->num_streams; i++) { 338 camera3_stream_t *newStream = streamList->streams[i]; 339 if (newStream->stream_type == CAMERA3_STREAM_INPUT) { 340 if (inputStream != NULL) { 341 ALOGE("%s: Multiple input streams requested!", __func__); 342 pthread_mutex_unlock(&mMutex); 343 return BAD_VALUE; 344 } 345 inputStream = newStream; 346 } 347 } 348 mInputStream = inputStream; 349 350 /* TODO: Clean up no longer used streams, and maintain others if this 351 * is not the 1st time configureStreams is called */ 352 353 mMetadataChannel->stop(); 354 355 /* Allocate channel objects for the requested streams */ 356 for (size_t i = 0; i < streamList->num_streams; i++) { 357 camera3_stream_t *newStream = streamList->streams[i]; 358 if (newStream->priv == NULL) { 359 //New stream, construct channel 360 361 switch (newStream->stream_type) { 362 case CAMERA3_STREAM_INPUT: 363 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ; 364 newStream->max_buffers = QCamera3PicChannel::kMaxBuffers; 365 break; 366 case CAMERA3_STREAM_BIDIRECTIONAL: 367 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ | 368 GRALLOC_USAGE_HW_CAMERA_WRITE; 369 newStream->max_buffers = QCamera3RegularChannel::kMaxBuffers; 370 break; 371 case CAMERA3_STREAM_OUTPUT: 372 newStream->usage = GRALLOC_USAGE_HW_CAMERA_WRITE; 373 newStream->max_buffers = QCamera3RegularChannel::kMaxBuffers; 374 break; 375 default: 376 ALOGE("%s: Invalid stream_type %d", __func__, newStream->stream_type); 377 break; 378 } 379 380 if (newStream->stream_type == CAMERA3_STREAM_OUTPUT || 381 newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL) { 382 QCamera3Channel *channel; 383 switch (newStream->format) { 384 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 385 channel = new QCamera3RegularChannel(mCameraHandle->camera_handle, 386 mCameraHandle->ops, captureResultCb, 387 &gCamCapability[mCameraId]->padding_info, this, newStream); 388 if (channel == NULL) { 389 ALOGE("%s: allocation of channel failed", __func__); 390 pthread_mutex_unlock(&mMutex); 391 return -ENOMEM; 392 } 393 394 newStream->priv = channel; 395 break; 396 case HAL_PIXEL_FORMAT_BLOB: 397 channel = new QCamera3PicChannel(mCameraHandle->camera_handle, 398 mCameraHandle->ops, captureResultCb, 399 &gCamCapability[mCameraId]->padding_info, this, newStream); 400 if (channel == NULL) { 401 ALOGE("%s: allocation of channel failed", __func__); 402 pthread_mutex_unlock(&mMutex); 403 return -ENOMEM; 404 } 405 406 newStream->priv = channel; 407 break; 408 409 //TODO: Add support for app consumed format? 410 default: 411 ALOGE("%s: not a supported format 0x%x", __func__, newStream->format); 412 break; 413 } 414 } 415 } else { 416 // Channel already exists for this stream 417 // Do nothing for now 418 } 419 } 420 421 // Cannot reuse settings across configure call 422 memset(mParameters, 0, sizeof(parm_buffer_t)); 423 pthread_mutex_unlock(&mMutex); 424 return 0; 425} 426 427/*=========================================================================== 428 * FUNCTION : validateCaptureRequest 429 * 430 * DESCRIPTION: validate a capture request from camera service 431 * 432 * PARAMETERS : 433 * @request : request from framework to process 434 * 435 * RETURN : 436 * 437 *==========================================================================*/ 438int QCamera3HardwareInterface::validateCaptureRequest( 439 camera3_capture_request_t *request) 440{ 441 int rc = NO_ERROR; 442 ssize_t idx = 0; 443 const camera3_stream_buffer_t *b; 444 CameraMetadata meta; 445 446 /* Sanity check the request */ 447 if (request == NULL) { 448 ALOGE("%s: NULL capture request", __func__); 449 return BAD_VALUE; 450 } 451 452 uint32_t frameNumber = request->frame_number; 453 if (request->input_buffer != NULL && 454 request->input_buffer->stream != mInputStream) { 455 ALOGE("%s: Request %d: Input buffer not from input stream!", 456 __FUNCTION__, frameNumber); 457 return BAD_VALUE; 458 } 459 if (request->num_output_buffers < 1 || request->output_buffers == NULL) { 460 ALOGE("%s: Request %d: No output buffers provided!", 461 __FUNCTION__, frameNumber); 462 return BAD_VALUE; 463 } 464 if (request->input_buffer != NULL) { 465 //TODO 466 ALOGE("%s: Not supporting input buffer yet", __func__); 467 return BAD_VALUE; 468 } 469 470 // Validate all buffers 471 b = request->output_buffers; 472 do { 473 QCamera3Channel *channel = 474 static_cast<QCamera3Channel*>(b->stream->priv); 475 if (channel == NULL) { 476 ALOGE("%s: Request %d: Buffer %d: Unconfigured stream!", 477 __func__, frameNumber, idx); 478 return BAD_VALUE; 479 } 480 if (b->status != CAMERA3_BUFFER_STATUS_OK) { 481 ALOGE("%s: Request %d: Buffer %d: Status not OK!", 482 __func__, frameNumber, idx); 483 return BAD_VALUE; 484 } 485 if (b->release_fence != -1) { 486 ALOGE("%s: Request %d: Buffer %d: Has a release fence!", 487 __func__, frameNumber, idx); 488 return BAD_VALUE; 489 } 490 if (b->buffer == NULL) { 491 ALOGE("%s: Request %d: Buffer %d: NULL buffer handle!", 492 __func__, frameNumber, idx); 493 return BAD_VALUE; 494 } 495 idx++; 496 b = request->output_buffers + idx; 497 } while (idx < (ssize_t)request->num_output_buffers); 498 499 return NO_ERROR; 500} 501 502/*=========================================================================== 503 * FUNCTION : registerStreamBuffers 504 * 505 * DESCRIPTION: Register buffers for a given stream with the HAL device. 506 * 507 * PARAMETERS : 508 * @stream_list : streams to be configured 509 * 510 * RETURN : 511 * 512 *==========================================================================*/ 513int QCamera3HardwareInterface::registerStreamBuffers( 514 const camera3_stream_buffer_set_t *buffer_set) 515{ 516 int rc = 0; 517 518 pthread_mutex_lock(&mMutex); 519 520 if (buffer_set == NULL) { 521 ALOGE("%s: Invalid buffer_set parameter.", __func__); 522 pthread_mutex_unlock(&mMutex); 523 return -EINVAL; 524 } 525 if (buffer_set->stream == NULL) { 526 ALOGE("%s: Invalid stream parameter.", __func__); 527 pthread_mutex_unlock(&mMutex); 528 return -EINVAL; 529 } 530 if (buffer_set->num_buffers < 1) { 531 ALOGE("%s: Invalid num_buffers %d.", __func__, buffer_set->num_buffers); 532 pthread_mutex_unlock(&mMutex); 533 return -EINVAL; 534 } 535 if (buffer_set->buffers == NULL) { 536 ALOGE("%s: Invalid buffers parameter.", __func__); 537 pthread_mutex_unlock(&mMutex); 538 return -EINVAL; 539 } 540 541 camera3_stream_t *stream = buffer_set->stream; 542 QCamera3Channel *channel = (QCamera3Channel *)stream->priv; 543 544 if (stream->stream_type != CAMERA3_STREAM_OUTPUT) { 545 ALOGE("%s: not yet support non output type stream", __func__); 546 pthread_mutex_unlock(&mMutex); 547 return -EINVAL; 548 } 549 rc = channel->registerBuffers(buffer_set->num_buffers, buffer_set->buffers); 550 if (rc < 0) { 551 ALOGE("%s: registerBUffers for stream %p failed", __func__, stream); 552 pthread_mutex_unlock(&mMutex); 553 return -ENODEV; 554 } 555 556 pthread_mutex_unlock(&mMutex); 557 return NO_ERROR; 558} 559 560/*=========================================================================== 561 * FUNCTION : processCaptureRequest 562 * 563 * DESCRIPTION: process a capture request from camera service 564 * 565 * PARAMETERS : 566 * @request : request from framework to process 567 * 568 * RETURN : 569 * 570 *==========================================================================*/ 571int QCamera3HardwareInterface::processCaptureRequest( 572 camera3_capture_request_t *request) 573{ 574 int rc = NO_ERROR; 575 ssize_t idx = 0; 576 const camera3_stream_buffer_t *b; 577 CameraMetadata meta; 578 579 pthread_mutex_lock(&mMutex); 580 581 rc = validateCaptureRequest(request); 582 if (rc != NO_ERROR) { 583 ALOGE("%s: incoming request is not valid", __func__); 584 pthread_mutex_unlock(&mMutex); 585 return rc; 586 } 587 588 uint32_t frameNumber = request->frame_number; 589 590 rc = setFrameParameters(request->settings); 591 if (rc < 0) { 592 ALOGE("%s: fail to set frame parameters", __func__); 593 pthread_mutex_unlock(&mMutex); 594 return rc; 595 } 596 597 // Acquire all request buffers first 598 for (size_t i = 0; i < request->num_output_buffers; i++) { 599 const camera3_stream_buffer_t& output = request->output_buffers[i]; 600 sp<Fence> acquireFence = new Fence(output.acquire_fence); 601 rc = acquireFence->wait(Fence::TIMEOUT_NEVER); 602 if (rc != OK) { 603 ALOGE("%s: fence wait failed %d", __func__, rc); 604 pthread_mutex_unlock(&mMutex); 605 return rc; 606 } 607 } 608 609 // Notify metadata channel we receive a request 610 mMetadataChannel->request(NULL, frameNumber); 611 612 // Call request on other streams 613 for (size_t i = 0; i < request->num_output_buffers; i++) { 614 const camera3_stream_buffer_t& output = request->output_buffers[i]; 615 QCamera3Channel *channel = (QCamera3Channel *)output.stream->priv; 616 if (channel == NULL) { 617 ALOGE("%s: invalid channel pointer for stream", __func__); 618 continue; 619 } 620 621 rc = channel->request(output.buffer, frameNumber); 622 if (rc < 0) 623 ALOGE("%s: request failed", __func__); 624 } 625 626 //Block on conditional variable 627 pthread_mutex_lock(&mRequestLock); 628 mPendingRequest = 1; 629 while (mPendingRequest == 1) { 630 pthread_cond_wait(&mRequestCond, &mRequestLock); 631 } 632 pthread_mutex_unlock(&mRequestLock); 633 634 pthread_mutex_unlock(&mMutex); 635 return rc; 636} 637 638/*=========================================================================== 639 * FUNCTION : getMetadataVendorTagOps 640 * 641 * DESCRIPTION: 642 * 643 * PARAMETERS : 644 * 645 * 646 * RETURN : 647 *==========================================================================*/ 648void QCamera3HardwareInterface::getMetadataVendorTagOps(vendor_tag_query_ops_t* ops) 649{ 650 /* Enable locks when we eventually add Vendor Tags */ 651 /* 652 pthread_mutex_lock(&mMutex); 653 654 pthread_mutex_unlock(&mMutex); 655 */ 656 return; 657} 658 659/*=========================================================================== 660 * FUNCTION : dump 661 * 662 * DESCRIPTION: 663 * 664 * PARAMETERS : 665 * 666 * 667 * RETURN : 668 *==========================================================================*/ 669void QCamera3HardwareInterface::dump(int fd) 670{ 671 /*Enable lock when we implement this function*/ 672 /* 673 pthread_mutex_lock(&mMutex); 674 675 pthread_mutex_unlock(&mMutex); 676 */ 677 return; 678} 679 680/*=========================================================================== 681 * FUNCTION : captureResultCb 682 * 683 * DESCRIPTION: Callback handler for all capture result (streams, as well as metadata) 684 * 685 * PARAMETERS : 686 * @metadata : metadata information 687 * @buffer : actual gralloc buffer to be returned to frameworks. NULL if metadata. 688 * 689 * RETURN : NONE 690 *==========================================================================*/ 691void QCamera3HardwareInterface::captureResultCb(metadata_buffer_t *metadata, 692 camera3_stream_buffer_t *buffer, uint32_t frame_number) 693{ 694 pthread_mutex_lock(&mCaptureResultLock); 695 camera3_capture_result_t result; 696 697 698 if (metadata) { 699 // Signal to unblock processCaptureRequest 700 pthread_mutex_lock(&mRequestLock); 701 mPendingRequest = 0; 702 pthread_cond_signal(&mRequestCond); 703 pthread_mutex_unlock(&mRequestLock); 704 705 //TODO: Add translation from metadata_buffer_t to CameraMetadata 706 // for now, hardcode timestamp only. 707 CameraMetadata camMetadata; 708 uint32_t *frame_number = (uint32_t *)POINTER_OF(CAM_INTF_META_FRAME_NUMBER, metadata); 709 nsecs_t captureTime = 1000000 * (*frame_number) * 33; 710 camMetadata.update(ANDROID_SENSOR_TIMESTAMP, &captureTime, 1); 711 712 result.result = camMetadata.release(); 713 if (!result.result) { 714 result.frame_number = *frame_number; 715 result.num_output_buffers = 0; 716 result.output_buffers = NULL; 717 mCallbackOps->process_capture_result(mCallbackOps, &result); 718 719 free_camera_metadata((camera_metadata_t*)result.result); 720 } 721 } else { 722 result.result = NULL; 723 result.frame_number = frame_number; 724 result.num_output_buffers = 1; 725 result.output_buffers = buffer; 726 mCallbackOps->process_capture_result(mCallbackOps, &result); 727 } 728 729 pthread_mutex_unlock(&mCaptureResultLock); 730 return; 731} 732 733#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX ) 734/*=========================================================================== 735 * FUNCTION : initCapabilities 736 * 737 * DESCRIPTION: initialize camera capabilities in static data struct 738 * 739 * PARAMETERS : 740 * @cameraId : camera Id 741 * 742 * RETURN : int32_t type of status 743 * NO_ERROR -- success 744 * none-zero failure code 745 *==========================================================================*/ 746int QCamera3HardwareInterface::initCapabilities(int cameraId) 747{ 748 int rc = 0; 749 mm_camera_vtbl_t *cameraHandle = NULL; 750 QCamera3HeapMemory *capabilityHeap = NULL; 751 752 cameraHandle = camera_open(cameraId); 753 if (!cameraHandle) { 754 ALOGE("%s: camera_open failed", __func__); 755 rc = -1; 756 goto open_failed; 757 } 758 759 capabilityHeap = new QCamera3HeapMemory(); 760 if (capabilityHeap == NULL) { 761 ALOGE("%s: creation of capabilityHeap failed", __func__); 762 goto heap_creation_failed; 763 } 764 /* Allocate memory for capability buffer */ 765 rc = capabilityHeap->allocate(1, sizeof(cam_capability_t), false); 766 if(rc != OK) { 767 ALOGE("%s: No memory for cappability", __func__); 768 goto allocate_failed; 769 } 770 771 /* Map memory for capability buffer */ 772 memset(DATA_PTR(capabilityHeap,0), 0, sizeof(cam_capability_t)); 773 rc = cameraHandle->ops->map_buf(cameraHandle->camera_handle, 774 CAM_MAPPING_BUF_TYPE_CAPABILITY, 775 capabilityHeap->getFd(0), 776 sizeof(cam_capability_t)); 777 if(rc < 0) { 778 ALOGE("%s: failed to map capability buffer", __func__); 779 goto map_failed; 780 } 781 782 /* Query Capability */ 783 rc = cameraHandle->ops->query_capability(cameraHandle->camera_handle); 784 if(rc < 0) { 785 ALOGE("%s: failed to query capability",__func__); 786 goto query_failed; 787 } 788 gCamCapability[cameraId] = (cam_capability_t *)malloc(sizeof(cam_capability_t)); 789 if (!gCamCapability[cameraId]) { 790 ALOGE("%s: out of memory", __func__); 791 goto query_failed; 792 } 793 memcpy(gCamCapability[cameraId], DATA_PTR(capabilityHeap,0), 794 sizeof(cam_capability_t)); 795 rc = 0; 796 797query_failed: 798 cameraHandle->ops->unmap_buf(cameraHandle->camera_handle, 799 CAM_MAPPING_BUF_TYPE_CAPABILITY); 800map_failed: 801 capabilityHeap->deallocate(); 802allocate_failed: 803 delete capabilityHeap; 804heap_creation_failed: 805 cameraHandle->ops->close_camera(cameraHandle->camera_handle); 806 cameraHandle = NULL; 807open_failed: 808 return rc; 809} 810 811/*=========================================================================== 812 * FUNCTION : initStaticMetadata 813 * 814 * DESCRIPTION: initialize the static metadata 815 * 816 * PARAMETERS : 817 * @cameraId : camera Id 818 * 819 * RETURN : int32_t type of status 820 * 0 -- success 821 * non-zero failure code 822 *==========================================================================*/ 823int QCamera3HardwareInterface::initStaticMetadata(int cameraId) 824{ 825 int rc = 0; 826 android::CameraMetadata staticInfo; 827 828 staticInfo.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 829 &gCamCapability[cameraId]->min_focus_distance, 1); 830 831 staticInfo.update(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, 832 &gCamCapability[cameraId]->hyper_focal_distance, 1); 833 834 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, 835 gCamCapability[cameraId]->focal_lengths, 836 gCamCapability[cameraId]->focal_lengths_count); 837 838 839 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_APERTURES, 840 gCamCapability[cameraId]->apertures, 841 gCamCapability[cameraId]->apertures_count); 842 843 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, 844 gCamCapability[cameraId]->filter_densities, 845 gCamCapability[cameraId]->filter_densities_count); 846 847 848 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, 849 (int*)gCamCapability[cameraId]->optical_stab_modes, 850 gCamCapability[cameraId]->optical_stab_modes_count); 851 852 staticInfo.update(ANDROID_LENS_POSITION, 853 gCamCapability[cameraId]->lens_position, 854 sizeof(gCamCapability[cameraId]->lens_position)/ sizeof(float)); 855 856 static const int32_t lens_shading_map_size[] = {gCamCapability[cameraId]->lens_shading_map_size.width, 857 gCamCapability[cameraId]->lens_shading_map_size.height}; 858 staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE, 859 lens_shading_map_size, 860 sizeof(lens_shading_map_size)/sizeof(int32_t)); 861 862 staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP, gCamCapability[cameraId]->lens_shading_map, 863 sizeof(gCamCapability[cameraId]->lens_shading_map_size)/ sizeof(cam_dimension_t)); 864 865 static const int32_t geo_correction_map_size[] = {gCamCapability[cameraId]->geo_correction_map_size.width, 866 gCamCapability[cameraId]->geo_correction_map_size.height}; 867 staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE, 868 geo_correction_map_size, 869 sizeof(geo_correction_map_size)/sizeof(int32_t)); 870 871 staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP, 872 gCamCapability[cameraId]->geo_correction_map, 873 sizeof(gCamCapability[cameraId]->geo_correction_map_size)/ sizeof(cam_dimension_t)); 874 875 staticInfo.update(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, 876 gCamCapability[cameraId]->sensor_physical_size, 2); 877 878 staticInfo.update(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, 879 gCamCapability[cameraId]->exposure_time_range, 2); 880 881 staticInfo.update(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, 882 &gCamCapability[cameraId]->max_frame_duration, 1); 883 884 885 staticInfo.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, 886 (int*)&gCamCapability[cameraId]->color_arrangement, 1); 887 888 static const int32_t pixel_array_size[] = {gCamCapability[cameraId]->pixel_array_size.width, 889 gCamCapability[cameraId]->pixel_array_size.height}; 890 staticInfo.update(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, 891 pixel_array_size, 2); 892 893 static const int32_t active_array_size[] = {gCamCapability[cameraId]->active_array_size.width, 894 gCamCapability[cameraId]->active_array_size.height}; 895 staticInfo.update(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, 896 active_array_size, 2); 897 898 staticInfo.update(ANDROID_SENSOR_INFO_WHITE_LEVEL, 899 &gCamCapability[cameraId]->white_level, 1); 900 901 staticInfo.update(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, 902 gCamCapability[cameraId]->black_level_pattern, 4); 903 904 staticInfo.update(ANDROID_FLASH_INFO_CHARGE_DURATION, 905 &gCamCapability[cameraId]->flash_charge_duration, 1); 906 907 staticInfo.update(ANDROID_TONEMAP_MAX_CURVE_POINTS, 908 &gCamCapability[cameraId]->max_tone_map_curve_points, 1); 909 910 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 911 (int*)&gCamCapability[cameraId]->max_face_detection_count, 1); 912 913 staticInfo.update(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT, 914 &gCamCapability[cameraId]->histogram_size, 1); 915 916 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT, 917 &gCamCapability[cameraId]->max_histogram_count, 1); 918 919 static const int32_t sharpness_map_size[] = {gCamCapability[cameraId]->sharpness_map_size.width, 920 gCamCapability[cameraId]->sharpness_map_size.height}; 921 922 staticInfo.update(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE, 923 sharpness_map_size, sizeof(sharpness_map_size)/sizeof(int32_t)); 924 925 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE, 926 &gCamCapability[cameraId]->max_sharpness_map_value, 1); 927 928 929 staticInfo.update(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS, 930 &gCamCapability[cameraId]->raw_min_duration, 931 1); 932 933 static const int32_t exposureCompensationRange[] = {gCamCapability[cameraId]->exposure_compensation_min, 934 gCamCapability[cameraId]->exposure_compensation_max}; 935 staticInfo.update(ANDROID_CONTROL_AE_COMPENSATION_RANGE, 936 exposureCompensationRange, 937 sizeof(exposureCompensationRange)/sizeof(int32_t)); 938 939 uint8_t lensFacing = (gCamCapability[cameraId]->position == CAM_POSITION_BACK) ? 940 ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; 941 staticInfo.update(ANDROID_LENS_FACING, &lensFacing, 1); 942 943 gStaticMetadata = staticInfo.release(); 944 return rc; 945} 946 947/*=========================================================================== 948 * FUNCTION : getCapabilities 949 * 950 * DESCRIPTION: query camera capabilities 951 * 952 * PARAMETERS : 953 * @cameraId : camera Id 954 * @info : camera info struct to be filled in with camera capabilities 955 * 956 * RETURN : int32_t type of status 957 * NO_ERROR -- success 958 * none-zero failure code 959 *==========================================================================*/ 960int QCamera3HardwareInterface::getCamInfo(int cameraId, 961 struct camera_info *info) 962{ 963 int rc = 0; 964 965 if (NULL == gCamCapability[cameraId]) { 966 rc = initCapabilities(cameraId); 967 if (rc < 0) { 968 //pthread_mutex_unlock(&g_camlock); 969 return rc; 970 } 971 } 972 973 if (NULL == gStaticMetadata) { 974 rc = initStaticMetadata(cameraId); 975 if (rc < 0) { 976 return rc; 977 } 978 } 979 980 switch(gCamCapability[cameraId]->position) { 981 case CAM_POSITION_BACK: 982 info->facing = CAMERA_FACING_BACK; 983 break; 984 985 case CAM_POSITION_FRONT: 986 info->facing = CAMERA_FACING_FRONT; 987 break; 988 989 default: 990 ALOGE("%s:Unknown position type for camera id:%d", __func__, cameraId); 991 rc = -1; 992 break; 993 } 994 995 996 info->orientation = gCamCapability[cameraId]->sensor_mount_angle; 997 info->device_version = HARDWARE_DEVICE_API_VERSION(3, 0); 998 info->static_camera_characteristics = gStaticMetadata; 999 1000 return rc; 1001} 1002 1003/*=========================================================================== 1004 * FUNCTION : translateMetadata 1005 * 1006 * DESCRIPTION: translate the metadata into camera_metadata_t 1007 * 1008 * PARAMETERS : type of the request 1009 * 1010 * 1011 * RETURN : success: camera_metadata_t* 1012 * failure: NULL 1013 * 1014 *==========================================================================*/ 1015camera_metadata_t* QCamera3HardwareInterface::translateMetadata(int type) 1016{ 1017 pthread_mutex_lock(&mMutex); 1018 1019 if (mDefaultMetadata[type] != NULL) { 1020 pthread_mutex_unlock(&mMutex); 1021 return mDefaultMetadata[type]; 1022 } 1023 //first time we are handling this request 1024 //fill up the metadata structure using the wrapper class 1025 android::CameraMetadata settings; 1026 //translate from cam_capability_t to camera_metadata_tag_t 1027 static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE; 1028 settings.update(ANDROID_REQUEST_TYPE, &requestType, 1); 1029 1030 /*control*/ 1031 1032 uint8_t controlIntent = 0; 1033 switch (type) { 1034 case CAMERA3_TEMPLATE_PREVIEW: 1035 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; 1036 break; 1037 case CAMERA3_TEMPLATE_STILL_CAPTURE: 1038 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE; 1039 break; 1040 case CAMERA3_TEMPLATE_VIDEO_RECORD: 1041 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD; 1042 break; 1043 case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT: 1044 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT; 1045 break; 1046 case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG: 1047 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG; 1048 break; 1049 default: 1050 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM; 1051 break; 1052 } 1053 settings.update(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1); 1054 1055 settings.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, 1056 &gCamCapability[mCameraId]->exposure_compensation_default, 1); 1057 1058 static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF; 1059 settings.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1); 1060 1061 static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF; 1062 settings.update(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1); 1063 1064 static const uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO; 1065 settings.update(ANDROID_CONTROL_AWB_MODE, &awbMode, 1); 1066 1067 static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO; 1068 settings.update(ANDROID_CONTROL_MODE, &controlMode, 1); 1069 1070 static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; 1071 settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); 1072 1073 static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; //similar to AUTO? 1074 settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); 1075 1076 /*flash*/ 1077 static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF; 1078 settings.update(ANDROID_FLASH_MODE, &flashMode, 1); 1079 1080 1081 /* lens */ 1082 static const float default_aperture = gCamCapability[mCameraId]->apertures[0]; 1083 settings.update(ANDROID_LENS_APERTURE, &default_aperture, 1); 1084 1085 static const float default_filter_density = gCamCapability[mCameraId]->filter_densities[0]; 1086 settings.update(ANDROID_LENS_FILTER_DENSITY, &default_filter_density, 1); 1087 1088 static const float default_focal_length = gCamCapability[mCameraId]->focal_lengths[0]; 1089 settings.update(ANDROID_LENS_FOCAL_LENGTH, &default_focal_length, 1); 1090 1091 mDefaultMetadata[type] = settings.release(); 1092 1093 pthread_mutex_unlock(&mMutex); 1094 return mDefaultMetadata[type]; 1095} 1096 1097/*=========================================================================== 1098 * FUNCTION : setFrameParameters 1099 * 1100 * DESCRIPTION: set parameters per frame as requested in the metadata from 1101 * framework 1102 * 1103 * PARAMETERS : 1104 * @settings : frame settings information from framework 1105 * 1106 * 1107 * RETURN : success: NO_ERROR 1108 * failure: 1109 *==========================================================================*/ 1110int QCamera3HardwareInterface::setFrameParameters(const camera_metadata_t *settings) 1111{ 1112 /*translate from camera_metadata_t type to parm_type_t*/ 1113 int rc = 0; 1114 android::CameraMetadata frame_settings; 1115 if (settings == NULL && prevSettings == NULL) { 1116 /*settings cannot be null for the first request*/ 1117 return BAD_VALUE; 1118 } else if (settings == NULL) { 1119 /*do nothing? we have already configured the settings previously*/ 1120 } else{ 1121 //reset the prevSettings 1122 if (prevSettings != NULL) { 1123 free(prevSettings); 1124 prevSettings = NULL; 1125 } 1126 rc = translateMetadataToParameters(settings); 1127 } 1128 /*set the parameters to backend*/ 1129 return rc; 1130} 1131 1132/*=========================================================================== 1133 * FUNCTION : translateMetadataToParameters 1134 * 1135 * DESCRIPTION: read from the camera_metadata_t and change to parm_type_t 1136 * 1137 * 1138 * PARAMETERS : 1139 * @settings : frame settings information from framework 1140 * 1141 * 1142 * RETURN : success: NO_ERROR 1143 * failure: 1144 *==========================================================================*/ 1145int QCamera3HardwareInterface::translateMetadataToParameters 1146 (const camera_metadata_t *settings) 1147{ 1148 return 0; 1149} 1150 1151/*=========================================================================== 1152 * FUNCTION : captureResultCb 1153 * 1154 * DESCRIPTION: Callback handler for all channels (streams, as well as metadata) 1155 * 1156 * PARAMETERS : 1157 * @frame : frame information from mm-camera-interface 1158 * @buffer : actual gralloc buffer to be returned to frameworks. NULL if metadata. 1159 * @userdata: userdata 1160 * 1161 * RETURN : NONE 1162 *==========================================================================*/ 1163void QCamera3HardwareInterface::captureResultCb(metadata_buffer_t *metadata, 1164 camera3_stream_buffer_t *buffer, 1165 uint32_t frame_number, void *userdata) 1166{ 1167 QCamera3HardwareInterface *hw = (QCamera3HardwareInterface *)userdata; 1168 if (hw == NULL) { 1169 ALOGE("%s: Invalid hw %p", __func__, hw); 1170 return; 1171 } 1172 1173 hw->captureResultCb(metadata, buffer, frame_number); 1174 return; 1175} 1176 1177/*=========================================================================== 1178 * FUNCTION : initialize 1179 * 1180 * DESCRIPTION: Pass framework callback pointers to HAL 1181 * 1182 * PARAMETERS : 1183 * 1184 * 1185 * RETURN : Success : 0 1186 * Failure: -ENODEV 1187 *==========================================================================*/ 1188 1189int QCamera3HardwareInterface::initialize(const struct camera3_device *device, 1190 const camera3_callback_ops_t *callback_ops) 1191{ 1192 QCamera3HardwareInterface *hw = 1193 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 1194 if (!hw) { 1195 ALOGE("%s: NULL camera device", __func__); 1196 return -ENODEV; 1197 } 1198 1199 return hw->initialize(callback_ops); 1200} 1201 1202/*=========================================================================== 1203 * FUNCTION : configure_streams 1204 * 1205 * DESCRIPTION: 1206 * 1207 * PARAMETERS : 1208 * 1209 * 1210 * RETURN : Success: 0 1211 * Failure: -EINVAL (if stream configuration is invalid) 1212 * -ENODEV (fatal error) 1213 *==========================================================================*/ 1214 1215int QCamera3HardwareInterface::configure_streams( 1216 const struct camera3_device *device, 1217 camera3_stream_configuration_t *stream_list) 1218{ 1219 QCamera3HardwareInterface *hw = 1220 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 1221 if (!hw) { 1222 ALOGE("%s: NULL camera device", __func__); 1223 return -ENODEV; 1224 } 1225 return hw->configureStreams(stream_list); 1226} 1227 1228/*=========================================================================== 1229 * FUNCTION : register_stream_buffers 1230 * 1231 * DESCRIPTION: Register stream buffers with the device 1232 * 1233 * PARAMETERS : 1234 * 1235 * RETURN : 1236 *==========================================================================*/ 1237int QCamera3HardwareInterface::register_stream_buffers( 1238 const struct camera3_device *device, 1239 const camera3_stream_buffer_set_t *buffer_set) 1240{ 1241 QCamera3HardwareInterface *hw = 1242 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 1243 if (!hw) { 1244 ALOGE("%s: NULL camera device", __func__); 1245 return -ENODEV; 1246 } 1247 return hw->registerStreamBuffers(buffer_set); 1248} 1249 1250/*=========================================================================== 1251 * FUNCTION : construct_default_request_settings 1252 * 1253 * DESCRIPTION: Configure a settings buffer to meet the required use case 1254 * 1255 * PARAMETERS : 1256 * 1257 * 1258 * RETURN : Success: Return valid metadata 1259 * Failure: Return NULL 1260 *==========================================================================*/ 1261const camera_metadata_t* QCamera3HardwareInterface:: 1262 construct_default_request_settings(const struct camera3_device *device, 1263 int type) 1264{ 1265 1266 camera_metadata_t* fwk_metadata = NULL; 1267 QCamera3HardwareInterface *hw = 1268 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 1269 if (!hw) { 1270 ALOGE("%s: NULL camera device", __func__); 1271 return NULL; 1272 } 1273 1274 fwk_metadata = hw->translateMetadata(type); 1275 1276 return fwk_metadata; 1277} 1278 1279/*=========================================================================== 1280 * FUNCTION : process_capture_request 1281 * 1282 * DESCRIPTION: 1283 * 1284 * PARAMETERS : 1285 * 1286 * 1287 * RETURN : 1288 *==========================================================================*/ 1289int QCamera3HardwareInterface::process_capture_request( 1290 const struct camera3_device *device, 1291 camera3_capture_request_t *request) 1292{ 1293 QCamera3HardwareInterface *hw = 1294 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 1295 if (!hw) { 1296 ALOGE("%s: NULL camera device", __func__); 1297 return -EINVAL; 1298 } 1299 1300 return hw->processCaptureRequest(request); 1301} 1302 1303/*=========================================================================== 1304 * FUNCTION : get_metadata_vendor_tag_ops 1305 * 1306 * DESCRIPTION: 1307 * 1308 * PARAMETERS : 1309 * 1310 * 1311 * RETURN : 1312 *==========================================================================*/ 1313 1314void QCamera3HardwareInterface::get_metadata_vendor_tag_ops( 1315 const struct camera3_device *device, 1316 vendor_tag_query_ops_t* ops) 1317{ 1318 QCamera3HardwareInterface *hw = 1319 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 1320 if (!hw) { 1321 ALOGE("%s: NULL camera device", __func__); 1322 return; 1323 } 1324 1325 hw->getMetadataVendorTagOps(ops); 1326 return; 1327} 1328 1329/*=========================================================================== 1330 * FUNCTION : dump 1331 * 1332 * DESCRIPTION: 1333 * 1334 * PARAMETERS : 1335 * 1336 * 1337 * RETURN : 1338 *==========================================================================*/ 1339 1340void QCamera3HardwareInterface::dump( 1341 const struct camera3_device *device, int fd) 1342{ 1343 QCamera3HardwareInterface *hw = 1344 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 1345 if (!hw) { 1346 ALOGE("%s: NULL camera device", __func__); 1347 return; 1348 } 1349 1350 hw->dump(fd); 1351 return; 1352} 1353 1354/*=========================================================================== 1355 * FUNCTION : close_camera_device 1356 * 1357 * DESCRIPTION: 1358 * 1359 * PARAMETERS : 1360 * 1361 * 1362 * RETURN : 1363 *==========================================================================*/ 1364int QCamera3HardwareInterface::close_camera_device(struct hw_device_t* device) 1365{ 1366 int ret = NO_ERROR; 1367 QCamera3HardwareInterface *hw = 1368 reinterpret_cast<QCamera3HardwareInterface *>( 1369 reinterpret_cast<camera3_device_t *>(device)->priv); 1370 if (!hw) { 1371 ALOGE("NULL camera device"); 1372 return BAD_VALUE; 1373 } 1374 delete hw; 1375 return ret; 1376} 1377 1378 1379}; //end namespace qcamera 1380