QCamera3HWI.cpp revision 66cadfdce2ea19f4707bf2a595b58bd36fbfdf3b
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#include "QCamera3PostProc.h" 44 45using namespace android; 46 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 53const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::EFFECT_MODES_MAP[] = { 54 { ANDROID_CONTROL_EFFECT_MODE_OFF, CAM_EFFECT_MODE_OFF }, 55 { ANDROID_CONTROL_EFFECT_MODE_MONO, CAM_EFFECT_MODE_MONO }, 56 { ANDROID_CONTROL_EFFECT_MODE_NEGATIVE, CAM_EFFECT_MODE_NEGATIVE }, 57 { ANDROID_CONTROL_EFFECT_MODE_SOLARIZE, CAM_EFFECT_MODE_SOLARIZE }, 58 { ANDROID_CONTROL_EFFECT_MODE_SEPIA, CAM_EFFECT_MODE_SEPIA }, 59 { ANDROID_CONTROL_EFFECT_MODE_POSTERIZE, CAM_EFFECT_MODE_POSTERIZE }, 60 { ANDROID_CONTROL_EFFECT_MODE_WHITEBOARD, CAM_EFFECT_MODE_WHITEBOARD }, 61 { ANDROID_CONTROL_EFFECT_MODE_BLACKBOARD, CAM_EFFECT_MODE_BLACKBOARD }, 62 { ANDROID_CONTROL_EFFECT_MODE_AQUA, CAM_EFFECT_MODE_AQUA } 63}; 64 65const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::WHITE_BALANCE_MODES_MAP[] = { 66 { ANDROID_CONTROL_AWB_MODE_OFF, CAM_WB_MODE_OFF }, 67 { ANDROID_CONTROL_AWB_MODE_AUTO, CAM_WB_MODE_AUTO }, 68 { ANDROID_CONTROL_AWB_MODE_INCANDESCENT, CAM_WB_MODE_INCANDESCENT }, 69 { ANDROID_CONTROL_AWB_MODE_FLUORESCENT, CAM_WB_MODE_FLUORESCENT }, 70 { ANDROID_CONTROL_AWB_MODE_WARM_FLUORESCENT,CAM_WB_MODE_WARM_FLUORESCENT}, 71 { ANDROID_CONTROL_AWB_MODE_DAYLIGHT, CAM_WB_MODE_DAYLIGHT }, 72 { ANDROID_CONTROL_AWB_MODE_CLOUDY_DAYLIGHT, CAM_WB_MODE_CLOUDY_DAYLIGHT }, 73 { ANDROID_CONTROL_AWB_MODE_TWILIGHT, CAM_WB_MODE_TWILIGHT }, 74 { ANDROID_CONTROL_AWB_MODE_SHADE, CAM_WB_MODE_SHADE } 75}; 76 77const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::SCENE_MODES_MAP[] = { 78 { ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED, CAM_SCENE_MODE_OFF }, 79 { ANDROID_CONTROL_SCENE_MODE_ACTION, CAM_SCENE_MODE_ACTION }, 80 { ANDROID_CONTROL_SCENE_MODE_PORTRAIT, CAM_SCENE_MODE_PORTRAIT }, 81 { ANDROID_CONTROL_SCENE_MODE_LANDSCAPE, CAM_SCENE_MODE_LANDSCAPE }, 82 { ANDROID_CONTROL_SCENE_MODE_NIGHT, CAM_SCENE_MODE_NIGHT }, 83 { ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT, CAM_SCENE_MODE_NIGHT_PORTRAIT }, 84 { ANDROID_CONTROL_SCENE_MODE_THEATRE, CAM_SCENE_MODE_THEATRE }, 85 { ANDROID_CONTROL_SCENE_MODE_BEACH, CAM_SCENE_MODE_BEACH }, 86 { ANDROID_CONTROL_SCENE_MODE_SNOW, CAM_SCENE_MODE_SNOW }, 87 { ANDROID_CONTROL_SCENE_MODE_SUNSET, CAM_SCENE_MODE_SUNSET }, 88 { ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO, CAM_SCENE_MODE_ANTISHAKE }, 89 { ANDROID_CONTROL_SCENE_MODE_FIREWORKS , CAM_SCENE_MODE_FIREWORKS }, 90 { ANDROID_CONTROL_SCENE_MODE_SPORTS , CAM_SCENE_MODE_SPORTS }, 91 { ANDROID_CONTROL_SCENE_MODE_PARTY, CAM_SCENE_MODE_PARTY }, 92 { ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT, CAM_SCENE_MODE_CANDLELIGHT }, 93 { ANDROID_CONTROL_SCENE_MODE_BARCODE, CAM_SCENE_MODE_BARCODE} 94}; 95 96const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::FOCUS_MODES_MAP[] = { 97 { ANDROID_CONTROL_AF_MODE_OFF, CAM_FOCUS_MODE_OFF }, 98 { ANDROID_CONTROL_AF_MODE_AUTO, CAM_FOCUS_MODE_AUTO }, 99 { ANDROID_CONTROL_AF_MODE_MACRO, CAM_FOCUS_MODE_MACRO }, 100 { ANDROID_CONTROL_AF_MODE_EDOF, CAM_FOCUS_MODE_EDOF }, 101 { ANDROID_CONTROL_AF_MODE_CONTINUOUS_PICTURE, CAM_FOCUS_MODE_CONTINOUS_PICTURE }, 102 { ANDROID_CONTROL_AF_MODE_CONTINUOUS_VIDEO, CAM_FOCUS_MODE_CONTINOUS_VIDEO } 103}; 104 105const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::ANTIBANDING_MODES_MAP[] = { 106 { ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF, CAM_ANTIBANDING_MODE_OFF }, 107 { ANDROID_CONTROL_AE_ANTIBANDING_MODE_50HZ, CAM_ANTIBANDING_MODE_50HZ }, 108 { ANDROID_CONTROL_AE_ANTIBANDING_MODE_60HZ, CAM_ANTIBANDING_MODE_60HZ }, 109 { ANDROID_CONTROL_AE_ANTIBANDING_MODE_AUTO, CAM_ANTIBANDING_MODE_AUTO } 110}; 111 112const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::AUTO_EXPOSURE_MAP[] = { 113 { ANDROID_CONTROL_AE_MODE_OFF, CAM_AEC_MODE_OFF }, 114 { ANDROID_CONTROL_AE_MODE_ON, CAM_AEC_MODE_FRAME_AVERAGE }, 115}; 116 117const QCamera3HardwareInterface::QCameraMap QCamera3HardwareInterface::FLASH_MODES_MAP[] = { 118 { ANDROID_FLASH_MODE_OFF, CAM_FLASH_MODE_OFF }, 119 { ANDROID_FLASH_MODE_SINGLE, CAM_FLASH_MODE_ON }, 120 { ANDROID_FLASH_MODE_TORCH, CAM_FLASH_MODE_TORCH} 121}; 122 123 124camera3_device_ops_t QCamera3HardwareInterface::mCameraOps = { 125 initialize: QCamera3HardwareInterface::initialize, 126 configure_streams: QCamera3HardwareInterface::configure_streams, 127 register_stream_buffers: QCamera3HardwareInterface::register_stream_buffers, 128 construct_default_request_settings: QCamera3HardwareInterface::construct_default_request_settings, 129 process_capture_request: QCamera3HardwareInterface::process_capture_request, 130 get_metadata_vendor_tag_ops: QCamera3HardwareInterface::get_metadata_vendor_tag_ops, 131 dump: QCamera3HardwareInterface::dump, 132}; 133 134 135/*=========================================================================== 136 * FUNCTION : QCamera3HardwareInterface 137 * 138 * DESCRIPTION: constructor of QCamera3HardwareInterface 139 * 140 * PARAMETERS : 141 * @cameraId : camera ID 142 * 143 * RETURN : none 144 *==========================================================================*/ 145QCamera3HardwareInterface::QCamera3HardwareInterface(int cameraId) 146 : mCameraId(cameraId), 147 mCameraHandle(NULL), 148 mCameraOpened(false), 149 mCallbackOps(NULL), 150 mJpegSettings(NULL) 151{ 152 mCameraDevice.common.tag = HARDWARE_DEVICE_TAG; 153 mCameraDevice.common.version = CAMERA_DEVICE_API_VERSION_3_0; 154 mCameraDevice.common.close = close_camera_device; 155 mCameraDevice.ops = &mCameraOps; 156 mCameraDevice.priv = this; 157 gCamCapability[cameraId]->version = CAM_HAL_V3; 158 159 pthread_mutex_init(&mRequestLock, NULL); 160 pthread_cond_init(&mRequestCond, NULL); 161 mPendingRequest = 0; 162 163 pthread_mutex_init(&mMutex, NULL); 164} 165 166/*=========================================================================== 167 * FUNCTION : ~QCamera3HardwareInterface 168 * 169 * DESCRIPTION: destructor of QCamera3HardwareInterface 170 * 171 * PARAMETERS : none 172 * 173 * RETURN : none 174 *==========================================================================*/ 175QCamera3HardwareInterface::~QCamera3HardwareInterface() 176{ 177 if (mJpegSettings != NULL) { 178 free(mJpegSettings); 179 mJpegSettings = NULL; 180 } 181 closeCamera(); 182 183 pthread_mutex_destroy(&mRequestLock); 184 pthread_cond_destroy(&mRequestCond); 185 186 pthread_mutex_destroy(&mMutex); 187} 188 189/*=========================================================================== 190 * FUNCTION : openCamera 191 * 192 * DESCRIPTION: open camera 193 * 194 * PARAMETERS : 195 * @hw_device : double ptr for camera device struct 196 * 197 * RETURN : int32_t type of status 198 * NO_ERROR -- success 199 * none-zero failure code 200 *==========================================================================*/ 201int QCamera3HardwareInterface::openCamera(struct hw_device_t **hw_device) 202{ 203 //int rc = NO_ERROR; 204 int rc = 0; 205 if (mCameraOpened) { 206 *hw_device = NULL; 207 return PERMISSION_DENIED; 208 } 209 210 rc = openCamera(); 211 if (rc == 0) 212 *hw_device = &mCameraDevice.common; 213 else 214 *hw_device = NULL; 215 return rc; 216} 217 218/*=========================================================================== 219 * FUNCTION : openCamera 220 * 221 * DESCRIPTION: open camera 222 * 223 * PARAMETERS : none 224 * 225 * RETURN : int32_t type of status 226 * NO_ERROR -- success 227 * none-zero failure code 228 *==========================================================================*/ 229int QCamera3HardwareInterface::openCamera() 230{ 231 if (mCameraHandle) { 232 ALOGE("Failure: Camera already opened"); 233 return ALREADY_EXISTS; 234 } 235 mCameraHandle = camera_open(mCameraId); 236 if (!mCameraHandle) { 237 ALOGE("camera_open failed."); 238 return UNKNOWN_ERROR; 239 } 240 241 mCameraOpened = true; 242 243 return NO_ERROR; 244} 245 246/*=========================================================================== 247 * FUNCTION : closeCamera 248 * 249 * DESCRIPTION: close camera 250 * 251 * PARAMETERS : none 252 * 253 * RETURN : int32_t type of status 254 * NO_ERROR -- success 255 * none-zero failure code 256 *==========================================================================*/ 257int QCamera3HardwareInterface::closeCamera() 258{ 259 int rc = NO_ERROR; 260 261 rc = mCameraHandle->ops->close_camera(mCameraHandle->camera_handle); 262 mCameraHandle = NULL; 263 mCameraOpened = false; 264 265 return rc; 266} 267 268/*=========================================================================== 269 * FUNCTION : sendCaptureResult 270 * 271 * DESCRIPTION: send completed capture result metadata buffer along with possibly 272 * completed output stream buffers to the framework 273 * 274 * PARAMETERS : 275 * 276 * RETURN : 277 *==========================================================================*/ 278void QCamera3HardwareInterface::sendCaptureResult(const struct camera3_callback_ops *, 279 const camera3_capture_result_t *result) 280{ 281 //TODO - Implement 282} 283 284/*=========================================================================== 285 * FUNCTION : notify 286 * 287 * DESCRIPTION: Asynchronous notification callback to framework 288 * 289 * PARAMETERS : 290 * 291 * RETURN : 292 * 293 * 294 *==========================================================================*/ 295 296void QCamera3HardwareInterface::notify(const struct camera3_callback_ops *, 297 const camera3_notify_msg_t *msg) 298{ 299 //TODO - Implement 300} 301 302 303/*=========================================================================== 304 * FUNCTION : initialize 305 * 306 * DESCRIPTION: Initialize frameworks callback functions 307 * 308 * PARAMETERS : 309 * @callback_ops : callback function to frameworks 310 * 311 * RETURN : 312 * 313 *==========================================================================*/ 314int QCamera3HardwareInterface::initialize( 315 const struct camera3_callback_ops *callback_ops) 316{ 317 int rc; 318 319 pthread_mutex_lock(&mMutex); 320 321 //Create metadata channel and initialize it 322 mMetadataChannel = new QCamera3MetadataChannel(mCameraHandle->camera_handle, 323 mCameraHandle->ops, captureResultCb, 324 &gCamCapability[mCameraId]->padding_info, this); 325 if (mMetadataChannel == NULL) { 326 ALOGE("%s: failed to allocate metadata channel", __func__); 327 rc = -ENOMEM; 328 goto err1; 329 } 330 rc = mMetadataChannel->initialize(); 331 if (rc < 0) { 332 ALOGE("%s: metadata channel initialization failed", __func__); 333 goto err2; 334 } 335 336 /* Initialize parameter heap and structure */ 337 mParamHeap = new QCamera3HeapMemory(); 338 if (mParamHeap == NULL) { 339 ALOGE("%s: creation of mParamHeap failed", __func__); 340 goto err2; 341 } 342 rc = mParamHeap->allocate(1, sizeof(parm_buffer_t), false); 343 if (rc < 0) { 344 ALOGE("%s: allocation of mParamHeap failed", __func__); 345 goto err3; 346 } 347 rc = mCameraHandle->ops->map_buf(mCameraHandle->camera_handle, 348 CAM_MAPPING_BUF_TYPE_PARM_BUF, 349 mParamHeap->getFd(0), sizeof(parm_buffer_t)); 350 if (rc < 0) { 351 ALOGE("%s: map_buf failed for mParamHeap", __func__); 352 goto err4; 353 } 354 mParameters = (parm_buffer_t *)DATA_PTR(mParamHeap, 0); 355 356 mCallbackOps = callback_ops; 357 358 pthread_mutex_unlock(&mMutex); 359 return 0; 360 361err4: 362 mParamHeap->deallocate(); 363err3: 364 delete mParamHeap; 365 mParamHeap = NULL; 366err2: 367 delete mMetadataChannel; 368 mMetadataChannel = NULL; 369err1: 370 pthread_mutex_unlock(&mMutex); 371 return rc; 372} 373 374/*=========================================================================== 375 * FUNCTION : configureStreams 376 * 377 * DESCRIPTION: Reset HAL camera device processing pipeline and set up new input 378 * and output streams. 379 * 380 * PARAMETERS : 381 * @stream_list : streams to be configured 382 * 383 * RETURN : 384 * 385 *==========================================================================*/ 386int QCamera3HardwareInterface::configureStreams( 387 camera3_stream_configuration_t *streamList) 388{ 389 pthread_mutex_lock(&mMutex); 390 int rc; 391 392 // Sanity check stream_list 393 if (streamList == NULL) { 394 ALOGE("%s: NULL stream configuration", __func__); 395 pthread_mutex_unlock(&mMutex); 396 return BAD_VALUE; 397 } 398 399 if (streamList->streams == NULL) { 400 ALOGE("%s: NULL stream list", __func__); 401 pthread_mutex_unlock(&mMutex); 402 return BAD_VALUE; 403 } 404 405 if (streamList->num_streams < 1) { 406 ALOGE("%s: Bad number of streams requested: %d", __func__, 407 streamList->num_streams); 408 pthread_mutex_unlock(&mMutex); 409 return BAD_VALUE; 410 } 411 412 camera3_stream_t *inputStream = NULL; 413 for (size_t i = 0; i < streamList->num_streams; i++) { 414 camera3_stream_t *newStream = streamList->streams[i]; 415 if (newStream->stream_type == CAMERA3_STREAM_INPUT) { 416 if (inputStream != NULL) { 417 ALOGE("%s: Multiple input streams requested!", __func__); 418 pthread_mutex_unlock(&mMutex); 419 return BAD_VALUE; 420 } 421 inputStream = newStream; 422 } 423 } 424 mInputStream = inputStream; 425 426 /* TODO: Clean up no longer used streams, and maintain others if this 427 * is not the 1st time configureStreams is called */ 428 429 mMetadataChannel->stop(); 430 431 /* Allocate channel objects for the requested streams */ 432 for (size_t i = 0; i < streamList->num_streams; i++) { 433 camera3_stream_t *newStream = streamList->streams[i]; 434 if (newStream->priv == NULL) { 435 //New stream, construct channel 436 437 switch (newStream->stream_type) { 438 case CAMERA3_STREAM_INPUT: 439 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ; 440 newStream->max_buffers = QCamera3PicChannel::kMaxBuffers; 441 break; 442 case CAMERA3_STREAM_BIDIRECTIONAL: 443 newStream->usage = GRALLOC_USAGE_HW_CAMERA_READ | 444 GRALLOC_USAGE_HW_CAMERA_WRITE; 445 newStream->max_buffers = QCamera3RegularChannel::kMaxBuffers; 446 break; 447 case CAMERA3_STREAM_OUTPUT: 448 newStream->usage = GRALLOC_USAGE_HW_CAMERA_WRITE; 449 newStream->max_buffers = QCamera3RegularChannel::kMaxBuffers; 450 break; 451 default: 452 ALOGE("%s: Invalid stream_type %d", __func__, newStream->stream_type); 453 break; 454 } 455 456 if (newStream->stream_type == CAMERA3_STREAM_OUTPUT || 457 newStream->stream_type == CAMERA3_STREAM_BIDIRECTIONAL) { 458 QCamera3Channel *channel; 459 switch (newStream->format) { 460 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 461 channel = new QCamera3RegularChannel(mCameraHandle->camera_handle, 462 mCameraHandle->ops, captureResultCb, 463 &gCamCapability[mCameraId]->padding_info, this, newStream); 464 if (channel == NULL) { 465 ALOGE("%s: allocation of channel failed", __func__); 466 pthread_mutex_unlock(&mMutex); 467 return -ENOMEM; 468 } 469 470 newStream->priv = channel; 471 break; 472 case HAL_PIXEL_FORMAT_BLOB: 473 channel = new QCamera3PicChannel(mCameraHandle->camera_handle, 474 mCameraHandle->ops, captureResultCb, 475 &gCamCapability[mCameraId]->padding_info, this, newStream); 476 if (channel == NULL) { 477 ALOGE("%s: allocation of channel failed", __func__); 478 pthread_mutex_unlock(&mMutex); 479 return -ENOMEM; 480 } 481 //Register Jpeg callback with mm-camera-interface 482 rc = channel->initialize(); 483 if (rc < 0) { 484 ALOGE("%s: snapshot channel initialization failed", __func__); 485 delete channel; 486 channel = NULL; 487 goto end; 488 } 489 490 newStream->priv = channel; 491 break; 492 493 //TODO: Add support for app consumed format? 494 default: 495 ALOGE("%s: not a supported format 0x%x", __func__, newStream->format); 496 break; 497 } 498 } 499 } else { 500 // Channel already exists for this stream 501 // Do nothing for now 502 } 503 } 504 505 // Cannot reuse settings across configure call 506 memset(mParameters, 0, sizeof(parm_buffer_t)); 507end: 508 pthread_mutex_unlock(&mMutex); 509 return 0; 510} 511 512/*=========================================================================== 513 * FUNCTION : validateCaptureRequest 514 * 515 * DESCRIPTION: validate a capture request from camera service 516 * 517 * PARAMETERS : 518 * @request : request from framework to process 519 * 520 * RETURN : 521 * 522 *==========================================================================*/ 523int QCamera3HardwareInterface::validateCaptureRequest( 524 camera3_capture_request_t *request) 525{ 526 int rc = NO_ERROR; 527 ssize_t idx = 0; 528 const camera3_stream_buffer_t *b; 529 CameraMetadata meta; 530 531 /* Sanity check the request */ 532 if (request == NULL) { 533 ALOGE("%s: NULL capture request", __func__); 534 return BAD_VALUE; 535 } 536 537 uint32_t frameNumber = request->frame_number; 538 if (request->input_buffer != NULL && 539 request->input_buffer->stream != mInputStream) { 540 ALOGE("%s: Request %d: Input buffer not from input stream!", 541 __FUNCTION__, frameNumber); 542 return BAD_VALUE; 543 } 544 if (request->num_output_buffers < 1 || request->output_buffers == NULL) { 545 ALOGE("%s: Request %d: No output buffers provided!", 546 __FUNCTION__, frameNumber); 547 return BAD_VALUE; 548 } 549 if (request->input_buffer != NULL) { 550 //TODO 551 ALOGE("%s: Not supporting input buffer yet", __func__); 552 return BAD_VALUE; 553 } 554 555 // Validate all buffers 556 b = request->output_buffers; 557 do { 558 QCamera3Channel *channel = 559 static_cast<QCamera3Channel*>(b->stream->priv); 560 if (channel == NULL) { 561 ALOGE("%s: Request %d: Buffer %d: Unconfigured stream!", 562 __func__, frameNumber, idx); 563 return BAD_VALUE; 564 } 565 if (b->status != CAMERA3_BUFFER_STATUS_OK) { 566 ALOGE("%s: Request %d: Buffer %d: Status not OK!", 567 __func__, frameNumber, idx); 568 return BAD_VALUE; 569 } 570 if (b->release_fence != -1) { 571 ALOGE("%s: Request %d: Buffer %d: Has a release fence!", 572 __func__, frameNumber, idx); 573 return BAD_VALUE; 574 } 575 if (b->buffer == NULL) { 576 ALOGE("%s: Request %d: Buffer %d: NULL buffer handle!", 577 __func__, frameNumber, idx); 578 return BAD_VALUE; 579 } 580 idx++; 581 b = request->output_buffers + idx; 582 } while (idx < (ssize_t)request->num_output_buffers); 583 584 return NO_ERROR; 585} 586 587/*=========================================================================== 588 * FUNCTION : registerStreamBuffers 589 * 590 * DESCRIPTION: Register buffers for a given stream with the HAL device. 591 * 592 * PARAMETERS : 593 * @stream_list : streams to be configured 594 * 595 * RETURN : 596 * 597 *==========================================================================*/ 598int QCamera3HardwareInterface::registerStreamBuffers( 599 const camera3_stream_buffer_set_t *buffer_set) 600{ 601 int rc = 0; 602 603 pthread_mutex_lock(&mMutex); 604 605 if (buffer_set == NULL) { 606 ALOGE("%s: Invalid buffer_set parameter.", __func__); 607 pthread_mutex_unlock(&mMutex); 608 return -EINVAL; 609 } 610 if (buffer_set->stream == NULL) { 611 ALOGE("%s: Invalid stream parameter.", __func__); 612 pthread_mutex_unlock(&mMutex); 613 return -EINVAL; 614 } 615 if (buffer_set->num_buffers < 1) { 616 ALOGE("%s: Invalid num_buffers %d.", __func__, buffer_set->num_buffers); 617 pthread_mutex_unlock(&mMutex); 618 return -EINVAL; 619 } 620 if (buffer_set->buffers == NULL) { 621 ALOGE("%s: Invalid buffers parameter.", __func__); 622 pthread_mutex_unlock(&mMutex); 623 return -EINVAL; 624 } 625 626 camera3_stream_t *stream = buffer_set->stream; 627 QCamera3Channel *channel = (QCamera3Channel *)stream->priv; 628 629 if (stream->stream_type != CAMERA3_STREAM_OUTPUT) { 630 ALOGE("%s: not yet support non output type stream", __func__); 631 pthread_mutex_unlock(&mMutex); 632 return -EINVAL; 633 } 634 rc = channel->registerBuffers(buffer_set->num_buffers, buffer_set->buffers); 635 if (rc < 0) { 636 ALOGE("%s: registerBUffers for stream %p failed", __func__, stream); 637 pthread_mutex_unlock(&mMutex); 638 return -ENODEV; 639 } 640 641 pthread_mutex_unlock(&mMutex); 642 return NO_ERROR; 643} 644 645/*=========================================================================== 646 * FUNCTION : processCaptureRequest 647 * 648 * DESCRIPTION: process a capture request from camera service 649 * 650 * PARAMETERS : 651 * @request : request from framework to process 652 * 653 * RETURN : 654 * 655 *==========================================================================*/ 656int QCamera3HardwareInterface::processCaptureRequest( 657 camera3_capture_request_t *request) 658{ 659 int rc = NO_ERROR; 660 ssize_t idx = 0; 661 const camera3_stream_buffer_t *b; 662 CameraMetadata meta; 663 664 pthread_mutex_lock(&mMutex); 665 666 rc = validateCaptureRequest(request); 667 if (rc != NO_ERROR) { 668 ALOGE("%s: incoming request is not valid", __func__); 669 pthread_mutex_unlock(&mMutex); 670 return rc; 671 } 672 673 uint32_t frameNumber = request->frame_number; 674 675 rc = setFrameParameters(request->frame_number, request->settings); 676 677 if (rc < 0) { 678 ALOGE("%s: fail to set frame parameters", __func__); 679 pthread_mutex_unlock(&mMutex); 680 return rc; 681 } 682 683 // Acquire all request buffers first 684 for (size_t i = 0; i < request->num_output_buffers; i++) { 685 const camera3_stream_buffer_t& output = request->output_buffers[i]; 686 sp<Fence> acquireFence = new Fence(output.acquire_fence); 687 int format = output.stream->format; 688 689 if (output.stream->format == HAL_PIXEL_FORMAT_BLOB) { 690 //Call function to store local copy of jpeg data for encode params. 691 rc = getJpegSettings(request->settings); 692 if (rc < 0) { 693 ALOGE("%s: failed to get jpeg parameters"); 694 pthread_mutex_unlock(&mMutex); 695 return rc; 696 } 697 } 698 699 rc = acquireFence->wait(Fence::TIMEOUT_NEVER); 700 if (rc != OK) { 701 ALOGE("%s: fence wait failed %d", __func__, rc); 702 pthread_mutex_unlock(&mMutex); 703 return rc; 704 } 705 } 706 707 // Notify metadata channel we receive a request 708 mMetadataChannel->request(NULL, frameNumber); 709 710 // Call request on other streams 711 for (size_t i = 0; i < request->num_output_buffers; i++) { 712 const camera3_stream_buffer_t& output = request->output_buffers[i]; 713 QCamera3Channel *channel = (QCamera3Channel *)output.stream->priv; 714 int format = output.stream->format; 715 716 717 if (channel == NULL) { 718 ALOGE("%s: invalid channel pointer for stream", __func__); 719 continue; 720 } 721 722 if (output.stream->format == HAL_PIXEL_FORMAT_BLOB) { 723 rc = channel->request(output.buffer, frameNumber, mJpegSettings); 724 } else { 725 rc = channel->request(output.buffer, frameNumber); 726 } 727 if (rc < 0) 728 ALOGE("%s: request failed", __func__); 729 } 730 731 //Block on conditional variable 732 pthread_mutex_lock(&mRequestLock); 733 mPendingRequest = 1; 734 while (mPendingRequest == 1) { 735 pthread_cond_wait(&mRequestCond, &mRequestLock); 736 } 737 pthread_mutex_unlock(&mRequestLock); 738 739 pthread_mutex_unlock(&mMutex); 740 return rc; 741} 742 743/*=========================================================================== 744 * FUNCTION : getMetadataVendorTagOps 745 * 746 * DESCRIPTION: 747 * 748 * PARAMETERS : 749 * 750 * 751 * RETURN : 752 *==========================================================================*/ 753void QCamera3HardwareInterface::getMetadataVendorTagOps(vendor_tag_query_ops_t* ops) 754{ 755 /* Enable locks when we eventually add Vendor Tags */ 756 /* 757 pthread_mutex_lock(&mMutex); 758 759 pthread_mutex_unlock(&mMutex); 760 */ 761 return; 762} 763 764/*=========================================================================== 765 * FUNCTION : dump 766 * 767 * DESCRIPTION: 768 * 769 * PARAMETERS : 770 * 771 * 772 * RETURN : 773 *==========================================================================*/ 774void QCamera3HardwareInterface::dump(int fd) 775{ 776 /*Enable lock when we implement this function*/ 777 /* 778 pthread_mutex_lock(&mMutex); 779 780 pthread_mutex_unlock(&mMutex); 781 */ 782 return; 783} 784 785/*=========================================================================== 786 * FUNCTION : captureResultCb 787 * 788 * DESCRIPTION: Callback handler for all capture result (streams, as well as metadata) 789 * 790 * PARAMETERS : 791 * @metadata : metadata information 792 * @buffer : actual gralloc buffer to be returned to frameworks. NULL if metadata. 793 * 794 * RETURN : NONE 795 *==========================================================================*/ 796void QCamera3HardwareInterface::captureResultCb(metadata_buffer_t *metadata, 797 camera3_stream_buffer_t *buffer, uint32_t frame_number) 798{ 799 pthread_mutex_lock(&mCaptureResultLock); 800 camera3_capture_result_t result; 801 802 803 if (metadata) { 804 // Signal to unblock processCaptureRequest 805 pthread_mutex_lock(&mRequestLock); 806 mPendingRequest = 0; 807 pthread_cond_signal(&mRequestCond); 808 pthread_mutex_unlock(&mRequestLock); 809 810 uint32_t *frame_number = (uint32_t *)POINTER_OF(CAM_INTF_META_FRAME_NUMBER, metadata); 811 812 result.result = translateCbMetadataToResultMetadata(metadata); 813 if (!result.result) { 814 result.frame_number = *frame_number; 815 result.num_output_buffers = 0; 816 result.output_buffers = NULL; 817 mCallbackOps->process_capture_result(mCallbackOps, &result); 818 819 free_camera_metadata((camera_metadata_t*)result.result); 820 } 821 } else { 822 result.result = NULL; 823 result.frame_number = frame_number; 824 result.num_output_buffers = 1; 825 result.output_buffers = buffer; 826 mCallbackOps->process_capture_result(mCallbackOps, &result); 827 } 828 829 pthread_mutex_unlock(&mCaptureResultLock); 830 return; 831} 832 833/*=========================================================================== 834 * FUNCTION : translateCbMetadataToResultMetadata 835 * 836 * DESCRIPTION: 837 * 838 * PARAMETERS : 839 * @metadata : metadata information from callback 840 * 841 * RETURN : camera_metadata_t* 842 * metadata in a format specified by fwk 843 *==========================================================================*/ 844camera_metadata_t* 845QCamera3HardwareInterface::translateCbMetadataToResultMetadata 846 (metadata_buffer_t *metadata) 847{ 848 CameraMetadata camMetadata; 849 camera_metadata_t* resultMetadata; 850 851 uint32_t *frame_number = 852 (uint32_t *)POINTER_OF(CAM_INTF_META_FRAME_NUMBER, metadata); 853 nsecs_t captureTime = 1000000 * (*frame_number) * 33; 854 camMetadata.update(ANDROID_SENSOR_TIMESTAMP, &captureTime, 1); 855 856 /*CAM_INTF_META_HISTOGRAM - TODO*/ 857 /*cam_hist_stats_t *histogram = 858 (cam_hist_stats_t *)POINTER_OF(CAM_INTF_META_HISTOGRAM, 859 metadata);*/ 860 861 /*face detection*/ 862 cam_face_detection_data_t *faceDetectionInfo =(cam_face_detection_data_t *) 863 POINTER_OF(CAM_INTF_META_FACE_DETECTION, metadata); 864 uint8_t numFaces = faceDetectionInfo->num_faces_detected; 865 int32_t faceIds[numFaces]; 866 uint8_t faceScores[numFaces]; 867 int32_t faceRectangles[numFaces * 4]; 868 int32_t faceLandmarks[numFaces * 6]; 869 int j = 0, k = 0; 870 for (int i = 0; i < numFaces; i++) { 871 faceIds[i] = faceDetectionInfo->faces[i].face_id; 872 faceScores[i] = faceDetectionInfo->faces[i].score; 873 convertRegions(faceDetectionInfo->faces[i].face_boundary, 874 faceRectangles+j, -1); 875 convertLandmarks(faceDetectionInfo->faces[i], faceLandmarks+k); 876 j+= 4; 877 k+= 6; 878 } 879 camMetadata.update(ANDROID_STATISTICS_FACE_IDS, faceIds, numFaces); 880 camMetadata.update(ANDROID_STATISTICS_FACE_SCORES, faceScores, numFaces); 881 camMetadata.update(ANDROID_STATISTICS_FACE_RECTANGLES, 882 faceRectangles, numFaces*4); 883 camMetadata.update(ANDROID_STATISTICS_FACE_LANDMARKS, 884 faceLandmarks, numFaces*6); 885 886 887 /*autofocus - TODO*/ 888 /*cam_auto_focus_data_t *afData =(cam_auto_focus_data_t *) 889 POINTER_OF(CAM_INTF_META_AUTOFOCUS_DATA,metadata);*/ 890 891 int32_t *color_correct_mode = 892 (int32_t *)POINTER_OF(CAM_INTF_META_COLOR_CORRECT_MODE, metadata); 893 camMetadata.update(ANDROID_COLOR_CORRECTION_MODE, color_correct_mode, 1); 894 895 int32_t *ae_precapture_id = 896 (int32_t *)POINTER_OF(CAM_INTF_META_AEC_PRECAPTURE_ID, metadata); 897 camMetadata.update(ANDROID_CONTROL_AE_PRECAPTURE_ID, ae_precapture_id, 1); 898 899 /*aec regions*/ 900 cam_area_t *hAeRegions = 901 (cam_area_t *)POINTER_OF(CAM_INTF_META_AEC_ROI, metadata); 902 int32_t aeRegions[5]; 903 convertRegions(hAeRegions->rect, aeRegions, hAeRegions->weight); 904 camMetadata.update(ANDROID_CONTROL_AE_REGIONS, aeRegions, 5); 905 906 int32_t *ae_state = 907 (int32_t *)POINTER_OF(CAM_INTF_META_AEC_STATE, metadata); 908 camMetadata.update(ANDROID_CONTROL_AE_STATE, ae_state, 1); 909 910 int32_t *focusMode = 911 (int32_t *)POINTER_OF(CAM_INTF_PARM_FOCUS_MODE, metadata); 912 camMetadata.update(ANDROID_CONTROL_AF_MODE, focusMode, 1); 913 914 /*af regions*/ 915 cam_area_t *hAfRegions = 916 (cam_area_t *)POINTER_OF(CAM_INTF_META_AF_ROI, metadata); 917 int32_t afRegions[5]; 918 convertRegions(hAfRegions->rect, afRegions, hAfRegions->weight); 919 camMetadata.update(ANDROID_CONTROL_AF_REGIONS, afRegions, 5); 920 921 int32_t *afState = (int32_t *)POINTER_OF(CAM_INTF_META_AF_STATE, metadata); 922 camMetadata.update(ANDROID_CONTROL_AF_STATE, afState, 1); 923 924 int32_t *afTriggerId = 925 (int32_t *)POINTER_OF(CAM_INTF_META_AF_TRIGGER_ID, metadata); 926 camMetadata.update(ANDROID_CONTROL_AF_TRIGGER_ID, afTriggerId, 1); 927 928 int32_t *whiteBalance = 929 (int32_t *)POINTER_OF(CAM_INTF_PARM_WHITE_BALANCE, metadata); 930 camMetadata.update(ANDROID_CONTROL_AWB_MODE, whiteBalance, 1); 931 932 /*awb regions*/ 933 cam_area_t *hAwbRegions = 934 (cam_area_t *)POINTER_OF(CAM_INTF_META_AWB_REGIONS, metadata); 935 int32_t awbRegions[5]; 936 convertRegions(hAwbRegions->rect, awbRegions, hAwbRegions->weight); 937 camMetadata.update(ANDROID_CONTROL_AWB_REGIONS, awbRegions, 5); 938 939 int32_t *whiteBalanceState = 940 (int32_t *)POINTER_OF(CAM_INTF_META_AWB_STATE, metadata); 941 camMetadata.update(ANDROID_CONTROL_AWB_STATE, whiteBalanceState, 1); 942 943 int32_t *mode = (int32_t *)POINTER_OF(CAM_INTF_META_MODE, metadata); 944 camMetadata.update(ANDROID_CONTROL_MODE, mode, 1); 945 946 int32_t *edgeMode = (int32_t *)POINTER_OF(CAM_INTF_META_EDGE, metadata); 947 camMetadata.update(ANDROID_EDGE_MODE, edgeMode, 1); 948 949 int32_t *flashPower = 950 (int32_t *)POINTER_OF(CAM_INTF_META_FLASH_POWER, metadata); 951 camMetadata.update(ANDROID_FLASH_FIRING_POWER, flashPower, 1); 952 953 int64_t *flashFiringTime = 954 (int64_t *)POINTER_OF(CAM_INTF_META_FLASH_FIRING_TIME, metadata); 955 camMetadata.update(ANDROID_FLASH_FIRING_TIME, flashFiringTime, 1); 956 957 /*int32_t *ledMode = 958 (int32_t *)POINTER_OF(CAM_INTF_PARM_LED_MODE, metadata); 959 camMetadata.update(ANDROID_FLASH_FIRING_TIME, ledMode, 1);*/ 960 961 int32_t *flashState = 962 (int32_t *)POINTER_OF(CAM_INTF_META_FLASH_STATE, metadata); 963 camMetadata.update(ANDROID_FLASH_STATE, flashState, 1); 964 965 int32_t *hotPixelMode = 966 (int32_t *)POINTER_OF(CAM_INTF_META_HOTPIXEL_MODE, metadata); 967 camMetadata.update(ANDROID_HOT_PIXEL_MODE, hotPixelMode, 1); 968 969 float *lensAperture = 970 (float *)POINTER_OF(CAM_INTF_META_LENS_APERTURE, metadata); 971 camMetadata.update(ANDROID_LENS_APERTURE , lensAperture, 1); 972 973 float *filterDensity = 974 (float *)POINTER_OF(CAM_INTF_META_LENS_FILTERDENSITY, metadata); 975 camMetadata.update(ANDROID_LENS_FILTER_DENSITY , filterDensity, 1); 976 977 float *focalLength = 978 (float *)POINTER_OF(CAM_INTF_META_LENS_FOCAL_LENGTH, metadata); 979 camMetadata.update(ANDROID_LENS_FOCAL_LENGTH, focalLength, 1); 980 981 float *focusDistance = 982 (float *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_DISTANCE, metadata); 983 camMetadata.update(ANDROID_LENS_FOCUS_DISTANCE , focusDistance, 1); 984 985 float *focusRange = 986 (float *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_RANGE, metadata); 987 camMetadata.update(ANDROID_LENS_FOCUS_RANGE , focusRange, 1); 988 989 int32_t *opticalStab = 990 (int32_t *)POINTER_OF(CAM_INTF_META_LENS_OPT_STAB_MODE, metadata); 991 camMetadata.update(ANDROID_LENS_OPTICAL_STABILIZATION_MODE, opticalStab, 1); 992 993 /*int32_t *focusState = 994 (int32_t *)POINTER_OF(CAM_INTF_META_LENS_FOCUS_STATE, metadata); 995 camMetadata.update(ANDROID_LENS_STATE , focusState, 1); //check */ 996 997 int32_t *noiseRedMode = 998 (int32_t *)POINTER_OF(CAM_INTF_META_NOISE_REDUCTION_MODE, metadata); 999 camMetadata.update(ANDROID_NOISE_REDUCTION_MODE , noiseRedMode, 1); 1000 1001 /*CAM_INTF_META_SCALER_CROP_REGION - check size*/ 1002 1003 cam_crop_region_t *scalerCropRegion = (cam_crop_region_t *) 1004 POINTER_OF(CAM_INTF_META_SCALER_CROP_REGION, metadata); 1005 camMetadata.update(ANDROID_SCALER_CROP_REGION, 1006 (int32_t*)scalerCropRegion, 1007 sizeof(scalerCropRegion)/sizeof(cam_crop_region_t)); 1008 1009 int64_t *sensorExpTime = 1010 (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_EXPOSURE_TIME, metadata); 1011 camMetadata.update(ANDROID_SENSOR_EXPOSURE_TIME , sensorExpTime, 1); 1012 1013 int64_t *sensorFameDuration = 1014 (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_FRAME_DURATION, metadata); 1015 camMetadata.update(ANDROID_SENSOR_FRAME_DURATION, sensorFameDuration, 1); 1016 1017 int32_t *sensorSensitivity = 1018 (int32_t *)POINTER_OF(CAM_INTF_META_SENSOR_SENSITIVITY, metadata); 1019 camMetadata.update(ANDROID_SENSOR_SENSITIVITY, sensorSensitivity, 1); 1020 1021 int64_t *sensorTimestamp = 1022 (int64_t *)POINTER_OF(CAM_INTF_META_SENSOR_TIMESTAMP, metadata); 1023 camMetadata.update(ANDROID_SENSOR_TIMESTAMP, sensorTimestamp, 1); 1024 1025 int32_t *shadingMode = 1026 (int32_t *)POINTER_OF(CAM_INTF_META_SHADING_MODE, metadata); 1027 camMetadata.update(ANDROID_SHADING_MODE, shadingMode, 1); 1028 1029 int32_t *faceDetectMode = 1030 (int32_t *)POINTER_OF(CAM_INTF_META_STATS_FACEDETECT_MODE, metadata); 1031 camMetadata.update(ANDROID_STATISTICS_FACE_DETECT_MODE, faceDetectMode, 1); 1032 1033 int32_t *histogramMode = 1034 (int32_t *)POINTER_OF(CAM_INTF_META_STATS_HISTOGRAM_MODE, metadata); 1035 camMetadata.update(ANDROID_STATISTICS_HISTOGRAM_MODE, histogramMode, 1); 1036 1037 int32_t *sharpnessMapMode = 1038 (int32_t *)POINTER_OF(CAM_INTF_META_STATS_SHARPNESS_MAP_MODE, metadata); 1039 camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP_MODE, 1040 sharpnessMapMode, 1); 1041 1042 /*CAM_INTF_META_STATS_SHARPNESS_MAP - check size*/ 1043 cam_sharpness_map_t *sharpnessMap = (cam_sharpness_map_t *) 1044 POINTER_OF(CAM_INTF_META_STATS_SHARPNESS_MAP, metadata); 1045 camMetadata.update(ANDROID_STATISTICS_SHARPNESS_MAP, 1046 (int32_t*)sharpnessMap->sharpness, 1047 CAM_MAX_MAP_WIDTH*CAM_MAX_MAP_HEIGHT); 1048 1049 resultMetadata = camMetadata.release(); 1050 return NULL; 1051} 1052 1053/*=========================================================================== 1054 * FUNCTION : convertRegions 1055 * 1056 * DESCRIPTION: helper method to convert from cam_rect_t into int32_t array 1057 * 1058 * PARAMETERS : 1059 * @rect : cam_rect_t struct to convert 1060 * @region : int32_t destination array 1061 * @weight : if we are converting from cam_area_t, weight is valid 1062 * else weight = -1 1063 * 1064 *==========================================================================*/ 1065void QCamera3HardwareInterface::convertRegions(cam_rect_t rect, int32_t* region, int weight){ 1066 region[0] = rect.left; 1067 region[1] = rect.top; 1068 region[2] = rect.width; 1069 region[3] = rect.height; 1070 if (weight > -1) { 1071 region[4] = weight; 1072 } 1073} 1074/*=========================================================================== 1075 * FUNCTION : convertLandmarks 1076 * 1077 * DESCRIPTION: helper method to extract the landmarks from face detection info 1078 * 1079 * PARAMETERS : 1080 * @face : cam_rect_t struct to convert 1081 * @landmarks : int32_t destination array 1082 * 1083 * 1084 *==========================================================================*/ 1085void QCamera3HardwareInterface::convertLandmarks(cam_face_detection_info_t face, int32_t* landmarks) 1086{ 1087 landmarks[0] = face.left_eye_center.x; 1088 landmarks[1] = face.left_eye_center.y; 1089 landmarks[2] = face.right_eye_center.y; 1090 landmarks[3] = face.right_eye_center.y; 1091 landmarks[4] = face.mouth_center.x; 1092 landmarks[5] = face.mouth_center.y; 1093} 1094 1095#define DATA_PTR(MEM_OBJ,INDEX) MEM_OBJ->getPtr( INDEX ) 1096/*=========================================================================== 1097 * FUNCTION : initCapabilities 1098 * 1099 * DESCRIPTION: initialize camera capabilities in static data struct 1100 * 1101 * PARAMETERS : 1102 * @cameraId : camera Id 1103 * 1104 * RETURN : int32_t type of status 1105 * NO_ERROR -- success 1106 * none-zero failure code 1107 *==========================================================================*/ 1108int QCamera3HardwareInterface::initCapabilities(int cameraId) 1109{ 1110 int rc = 0; 1111 mm_camera_vtbl_t *cameraHandle = NULL; 1112 QCamera3HeapMemory *capabilityHeap = NULL; 1113 1114 cameraHandle = camera_open(cameraId); 1115 if (!cameraHandle) { 1116 ALOGE("%s: camera_open failed", __func__); 1117 rc = -1; 1118 goto open_failed; 1119 } 1120 1121 capabilityHeap = new QCamera3HeapMemory(); 1122 if (capabilityHeap == NULL) { 1123 ALOGE("%s: creation of capabilityHeap failed", __func__); 1124 goto heap_creation_failed; 1125 } 1126 /* Allocate memory for capability buffer */ 1127 rc = capabilityHeap->allocate(1, sizeof(cam_capability_t), false); 1128 if(rc != OK) { 1129 ALOGE("%s: No memory for cappability", __func__); 1130 goto allocate_failed; 1131 } 1132 1133 /* Map memory for capability buffer */ 1134 memset(DATA_PTR(capabilityHeap,0), 0, sizeof(cam_capability_t)); 1135 rc = cameraHandle->ops->map_buf(cameraHandle->camera_handle, 1136 CAM_MAPPING_BUF_TYPE_CAPABILITY, 1137 capabilityHeap->getFd(0), 1138 sizeof(cam_capability_t)); 1139 if(rc < 0) { 1140 ALOGE("%s: failed to map capability buffer", __func__); 1141 goto map_failed; 1142 } 1143 1144 /* Query Capability */ 1145 rc = cameraHandle->ops->query_capability(cameraHandle->camera_handle); 1146 if(rc < 0) { 1147 ALOGE("%s: failed to query capability",__func__); 1148 goto query_failed; 1149 } 1150 gCamCapability[cameraId] = (cam_capability_t *)malloc(sizeof(cam_capability_t)); 1151 if (!gCamCapability[cameraId]) { 1152 ALOGE("%s: out of memory", __func__); 1153 goto query_failed; 1154 } 1155 memcpy(gCamCapability[cameraId], DATA_PTR(capabilityHeap,0), 1156 sizeof(cam_capability_t)); 1157 rc = 0; 1158 1159query_failed: 1160 cameraHandle->ops->unmap_buf(cameraHandle->camera_handle, 1161 CAM_MAPPING_BUF_TYPE_CAPABILITY); 1162map_failed: 1163 capabilityHeap->deallocate(); 1164allocate_failed: 1165 delete capabilityHeap; 1166heap_creation_failed: 1167 cameraHandle->ops->close_camera(cameraHandle->camera_handle); 1168 cameraHandle = NULL; 1169open_failed: 1170 return rc; 1171} 1172 1173/*=========================================================================== 1174 * FUNCTION : initParameters 1175 * 1176 * DESCRIPTION: initialize camera parameters 1177 * 1178 * PARAMETERS : 1179 * 1180 * RETURN : int32_t type of status 1181 * NO_ERROR -- success 1182 * none-zero failure code 1183 *==========================================================================*/ 1184int QCamera3HardwareInterface::initParameters() 1185{ 1186 int rc = 0; 1187 1188 //Allocate Set Param Buffer 1189 mParamHeap = new QCamera3HeapMemory(); 1190 rc = mParamHeap->allocate(1, sizeof(parm_buffer_t), false); 1191 if(rc != OK) { 1192 rc = NO_MEMORY; 1193 ALOGE("Failed to allocate SETPARM Heap memory"); 1194 delete mParamHeap; 1195 mParamHeap = NULL; 1196 return rc; 1197 } 1198 1199 //Map memory for parameters buffer 1200 rc = mCameraHandle->ops->map_buf(mCameraHandle->camera_handle, 1201 CAM_MAPPING_BUF_TYPE_PARM_BUF, 1202 mParamHeap->getFd(0), 1203 sizeof(parm_buffer_t)); 1204 if(rc < 0) { 1205 ALOGE("%s:failed to map SETPARM buffer",__func__); 1206 rc = FAILED_TRANSACTION; 1207 mParamHeap->deallocate(); 1208 delete mParamHeap; 1209 mParamHeap = NULL; 1210 return rc; 1211 } 1212 1213 mParameters = (parm_buffer_t*) DATA_PTR(mParamHeap,0); 1214 memset(mParameters, 0, sizeof(parm_buffer_t)); 1215 mParameters->first_flagged_entry = CAM_INTF_PARM_MAX; 1216 return rc; 1217} 1218 1219/*=========================================================================== 1220 * FUNCTION : initStaticMetadata 1221 * 1222 * DESCRIPTION: initialize the static metadata 1223 * 1224 * PARAMETERS : 1225 * @cameraId : camera Id 1226 * 1227 * RETURN : int32_t type of status 1228 * 0 -- success 1229 * non-zero failure code 1230 *==========================================================================*/ 1231int QCamera3HardwareInterface::initStaticMetadata(int cameraId) 1232{ 1233 int rc = 0; 1234 CameraMetadata staticInfo; 1235 int facingBack = gCamCapability[cameraId]->position == CAM_POSITION_BACK; 1236 /*HAL 3 only*/ 1237 #ifdef HAL_3_CAPABILITIES 1238 staticInfo.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 1239 &gCamCapability[cameraId]->min_focus_distance, 1); 1240 1241 staticInfo.update(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, 1242 &gCamCapability[cameraId]->hyper_focal_distance, 1); 1243 1244 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, 1245 gCamCapability[cameraId]->focal_lengths, 1246 gCamCapability[cameraId]->focal_lengths_count); 1247 1248 1249 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_APERTURES, 1250 gCamCapability[cameraId]->apertures, 1251 gCamCapability[cameraId]->apertures_count); 1252 1253 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, 1254 gCamCapability[cameraId]->filter_densities, 1255 gCamCapability[cameraId]->filter_densities_count); 1256 1257 1258 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, 1259 (int*)gCamCapability[cameraId]->optical_stab_modes, 1260 gCamCapability[cameraId]->optical_stab_modes_count); 1261 1262 staticInfo.update(ANDROID_LENS_POSITION, 1263 gCamCapability[cameraId]->lens_position, 1264 sizeof(gCamCapability[cameraId]->lens_position)/ sizeof(float)); 1265 1266 static const int32_t lens_shading_map_size[] = {gCamCapability[cameraId]->lens_shading_map_size.width, 1267 gCamCapability[cameraId]->lens_shading_map_size.height}; 1268 staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE, 1269 lens_shading_map_size, 1270 sizeof(lens_shading_map_size)/sizeof(int32_t)); 1271 1272 staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP, gCamCapability[cameraId]->lens_shading_map, 1273 sizeof(gCamCapability[cameraId]->lens_shading_map_size)/ sizeof(cam_dimension_t)); 1274 1275 static const int32_t geo_correction_map_size[] = {gCamCapability[cameraId]->geo_correction_map_size.width, 1276 gCamCapability[cameraId]->geo_correction_map_size.height}; 1277 staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE, 1278 geo_correction_map_size, 1279 sizeof(geo_correction_map_size)/sizeof(int32_t)); 1280 1281 staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP, 1282 gCamCapability[cameraId]->geo_correction_map, 1283 sizeof(gCamCapability[cameraId]->geo_correction_map_size)/ sizeof(cam_dimension_t)); 1284 1285 staticInfo.update(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, 1286 gCamCapability[cameraId]->sensor_physical_size, 2); 1287 1288 staticInfo.update(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, 1289 gCamCapability[cameraId]->exposure_time_range, 2); 1290 1291 staticInfo.update(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, 1292 &gCamCapability[cameraId]->max_frame_duration, 1); 1293 1294 1295 staticInfo.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, 1296 (int*)&gCamCapability[cameraId]->color_arrangement, 1); 1297 1298 static const int32_t pixel_array_size[] = {gCamCapability[cameraId]->pixel_array_size.width, 1299 gCamCapability[cameraId]->pixel_array_size.height}; 1300 staticInfo.update(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, 1301 pixel_array_size, 2); 1302 1303 static const int32_t active_array_size[] = {gCamCapability[cameraId]->active_array_size.width, 1304 gCamCapability[cameraId]->active_array_size.height}; 1305 staticInfo.update(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, 1306 active_array_size, 2); 1307 1308 staticInfo.update(ANDROID_SENSOR_INFO_WHITE_LEVEL, 1309 &gCamCapability[cameraId]->white_level, 1); 1310 1311 staticInfo.update(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, 1312 gCamCapability[cameraId]->black_level_pattern, 4); 1313 1314 staticInfo.update(ANDROID_FLASH_INFO_CHARGE_DURATION, 1315 &gCamCapability[cameraId]->flash_charge_duration, 1); 1316 1317 staticInfo.update(ANDROID_TONEMAP_MAX_CURVE_POINTS, 1318 &gCamCapability[cameraId]->max_tone_map_curve_points, 1); 1319 1320 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 1321 (int*)&gCamCapability[cameraId]->max_face_detection_count, 1); 1322 1323 staticInfo.update(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT, 1324 &gCamCapability[cameraId]->histogram_size, 1); 1325 1326 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT, 1327 &gCamCapability[cameraId]->max_histogram_count, 1); 1328 1329 static const int32_t sharpness_map_size[] = {gCamCapability[cameraId]->sharpness_map_size.width, 1330 gCamCapability[cameraId]->sharpness_map_size.height}; 1331 1332 staticInfo.update(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE, 1333 sharpness_map_size, sizeof(sharpness_map_size)/sizeof(int32_t)); 1334 1335 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE, 1336 &gCamCapability[cameraId]->max_sharpness_map_value, 1); 1337 1338 1339 staticInfo.update(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS, 1340 &gCamCapability[cameraId]->raw_min_duration, 1341 1); 1342 1343 static int32_t scalar_formats[CAM_FORMAT_MAX]; 1344 for (int i = 0; i < gCamCapability[cameraId]->supported_scalar_format_cnt; i++) { 1345 scalar_formats[i] = getScalarFormat(gCamCapability[cameraId]->supported_scalar_fmts[i]); 1346 } 1347 staticInfo.update(ANDROID_SCALER_AVAILABLE_FORMATS, 1348 scalar_formats, 1349 sizeof(scalar_formats)/sizeof(int32_t)); 1350 1351 static int32_t available_processed_sizes[CAM_FORMAT_MAX]; 1352 makeTable(gCamCapability[cameraId]->supported_sizes_tbl, 1353 gCamCapability[cameraId]->supported_sizes_tbl_cnt, 1354 available_processed_sizes); 1355 staticInfo.update(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 1356 available_processed_sizes, 1357 sizeof(available_processed_sizes)/sizeof(int32_t)); 1358 #else 1359 const float minFocusDistance = 0; 1360 staticInfo.update(ANDROID_LENS_INFO_MINIMUM_FOCUS_DISTANCE, 1361 &minFocusDistance, 1); 1362 1363 const float hyperFocusDistance = 0; 1364 staticInfo.update(ANDROID_LENS_INFO_HYPERFOCAL_DISTANCE, 1365 &hyperFocusDistance, 1); 1366 1367 static const float focalLength = 3.30f; 1368 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS, 1369 &focalLength, 1370 1); 1371 1372 static const float aperture = 2.8f; 1373 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_APERTURES, 1374 &aperture, 1375 1); 1376 1377 static const float filterDensity = 0; 1378 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, 1379 &filterDensity, 1); 1380 1381 static const uint8_t availableOpticalStabilization = 1382 ANDROID_LENS_OPTICAL_STABILIZATION_MODE_OFF; 1383 staticInfo.update(ANDROID_LENS_INFO_AVAILABLE_OPTICAL_STABILIZATION, 1384 &availableOpticalStabilization, 1); 1385 1386 float lensPosition[3]; 1387 if (facingBack) { 1388 // Back-facing camera is center-top on device 1389 lensPosition[0] = 0; 1390 lensPosition[1] = 20; 1391 lensPosition[2] = -5; 1392 } else { 1393 // Front-facing camera is center-right on device 1394 lensPosition[0] = 20; 1395 lensPosition[1] = 20; 1396 lensPosition[2] = 0; 1397 } 1398 staticInfo.update(ANDROID_LENS_POSITION, 1399 lensPosition, 1400 sizeof(lensPosition)/ sizeof(float)); 1401 1402 static const int32_t lensShadingMapSize[] = {1, 1}; 1403 staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE, 1404 lensShadingMapSize, 1405 sizeof(lensShadingMapSize)/sizeof(int32_t)); 1406 1407 static const float lensShadingMap[3 * 1 * 1 ] = 1408 { 1.f, 1.f, 1.f }; 1409 staticInfo.update(ANDROID_LENS_INFO_SHADING_MAP, 1410 lensShadingMap, 1411 sizeof(lensShadingMap)/ sizeof(float)); 1412 1413 static const int32_t geometricCorrectionMapSize[] = {2, 2}; 1414 staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP_SIZE, 1415 geometricCorrectionMapSize, 1416 sizeof(geometricCorrectionMapSize)/sizeof(int32_t)); 1417 1418 static const float geometricCorrectionMap[2 * 3 * 2 * 2] = { 1419 0.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1420 1.f, 0.f, 1.f, 0.f, 1.f, 0.f, 1421 0.f, 1.f, 0.f, 1.f, 0.f, 1.f, 1422 1.f, 1.f, 1.f, 1.f, 1.f, 1.f}; 1423 staticInfo.update(ANDROID_LENS_INFO_GEOMETRIC_CORRECTION_MAP, 1424 geometricCorrectionMap, 1425 sizeof(geometricCorrectionMap)/ sizeof(float)); 1426 1427 static const float sensorPhysicalSize[2] = {3.20f, 2.40f}; 1428 staticInfo.update(ANDROID_SENSOR_INFO_PHYSICAL_SIZE, 1429 sensorPhysicalSize, 2); 1430 1431 const int64_t exposureTimeRange[2] = {1000L, 30000000000L} ; // 1 us - 30 sec 1432 staticInfo.update(ANDROID_SENSOR_INFO_EXPOSURE_TIME_RANGE, 1433 exposureTimeRange, 2); 1434 1435 const int64_t frameDurationRange[2] = {33331760L, 30000000000L}; 1436 staticInfo.update(ANDROID_SENSOR_INFO_MAX_FRAME_DURATION, 1437 frameDurationRange, 1); 1438 1439 const uint8_t colorFilterArrangement = 1440 ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT_RGGB; 1441 staticInfo.update(ANDROID_SENSOR_INFO_COLOR_FILTER_ARRANGEMENT, 1442 &colorFilterArrangement, 1); 1443 1444 const int resolution[2] = {640, 480}; 1445 staticInfo.update(ANDROID_SENSOR_INFO_PIXEL_ARRAY_SIZE, 1446 resolution, 2); 1447 1448 staticInfo.update(ANDROID_SENSOR_INFO_ACTIVE_ARRAY_SIZE, 1449 resolution, 2); 1450 1451 const uint32_t whiteLevel = 4000; 1452 staticInfo.update(ANDROID_SENSOR_INFO_WHITE_LEVEL, 1453 (int32_t*)&whiteLevel, 1); 1454 1455 static const int32_t blackLevelPattern[4] = { 1456 1000, 1000, 1457 1000, 1000 }; 1458 staticInfo.update(ANDROID_SENSOR_BLACK_LEVEL_PATTERN, 1459 blackLevelPattern, 4); 1460 1461 static const int64_t flashChargeDuration = 0; 1462 staticInfo.update(ANDROID_FLASH_INFO_CHARGE_DURATION, 1463 &flashChargeDuration, 1); 1464 1465 static const int32_t tonemapCurvePoints = 128; 1466 staticInfo.update(ANDROID_TONEMAP_MAX_CURVE_POINTS, 1467 &tonemapCurvePoints, 1); 1468 1469 static const int32_t maxFaceCount = 8; 1470 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_FACE_COUNT, 1471 &maxFaceCount, 1); 1472 1473 static const int32_t histogramSize = 64; 1474 staticInfo.update(ANDROID_STATISTICS_INFO_HISTOGRAM_BUCKET_COUNT, 1475 &histogramSize, 1); 1476 1477 static const int32_t maxHistogramCount = 1000; 1478 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_HISTOGRAM_COUNT, 1479 &maxHistogramCount, 1); 1480 1481 static const int32_t sharpnessMapSize[2] = {64, 64}; 1482 staticInfo.update(ANDROID_STATISTICS_INFO_SHARPNESS_MAP_SIZE, 1483 sharpnessMapSize, sizeof(sharpnessMapSize)/sizeof(int32_t)); 1484 1485 static const int32_t maxSharpnessMapValue = 1000; 1486 staticInfo.update(ANDROID_STATISTICS_INFO_MAX_SHARPNESS_MAP_VALUE, 1487 &maxSharpnessMapValue, 1); 1488 1489 static const uint8_t availableVstabModes[] = {ANDROID_CONTROL_VIDEO_STABILIZATION_MODE_OFF}; 1490 staticInfo.update(ANDROID_CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, 1491 availableVstabModes, sizeof(availableVstabModes)); 1492 1493 const uint64_t availableRawMinDurations[1] = {33331760L}; 1494 staticInfo.update(ANDROID_SCALER_AVAILABLE_RAW_MIN_DURATIONS, 1495 (int64_t*)&availableRawMinDurations, 1496 1); 1497 1498 const uint32_t availableFormats[4] = { 1499 HAL_PIXEL_FORMAT_RAW_SENSOR, 1500 HAL_PIXEL_FORMAT_BLOB, 1501 HAL_PIXEL_FORMAT_RGBA_8888, 1502 HAL_PIXEL_FORMAT_YCrCb_420_SP 1503 }; 1504 staticInfo.update(ANDROID_SCALER_AVAILABLE_FORMATS, 1505 (int32_t*)availableFormats, 1506 4); 1507 1508 const uint32_t availableProcessedSizes[4] = {640, 480, 320, 240}; 1509 staticInfo.update(ANDROID_SCALER_AVAILABLE_PROCESSED_SIZES, 1510 (int32_t*)availableProcessedSizes, 1511 sizeof(availableProcessedSizes)/sizeof(int32_t)); 1512 1513 staticInfo.update(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 1514 resolution, 1515 sizeof(resolution)/sizeof(int)); 1516 1517 static const uint8_t availableFaceDetectModes[] = { 1518 ANDROID_STATISTICS_FACE_DETECT_MODE_OFF }; 1519 1520 staticInfo.update(ANDROID_STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES, 1521 availableFaceDetectModes, 1522 sizeof(availableFaceDetectModes)); 1523 1524 static const uint8_t availableSceneModes[] = { 1525 ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED }; 1526 1527 staticInfo.update(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 1528 availableSceneModes, sizeof(availableSceneModes)); 1529 1530 static const int32_t availableFpsRanges[] = {15, 30}; 1531 staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_TARGET_FPS_RANGES, 1532 availableFpsRanges, sizeof(availableFpsRanges)/sizeof(int32_t)); 1533 1534 static const uint8_t availableEffectsModes[] = { 1535 ANDROID_CONTROL_EFFECT_MODE_OFF }; 1536 staticInfo.update(ANDROID_CONTROL_AVAILABLE_EFFECTS, 1537 availableEffectsModes, sizeof(availableEffectsModes)); 1538 1539 static const uint8_t availableAntibandingModes[] = { 1540 ANDROID_CONTROL_AE_ANTIBANDING_MODE_OFF }; 1541 staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, 1542 availableAntibandingModes, sizeof(availableAntibandingModes)); 1543 1544 static const uint8_t flashAvailable = 0; 1545 staticInfo.update(ANDROID_FLASH_INFO_AVAILABLE, 1546 &flashAvailable, sizeof(flashAvailable)); 1547 1548 static const int32_t max3aRegions = 0; 1549 staticInfo.update(ANDROID_CONTROL_MAX_REGIONS, 1550 &max3aRegions, 1); 1551 1552 static const camera_metadata_rational exposureCompensationStep = { 1553 1, 3 1554 }; 1555 staticInfo.update(ANDROID_CONTROL_AE_COMPENSATION_STEP, 1556 &exposureCompensationStep, 1); 1557 1558 static const int32_t jpegThumbnailSizes[] = { 1559 0, 0, 1560 160, 120, 1561 320, 240 1562 }; 1563 staticInfo.update(ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES, 1564 jpegThumbnailSizes, sizeof(jpegThumbnailSizes)/sizeof(int32_t)); 1565 1566 static const int32_t maxZoom = 10; 1567 staticInfo.update(ANDROID_SCALER_AVAILABLE_MAX_DIGITAL_ZOOM, 1568 &maxZoom, 1); 1569 1570 static int64_t jpegMinDuration[] = {33331760L, 30000000000L}; 1571 staticInfo.update(ANDROID_SCALER_AVAILABLE_JPEG_MIN_DURATIONS, 1572 jpegMinDuration, 1573 sizeof(jpegMinDuration)/sizeof(uint64_t)); 1574 #endif 1575 /*HAL 1 and HAL 3 common*/ 1576 static const int32_t raw_size[] = {gCamCapability[cameraId]->raw_dim.width, 1577 gCamCapability[cameraId]->raw_dim.height}; 1578 staticInfo.update(ANDROID_SCALER_AVAILABLE_RAW_SIZES, 1579 raw_size, 1580 sizeof(raw_size)/sizeof(uint32_t)); 1581 1582 static const int32_t exposureCompensationRange[] = {gCamCapability[cameraId]->exposure_compensation_min, 1583 gCamCapability[cameraId]->exposure_compensation_max}; 1584 staticInfo.update(ANDROID_CONTROL_AE_COMPENSATION_RANGE, 1585 exposureCompensationRange, 1586 sizeof(exposureCompensationRange)/sizeof(int32_t)); 1587 1588 uint8_t lensFacing = (facingBack) ? 1589 ANDROID_LENS_FACING_BACK : ANDROID_LENS_FACING_FRONT; 1590 staticInfo.update(ANDROID_LENS_FACING, &lensFacing, 1); 1591 1592 static int32_t available_jpeg_sizes[MAX_SIZES_CNT]; 1593 makeTable(gCamCapability[cameraId]->picture_sizes_tbl, 1594 gCamCapability[cameraId]->picture_sizes_tbl_cnt, 1595 available_jpeg_sizes); 1596 staticInfo.update(ANDROID_SCALER_AVAILABLE_JPEG_SIZES, 1597 available_jpeg_sizes, 1598 sizeof(available_jpeg_sizes)/sizeof(int32_t)); 1599 1600 static int32_t max_jpeg_size = 0; 1601 int temp_width, temp_height; 1602 for (int i = 0; i < gCamCapability[cameraId]->picture_sizes_tbl_cnt; i++) { 1603 temp_width = gCamCapability[cameraId]->picture_sizes_tbl[i].width; 1604 temp_height = gCamCapability[cameraId]->picture_sizes_tbl[i].height; 1605 if (temp_width * temp_height > max_jpeg_size ) { 1606 max_jpeg_size = temp_width * temp_height; 1607 } 1608 } 1609 max_jpeg_size = max_jpeg_size * 3/2 + sizeof(camera3_jpeg_blob_t); 1610 staticInfo.update(ANDROID_JPEG_MAX_SIZE, 1611 &max_jpeg_size, 1); 1612 1613 static int32_t avail_effects[CAM_EFFECT_MODE_MAX]; 1614 for (int i = 0; i < gCamCapability[cameraId]->supported_effects_cnt; i++) { 1615 avail_effects[i] = lookupFwkName(EFFECT_MODES_MAP, 1616 sizeof(EFFECT_MODES_MAP)/sizeof(int), 1617 gCamCapability[cameraId]->supported_effects[i]); 1618 } 1619 staticInfo.update(ANDROID_CONTROL_AVAILABLE_EFFECTS, 1620 avail_effects, 1621 sizeof(avail_effects)/sizeof(int32_t)); 1622 1623 static int32_t avail_scene_modes[CAM_SCENE_MODE_MAX]; 1624 for (int i = 0; i < gCamCapability[cameraId]->supported_scene_modes_cnt; i++) { 1625 avail_scene_modes[i] = lookupFwkName(SCENE_MODES_MAP, 1626 sizeof(SCENE_MODES_MAP)/sizeof(int), 1627 gCamCapability[cameraId]->supported_scene_modes[i]); 1628 } 1629 staticInfo.update(ANDROID_CONTROL_AVAILABLE_SCENE_MODES, 1630 avail_scene_modes, 1631 sizeof(avail_scene_modes)/sizeof(int32_t)); 1632 1633 static int32_t avail_antibanding_modes[CAM_ANTIBANDING_MODE_MAX]; 1634 for (int i = 0; i < gCamCapability[cameraId]->supported_antibandings_cnt; i++) { 1635 avail_antibanding_modes[i] = lookupFwkName(ANTIBANDING_MODES_MAP, 1636 sizeof(ANTIBANDING_MODES_MAP)/sizeof(int), 1637 gCamCapability[cameraId]->supported_antibandings[i]); 1638 } 1639 staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_ANTIBANDING_MODES, 1640 avail_antibanding_modes, 1641 sizeof(avail_antibanding_modes)/sizeof(int32_t)); 1642 1643 static uint8_t avail_af_modes[CAM_FOCUS_MODE_MAX]; 1644 for (int i = 0; i < gCamCapability[cameraId]->supported_focus_modes_cnt; i++) { 1645 avail_af_modes[i] = lookupFwkName(FOCUS_MODES_MAP, 1646 sizeof(FOCUS_MODES_MAP)/sizeof(int), 1647 gCamCapability[cameraId]->supported_focus_modes[i]); 1648 } 1649 staticInfo.update(ANDROID_CONTROL_AF_AVAILABLE_MODES, 1650 avail_af_modes, 1651 sizeof(avail_af_modes)); 1652 1653 static int32_t avail_awb_modes[CAM_WB_MODE_MAX]; 1654 for (int i = 0; i < gCamCapability[cameraId]->supported_white_balances_cnt; i++) { 1655 avail_awb_modes[i] = lookupFwkName(WHITE_BALANCE_MODES_MAP, 1656 sizeof(WHITE_BALANCE_MODES_MAP)/sizeof(int), 1657 gCamCapability[cameraId]->supported_white_balances[i]); 1658 } 1659 staticInfo.update(ANDROID_CONTROL_AWB_AVAILABLE_MODES, 1660 avail_awb_modes, 1661 sizeof(avail_awb_modes)/sizeof(int32_t)); 1662 1663 static int32_t avail_flash_modes[CAM_FLASH_MODE_MAX]; 1664 for (int i = 0; i < gCamCapability[cameraId]->supported_flash_modes_cnt; i++) { 1665 avail_flash_modes[i] = lookupFwkName(FLASH_MODES_MAP, 1666 sizeof(FLASH_MODES_MAP)/sizeof(int), 1667 gCamCapability[cameraId]->supported_flash_modes[i]); 1668 } 1669 staticInfo.update(ANDROID_FLASH_MODE, 1670 avail_flash_modes, 1671 sizeof(avail_flash_modes)/sizeof(int32_t)); 1672 1673 /*so far fwk seems to support only 2 aec modes on and off*/ 1674 static const uint8_t avail_ae_modes[] = { 1675 ANDROID_CONTROL_AE_MODE_OFF, 1676 ANDROID_CONTROL_AE_MODE_ON 1677 }; 1678 staticInfo.update(ANDROID_CONTROL_AE_AVAILABLE_MODES, 1679 avail_ae_modes, 1680 sizeof(avail_ae_modes)); 1681 1682 gStaticMetadata = staticInfo.release(); 1683 return rc; 1684} 1685 1686/*=========================================================================== 1687 * FUNCTION : makeTable 1688 * 1689 * DESCRIPTION: make a table of sizes 1690 * 1691 * PARAMETERS : 1692 * 1693 * 1694 * 1695 * RETURN : int32_t type of status 1696 * NO_ERROR -- success 1697 * none-zero failure code 1698 *==========================================================================*/ 1699void QCamera3HardwareInterface::makeTable(cam_dimension_t* dimTable, uint8_t size, 1700 int32_t* sizeTable) 1701{ 1702 int j = 0; 1703 for (int i = 0; i < size; i++) { 1704 sizeTable[j] = dimTable[i].width; 1705 sizeTable[j+1] = dimTable[i].height; 1706 j+=2; 1707 } 1708} 1709/*=========================================================================== 1710 * FUNCTION : getPreviewHalPixelFormat 1711 * 1712 * DESCRIPTION: convert the format to type recognized by framework 1713 * 1714 * PARAMETERS : format : the format from backend 1715 * 1716 ** RETURN : format recognized by framework 1717 * 1718 *==========================================================================*/ 1719int32_t QCamera3HardwareInterface::getScalarFormat(int32_t format) 1720{ 1721 int32_t halPixelFormat; 1722 1723 switch (format) { 1724 case CAM_FORMAT_YUV_420_NV12: 1725 halPixelFormat = HAL_PIXEL_FORMAT_YCbCr_420_SP; 1726 break; 1727 case CAM_FORMAT_YUV_420_NV21: 1728 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 1729 break; 1730 case CAM_FORMAT_YUV_420_NV21_ADRENO: 1731 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP_ADRENO; 1732 break; 1733 case CAM_FORMAT_YUV_420_YV12: 1734 halPixelFormat = HAL_PIXEL_FORMAT_YV12; 1735 break; 1736 case CAM_FORMAT_YUV_422_NV16: 1737 case CAM_FORMAT_YUV_422_NV61: 1738 default: 1739 halPixelFormat = HAL_PIXEL_FORMAT_YCrCb_420_SP; 1740 break; 1741 } 1742 return halPixelFormat; 1743} 1744 1745/*=========================================================================== 1746 * FUNCTION : AddSetParmEntryToBatch 1747 * 1748 * DESCRIPTION: add set parameter entry into batch 1749 * 1750 * PARAMETERS : 1751 * @p_table : ptr to parameter buffer 1752 * @paramType : parameter type 1753 * @paramLength : length of parameter value 1754 * @paramValue : ptr to parameter value 1755 * 1756 * RETURN : int32_t type of status 1757 * NO_ERROR -- success 1758 * none-zero failure code 1759 *==========================================================================*/ 1760int32_t QCamera3HardwareInterface::AddSetParmEntryToBatch(parm_buffer_t *p_table, 1761 cam_intf_parm_type_t paramType, 1762 uint32_t paramLength, 1763 void *paramValue) 1764{ 1765 int position = paramType; 1766 int current, next; 1767 1768 /************************************************************************* 1769 * Code to take care of linking next flags * 1770 *************************************************************************/ 1771 current = GET_FIRST_PARAM_ID(p_table); 1772 if (position == current){ 1773 //DO NOTHING 1774 } else if (position < current){ 1775 SET_NEXT_PARAM_ID(position, p_table, current); 1776 SET_FIRST_PARAM_ID(p_table, position); 1777 } else { 1778 /* Search for the position in the linked list where we need to slot in*/ 1779 while (position > GET_NEXT_PARAM_ID(current, p_table)) 1780 current = GET_NEXT_PARAM_ID(current, p_table); 1781 1782 /*If node already exists no need to alter linking*/ 1783 if (position != GET_NEXT_PARAM_ID(current, p_table)) { 1784 next = GET_NEXT_PARAM_ID(current, p_table); 1785 SET_NEXT_PARAM_ID(current, p_table, position); 1786 SET_NEXT_PARAM_ID(position, p_table, next); 1787 } 1788 } 1789 1790 /************************************************************************* 1791 * Copy contents into entry * 1792 *************************************************************************/ 1793 1794 if (paramLength > sizeof(parm_type_t)) { 1795 ALOGE("%s:Size of input larger than max entry size",__func__); 1796 return BAD_VALUE; 1797 } 1798 memcpy(POINTER_OF(paramType,p_table), paramValue, paramLength); 1799 return NO_ERROR; 1800} 1801 1802/*=========================================================================== 1803 * FUNCTION : lookupFwkName 1804 * 1805 * DESCRIPTION: In case the enum is not same in fwk and backend 1806 * make sure the parameter is correctly propogated 1807 * 1808 * PARAMETERS : 1809 * @arr : map between the two enums 1810 * @len : len of the map 1811 * @hal_name : name of the hal_parm to map 1812 * 1813 * RETURN : int type of status 1814 * fwk_name -- success 1815 * none-zero failure code 1816 *==========================================================================*/ 1817int QCamera3HardwareInterface::lookupFwkName(const QCameraMap arr[], 1818 int len, int hal_name) 1819{ 1820 1821 for (int i = 0; i < len; i++) { 1822 if (arr[i].hal_name == hal_name) 1823 return arr[i].fwk_name; 1824 } 1825 return NAME_NOT_FOUND; 1826} 1827 1828/*=========================================================================== 1829 * FUNCTION : lookupHalName 1830 * 1831 * DESCRIPTION: In case the enum is not same in fwk and backend 1832 * make sure the parameter is correctly propogated 1833 * 1834 * PARAMETERS : 1835 * @arr : map between the two enums 1836 * @len : len of the map 1837 * @fwk_name : name of the hal_parm to map 1838 * 1839 * RETURN : int32_t type of status 1840 * hal_name -- success 1841 * none-zero failure code 1842 *==========================================================================*/ 1843int QCamera3HardwareInterface::lookupHalName(const QCameraMap arr[], 1844 int len, int fwk_name) 1845{ 1846 for (int i = 0; i < len; i++) { 1847 if (arr[i].fwk_name == fwk_name) 1848 return arr[i].hal_name; 1849 } 1850 return NAME_NOT_FOUND; 1851} 1852 1853/*=========================================================================== 1854 * FUNCTION : getCapabilities 1855 * 1856 * DESCRIPTION: query camera capabilities 1857 * 1858 * PARAMETERS : 1859 * @cameraId : camera Id 1860 * @info : camera info struct to be filled in with camera capabilities 1861 * 1862 * RETURN : int32_t type of status 1863 * NO_ERROR -- success 1864 * none-zero failure code 1865 *==========================================================================*/ 1866int QCamera3HardwareInterface::getCamInfo(int cameraId, 1867 struct camera_info *info) 1868{ 1869 int rc = 0; 1870 1871 if (NULL == gCamCapability[cameraId]) { 1872 rc = initCapabilities(cameraId); 1873 if (rc < 0) { 1874 //pthread_mutex_unlock(&g_camlock); 1875 return rc; 1876 } 1877 } 1878 1879 if (NULL == gStaticMetadata) { 1880 rc = initStaticMetadata(cameraId); 1881 if (rc < 0) { 1882 return rc; 1883 } 1884 } 1885 1886 switch(gCamCapability[cameraId]->position) { 1887 case CAM_POSITION_BACK: 1888 info->facing = CAMERA_FACING_BACK; 1889 break; 1890 1891 case CAM_POSITION_FRONT: 1892 info->facing = CAMERA_FACING_FRONT; 1893 break; 1894 1895 default: 1896 ALOGE("%s:Unknown position type for camera id:%d", __func__, cameraId); 1897 rc = -1; 1898 break; 1899 } 1900 1901 1902 info->orientation = gCamCapability[cameraId]->sensor_mount_angle; 1903 info->device_version = HARDWARE_DEVICE_API_VERSION(3, 0); 1904 info->static_camera_characteristics = gStaticMetadata; 1905 1906 return rc; 1907} 1908 1909/*=========================================================================== 1910 * FUNCTION : translateMetadata 1911 * 1912 * DESCRIPTION: translate the metadata into camera_metadata_t 1913 * 1914 * PARAMETERS : type of the request 1915 * 1916 * 1917 * RETURN : success: camera_metadata_t* 1918 * failure: NULL 1919 * 1920 *==========================================================================*/ 1921camera_metadata_t* QCamera3HardwareInterface::translateCapabilityToMetadata(int type) 1922{ 1923 pthread_mutex_lock(&mMutex); 1924 1925 if (mDefaultMetadata[type] != NULL) { 1926 pthread_mutex_unlock(&mMutex); 1927 return mDefaultMetadata[type]; 1928 } 1929 //first time we are handling this request 1930 //fill up the metadata structure using the wrapper class 1931 CameraMetadata settings; 1932 //translate from cam_capability_t to camera_metadata_tag_t 1933 static const uint8_t requestType = ANDROID_REQUEST_TYPE_CAPTURE; 1934 settings.update(ANDROID_REQUEST_TYPE, &requestType, 1); 1935 1936 /*control*/ 1937 1938 uint8_t controlIntent = 0; 1939 switch (type) { 1940 case CAMERA3_TEMPLATE_PREVIEW: 1941 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_PREVIEW; 1942 break; 1943 case CAMERA3_TEMPLATE_STILL_CAPTURE: 1944 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_STILL_CAPTURE; 1945 break; 1946 case CAMERA3_TEMPLATE_VIDEO_RECORD: 1947 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_RECORD; 1948 break; 1949 case CAMERA3_TEMPLATE_VIDEO_SNAPSHOT: 1950 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_VIDEO_SNAPSHOT; 1951 break; 1952 case CAMERA3_TEMPLATE_ZERO_SHUTTER_LAG: 1953 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_ZERO_SHUTTER_LAG; 1954 break; 1955 default: 1956 controlIntent = ANDROID_CONTROL_CAPTURE_INTENT_CUSTOM; 1957 break; 1958 } 1959 settings.update(ANDROID_CONTROL_CAPTURE_INTENT, &controlIntent, 1); 1960 1961 settings.update(ANDROID_CONTROL_AE_EXPOSURE_COMPENSATION, 1962 &gCamCapability[mCameraId]->exposure_compensation_default, 1); 1963 1964 static const uint8_t aeLock = ANDROID_CONTROL_AE_LOCK_OFF; 1965 settings.update(ANDROID_CONTROL_AE_LOCK, &aeLock, 1); 1966 1967 static const uint8_t awbLock = ANDROID_CONTROL_AWB_LOCK_OFF; 1968 settings.update(ANDROID_CONTROL_AWB_LOCK, &awbLock, 1); 1969 1970 static const uint8_t awbMode = ANDROID_CONTROL_AWB_MODE_AUTO; 1971 settings.update(ANDROID_CONTROL_AWB_MODE, &awbMode, 1); 1972 1973 static const uint8_t controlMode = ANDROID_CONTROL_MODE_AUTO; 1974 settings.update(ANDROID_CONTROL_MODE, &controlMode, 1); 1975 1976 static const uint8_t effectMode = ANDROID_CONTROL_EFFECT_MODE_OFF; 1977 settings.update(ANDROID_CONTROL_EFFECT_MODE, &effectMode, 1); 1978 1979 static const uint8_t sceneMode = ANDROID_CONTROL_SCENE_MODE_FACE_PRIORITY; //similar to AUTO? 1980 settings.update(ANDROID_CONTROL_SCENE_MODE, &sceneMode, 1); 1981 1982 /*flash*/ 1983 static const uint8_t flashMode = ANDROID_FLASH_MODE_OFF; 1984 settings.update(ANDROID_FLASH_MODE, &flashMode, 1); 1985 1986 1987 /* lens */ 1988 static const float default_aperture = gCamCapability[mCameraId]->apertures[0]; 1989 settings.update(ANDROID_LENS_APERTURE, &default_aperture, 1); 1990 1991 static const float default_filter_density = gCamCapability[mCameraId]->filter_densities[0]; 1992 settings.update(ANDROID_LENS_FILTER_DENSITY, &default_filter_density, 1); 1993 1994 static const float default_focal_length = gCamCapability[mCameraId]->focal_lengths[0]; 1995 settings.update(ANDROID_LENS_FOCAL_LENGTH, &default_focal_length, 1); 1996 1997 mDefaultMetadata[type] = settings.release(); 1998 1999 pthread_mutex_unlock(&mMutex); 2000 return mDefaultMetadata[type]; 2001} 2002 2003/*=========================================================================== 2004 * FUNCTION : setFrameParameters 2005 * 2006 * DESCRIPTION: set parameters per frame as requested in the metadata from 2007 * framework 2008 * 2009 * PARAMETERS : 2010 * @settings : frame settings information from framework 2011 * 2012 * 2013 * RETURN : success: NO_ERROR 2014 * failure: 2015 *==========================================================================*/ 2016int QCamera3HardwareInterface::setFrameParameters(int frame_id, 2017 const camera_metadata_t *settings) 2018{ 2019 /*translate from camera_metadata_t type to parm_type_t*/ 2020 int rc = 0; 2021 if (settings == NULL && mParameters == NULL) { 2022 /*settings cannot be null for the first request*/ 2023 return BAD_VALUE; 2024 } 2025 /*we need to update the frame number in the parameters*/ 2026 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FRAME_NUMBER, 2027 sizeof(frame_id), &frame_id); 2028 if (rc < 0) { 2029 ALOGE("%s: Failed to set the frame number in the parameters", __func__); 2030 return BAD_VALUE; 2031 } 2032 if(settings != NULL){ 2033 rc = translateMetadataToParameters(settings); 2034 } 2035 /*set the parameters to backend*/ 2036 mCameraHandle->ops->set_parms(mCameraHandle->camera_handle, mParameters); 2037 return rc; 2038} 2039 2040/*=========================================================================== 2041 * FUNCTION : translateMetadataToParameters 2042 * 2043 * DESCRIPTION: read from the camera_metadata_t and change to parm_type_t 2044 * 2045 * 2046 * PARAMETERS : 2047 * @settings : frame settings information from framework 2048 * 2049 * 2050 * RETURN : success: NO_ERROR 2051 * failure: 2052 *==========================================================================*/ 2053int QCamera3HardwareInterface::translateMetadataToParameters 2054 (const camera_metadata_t *settings) 2055{ 2056 int rc = 0; 2057 CameraMetadata frame_settings; 2058 frame_settings = settings; 2059 2060 int32_t antibandingMode = 2061 frame_settings.find(ANDROID_CONTROL_AE_ANTIBANDING_MODE).data.i32[0]; 2062 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_ANTIBANDING, 2063 sizeof(antibandingMode), &antibandingMode); 2064 2065 /*int32_t expCompensation = frame_settings.find().data.i32[0]; 2066 rc = AddSetParmEntryToBatch(mParameters, 2067 CAM_INTF_PARM_EXPOSURE_COMPENSATION, 2068 sizeof(expCompensation), &expCompensation);*/ 2069 2070 int32_t aeLock = frame_settings.find(ANDROID_CONTROL_AE_LOCK).data.i32[0]; 2071 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_AEC_LOCK, 2072 sizeof(aeLock), &aeLock); 2073 2074 int32_t focusMode = 2075 frame_settings.find(ANDROID_CONTROL_AF_MODE).data.i32[0]; 2076 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_FOCUS_MODE, 2077 sizeof(focusMode), &focusMode); 2078 2079 int32_t awbLock = frame_settings.find(ANDROID_CONTROL_AWB_LOCK).data.i32[0]; 2080 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_AWB_LOCK, 2081 sizeof(awbLock), &awbLock); 2082 2083 int32_t fwk_whiteLevel = 2084 frame_settings.find(ANDROID_CONTROL_AWB_MODE).data.i32[0]; 2085 int whiteLevel = lookupHalName(WHITE_BALANCE_MODES_MAP, 2086 sizeof(WHITE_BALANCE_MODES_MAP)/ sizeof(int32_t), 2087 fwk_whiteLevel); 2088 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_WHITE_BALANCE, 2089 sizeof(whiteLevel), &whiteLevel); 2090 2091 int32_t fwk_effectMode = 2092 frame_settings.find(ANDROID_CONTROL_EFFECT_MODE).data.i32[0]; 2093 int effectMode = lookupHalName(EFFECT_MODES_MAP, 2094 sizeof(EFFECT_MODES_MAP)/ sizeof(int32_t), 2095 fwk_effectMode); 2096 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_PARM_EFFECT, 2097 sizeof(effectMode), &effectMode); 2098 int32_t fwk_aeMode = 2099 frame_settings.find(ANDROID_CONTROL_AE_MODE).data.i32[0]; 2100 int aeMode = lookupHalName(AUTO_EXPOSURE_MAP, 2101 sizeof(AUTO_EXPOSURE_MAP)/ sizeof(int32_t), 2102 fwk_aeMode); 2103 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AEC_MODE, 2104 sizeof(aeMode), &aeMode); 2105 2106 int32_t metaFrameNumber = 2107 frame_settings.find(ANDROID_REQUEST_FRAME_COUNT).data.i32[0]; 2108 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FRAME_NUMBER, 2109 sizeof(metaFrameNumber), &metaFrameNumber); 2110 2111 int32_t colorCorrectMode = 2112 frame_settings.find(ANDROID_COLOR_CORRECTION_MODE).data.i32[0]; 2113 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_COLOR_CORRECT_MODE, 2114 sizeof(colorCorrectMode), &colorCorrectMode); 2115 2116 int32_t aecTrigger = 2117 frame_settings.find(ANDROID_CONTROL_AE_PRECAPTURE_TRIGGER).data.i32[0]; 2118 rc = AddSetParmEntryToBatch(mParameters, 2119 CAM_INTF_META_AEC_PRECAPTURE_TRIGGER, 2120 sizeof(aecTrigger), &aecTrigger); 2121 2122 int32_t afTrigger = 2123 frame_settings.find(ANDROID_CONTROL_AF_TRIGGER).data.i32[0]; 2124 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_AF_TRIGGER, 2125 sizeof(afTrigger), &afTrigger); 2126 2127 2128 int32_t metaMode = frame_settings.find(ANDROID_CONTROL_MODE).data.i32[0]; 2129 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_MODE, 2130 sizeof(metaMode), &metaMode); 2131 2132 2133 int32_t demosaic = frame_settings.find(ANDROID_DEMOSAIC_MODE).data.u8[0]; 2134 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_DEMOSAIC, 2135 sizeof(demosaic), &demosaic); 2136 2137 int32_t edgeMode = frame_settings.find(ANDROID_EDGE_MODE).data.u8[0]; 2138 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_EDGE, 2139 sizeof(edgeMode), &edgeMode); 2140 2141 2142 int32_t edgeStrength = 2143 frame_settings.find(ANDROID_EDGE_STRENGTH).data.i32[0]; 2144 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHARPNESS_STRENGTH, 2145 sizeof(edgeStrength), &edgeStrength); 2146 2147 int32_t flashPower = 2148 frame_settings.find(ANDROID_FLASH_FIRING_POWER).data.u8[0]; 2149 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FLASH_POWER, 2150 sizeof(flashPower), &flashPower); 2151 2152 int64_t flashFiringTime = 2153 frame_settings.find(ANDROID_FLASH_FIRING_TIME).data.i64[0]; 2154 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_FLASH_FIRING_TIME, 2155 sizeof(flashFiringTime), &flashFiringTime); 2156 2157 int32_t geometricMode = 2158 frame_settings.find(ANDROID_GEOMETRIC_MODE).data.u8[0]; 2159 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_GEOMETRIC_MODE, 2160 sizeof(geometricMode), &geometricMode); 2161 2162 int32_t geometricStrength = 2163 frame_settings.find(ANDROID_GEOMETRIC_STRENGTH).data.u8[0]; 2164 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_GEOMETRIC_STRENGTH, 2165 sizeof(geometricStrength), &geometricStrength); 2166 2167 int32_t hotPixelMode = 2168 frame_settings.find(ANDROID_HOT_PIXEL_MODE).data.u8[0]; 2169 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_HOTPIXEL_MODE, 2170 sizeof(hotPixelMode), &hotPixelMode); 2171 2172 2173 float lensAperture = 2174 frame_settings.find( ANDROID_LENS_APERTURE).data.f[0]; 2175 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_APERTURE, 2176 sizeof(lensAperture), &lensAperture); 2177 2178 2179 float filterDensity = 2180 frame_settings.find(ANDROID_LENS_FILTER_DENSITY).data.f[0]; 2181 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_FILTERDENSITY, 2182 sizeof(filterDensity), &filterDensity); 2183 2184 2185 float focalLength = 2186 frame_settings.find(ANDROID_LENS_FOCAL_LENGTH).data.f[0]; 2187 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_FOCAL_LENGTH, 2188 sizeof(focalLength), &focalLength); 2189 2190 float focalDistance = 2191 frame_settings.find(ANDROID_LENS_FOCUS_DISTANCE).data.f[0]; 2192 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_FOCUS_DISTANCE, 2193 sizeof(focalDistance), &focalDistance); 2194 2195 int32_t optStabMode = 2196 frame_settings.find(ANDROID_LENS_OPTICAL_STABILIZATION_MODE).data.u8[0]; 2197 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_LENS_OPT_STAB_MODE, 2198 sizeof(optStabMode), &optStabMode); 2199 2200 int32_t noiseRedMode = 2201 frame_settings.find(ANDROID_NOISE_REDUCTION_MODE).data.u8[0]; 2202 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_NOISE_REDUCTION_MODE, 2203 sizeof(noiseRedMode), &noiseRedMode); 2204 2205 int32_t noiseRedStrength = 2206 frame_settings.find(ANDROID_NOISE_REDUCTION_STRENGTH).data.u8[0]; 2207 rc = AddSetParmEntryToBatch(mParameters, 2208 CAM_INTF_META_NOISE_REDUCTION_STRENGTH, 2209 sizeof(noiseRedStrength), &noiseRedStrength); 2210 2211 cam_crop_region_t scalerCropRegion; 2212 scalerCropRegion.left = 2213 frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[0]; 2214 scalerCropRegion.top = 2215 frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[1]; 2216 scalerCropRegion.width = 2217 frame_settings.find(ANDROID_SCALER_CROP_REGION).data.i32[2]; 2218 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SCALER_CROP_REGION, 2219 sizeof(scalerCropRegion), &scalerCropRegion); 2220 2221 int64_t sensorExpTime = 2222 frame_settings.find(ANDROID_SENSOR_EXPOSURE_TIME).data.i64[0]; 2223 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SENSOR_EXPOSURE_TIME, 2224 sizeof(sensorExpTime), &sensorExpTime); 2225 2226 int64_t sensorFrameDuration = 2227 frame_settings.find(ANDROID_SENSOR_FRAME_DURATION).data.i64[0]; 2228 rc = AddSetParmEntryToBatch(mParameters, 2229 CAM_INTF_META_SENSOR_FRAME_DURATION, 2230 sizeof(sensorFrameDuration), &sensorFrameDuration); 2231 2232 int32_t sensorSensitivity = 2233 frame_settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0]; 2234 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SENSOR_SENSITIVITY, 2235 sizeof(sensorSensitivity), &sensorSensitivity); 2236 2237 int32_t shadingMode = frame_settings.find(ANDROID_SHADING_MODE).data.u8[0]; 2238 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHADING_MODE, 2239 sizeof(shadingMode), &shadingMode); 2240 2241 int32_t shadingStrength = 2242 frame_settings.find(ANDROID_SHADING_STRENGTH).data.u8[0]; 2243 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_SHADING_STRENGTH, 2244 sizeof(shadingStrength), &shadingStrength); 2245 2246 int32_t facedetectMode = 2247 frame_settings.find(ANDROID_STATISTICS_FACE_DETECT_MODE).data.u8[0]; 2248 rc = AddSetParmEntryToBatch(mParameters, 2249 CAM_INTF_META_STATS_FACEDETECT_MODE, 2250 sizeof(facedetectMode), &facedetectMode); 2251 2252 int32_t histogramMode = 2253 frame_settings.find(ANDROID_STATISTICS_HISTOGRAM_MODE).data.u8[0]; 2254 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_STATS_HISTOGRAM_MODE, 2255 sizeof(histogramMode), &histogramMode); 2256 2257 int32_t sharpnessMapMode = 2258 frame_settings.find(ANDROID_STATISTICS_SHARPNESS_MAP_MODE).data.u8[0]; 2259 rc = AddSetParmEntryToBatch(mParameters, 2260 CAM_INTF_META_STATS_SHARPNESS_MAP_MODE, 2261 sizeof(sharpnessMapMode), &sharpnessMapMode); 2262 2263 int32_t tonemapMode = frame_settings.find(ANDROID_TONEMAP_MODE).data.u8[0]; 2264 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_TONEMAP_MODE, 2265 sizeof(tonemapMode), &tonemapMode); 2266 2267 int32_t captureIntent = 2268 frame_settings.find(ANDROID_CONTROL_CAPTURE_INTENT).data.i32[0]; 2269 rc = AddSetParmEntryToBatch(mParameters, CAM_INTF_META_CAPTURE_INTENT, 2270 sizeof(captureIntent), &captureIntent); 2271 2272 return rc; 2273} 2274 2275/*=========================================================================== 2276 * FUNCTION : translateMetadataToParameters 2277 * 2278 * DESCRIPTION: read from the camera_metadata_t and change to parm_type_t 2279 * 2280 * 2281 * PARAMETERS : 2282 * @settings : frame settings information from framework 2283 * 2284 * 2285 * RETURN : success: NO_ERROR 2286 * failure: 2287 *==========================================================================*/ 2288int QCamera3HardwareInterface::getJpegSettings 2289 (const camera_metadata_t *settings) 2290{ 2291 if (mJpegSettings) { 2292 free(mJpegSettings); 2293 mJpegSettings = NULL; 2294 } 2295 mJpegSettings = (jpeg_settings_t*) malloc(sizeof(jpeg_settings_t)); 2296 CameraMetadata jpeg_settings; 2297 jpeg_settings = settings; 2298 2299 mJpegSettings->jpeg_orientation = 2300 jpeg_settings.find(ANDROID_JPEG_ORIENTATION).data.i32[0]; 2301 mJpegSettings->jpeg_quality = 2302 jpeg_settings.find(ANDROID_JPEG_QUALITY).data.u8[0]; 2303 mJpegSettings->thumbnail_size.height = 2304 jpeg_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[0]; 2305 mJpegSettings->thumbnail_size.height = 2306 jpeg_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.i32[1]; 2307 for (int i = 0; i < 3; i++) { 2308 mJpegSettings->gps_coordinates[i] = 2309 jpeg_settings.find(ANDROID_JPEG_THUMBNAIL_SIZE).data.d[i]; 2310 } 2311 mJpegSettings->gps_timestamp = 2312 jpeg_settings.find(ANDROID_JPEG_GPS_TIMESTAMP).data.i64[0]; 2313 mJpegSettings->gps_processing_method = 2314 jpeg_settings.find(ANDROID_JPEG_GPS_PROCESSING_METHOD).data.u8[0]; 2315 mJpegSettings->sensor_sensitivity = 2316 jpeg_settings.find(ANDROID_SENSOR_SENSITIVITY).data.i32[0]; 2317 mJpegSettings->lens_focal_length = 2318 jpeg_settings.find(ANDROID_LENS_FOCAL_LENGTH).data.f[0]; 2319 return 0; 2320} 2321 2322/*=========================================================================== 2323 * FUNCTION : captureResultCb 2324 * 2325 * DESCRIPTION: Callback handler for all channels (streams, as well as metadata) 2326 * 2327 * PARAMETERS : 2328 * @frame : frame information from mm-camera-interface 2329 * @buffer : actual gralloc buffer to be returned to frameworks. NULL if metadata. 2330 * @userdata: userdata 2331 * 2332 * RETURN : NONE 2333 *==========================================================================*/ 2334void QCamera3HardwareInterface::captureResultCb(metadata_buffer_t *metadata, 2335 camera3_stream_buffer_t *buffer, 2336 uint32_t frame_number, void *userdata) 2337{ 2338 QCamera3HardwareInterface *hw = (QCamera3HardwareInterface *)userdata; 2339 if (hw == NULL) { 2340 ALOGE("%s: Invalid hw %p", __func__, hw); 2341 return; 2342 } 2343 2344 hw->captureResultCb(metadata, buffer, frame_number); 2345 return; 2346} 2347 2348/*=========================================================================== 2349 * FUNCTION : initialize 2350 * 2351 * DESCRIPTION: Pass framework callback pointers to HAL 2352 * 2353 * PARAMETERS : 2354 * 2355 * 2356 * RETURN : Success : 0 2357 * Failure: -ENODEV 2358 *==========================================================================*/ 2359 2360int QCamera3HardwareInterface::initialize(const struct camera3_device *device, 2361 const camera3_callback_ops_t *callback_ops) 2362{ 2363 QCamera3HardwareInterface *hw = 2364 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 2365 if (!hw) { 2366 ALOGE("%s: NULL camera device", __func__); 2367 return -ENODEV; 2368 } 2369 2370 return hw->initialize(callback_ops); 2371} 2372 2373/*=========================================================================== 2374 * FUNCTION : configure_streams 2375 * 2376 * DESCRIPTION: 2377 * 2378 * PARAMETERS : 2379 * 2380 * 2381 * RETURN : Success: 0 2382 * Failure: -EINVAL (if stream configuration is invalid) 2383 * -ENODEV (fatal error) 2384 *==========================================================================*/ 2385 2386int QCamera3HardwareInterface::configure_streams( 2387 const struct camera3_device *device, 2388 camera3_stream_configuration_t *stream_list) 2389{ 2390 QCamera3HardwareInterface *hw = 2391 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 2392 if (!hw) { 2393 ALOGE("%s: NULL camera device", __func__); 2394 return -ENODEV; 2395 } 2396 return hw->configureStreams(stream_list); 2397} 2398 2399/*=========================================================================== 2400 * FUNCTION : register_stream_buffers 2401 * 2402 * DESCRIPTION: Register stream buffers with the device 2403 * 2404 * PARAMETERS : 2405 * 2406 * RETURN : 2407 *==========================================================================*/ 2408int QCamera3HardwareInterface::register_stream_buffers( 2409 const struct camera3_device *device, 2410 const camera3_stream_buffer_set_t *buffer_set) 2411{ 2412 QCamera3HardwareInterface *hw = 2413 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 2414 if (!hw) { 2415 ALOGE("%s: NULL camera device", __func__); 2416 return -ENODEV; 2417 } 2418 return hw->registerStreamBuffers(buffer_set); 2419} 2420 2421/*=========================================================================== 2422 * FUNCTION : construct_default_request_settings 2423 * 2424 * DESCRIPTION: Configure a settings buffer to meet the required use case 2425 * 2426 * PARAMETERS : 2427 * 2428 * 2429 * RETURN : Success: Return valid metadata 2430 * Failure: Return NULL 2431 *==========================================================================*/ 2432const camera_metadata_t* QCamera3HardwareInterface:: 2433 construct_default_request_settings(const struct camera3_device *device, 2434 int type) 2435{ 2436 2437 camera_metadata_t* fwk_metadata = NULL; 2438 QCamera3HardwareInterface *hw = 2439 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 2440 if (!hw) { 2441 ALOGE("%s: NULL camera device", __func__); 2442 return NULL; 2443 } 2444 2445 fwk_metadata = hw->translateCapabilityToMetadata(type); 2446 2447 return fwk_metadata; 2448} 2449 2450/*=========================================================================== 2451 * FUNCTION : process_capture_request 2452 * 2453 * DESCRIPTION: 2454 * 2455 * PARAMETERS : 2456 * 2457 * 2458 * RETURN : 2459 *==========================================================================*/ 2460int QCamera3HardwareInterface::process_capture_request( 2461 const struct camera3_device *device, 2462 camera3_capture_request_t *request) 2463{ 2464 QCamera3HardwareInterface *hw = 2465 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 2466 if (!hw) { 2467 ALOGE("%s: NULL camera device", __func__); 2468 return -EINVAL; 2469 } 2470 2471 return hw->processCaptureRequest(request); 2472} 2473 2474/*=========================================================================== 2475 * FUNCTION : get_metadata_vendor_tag_ops 2476 * 2477 * DESCRIPTION: 2478 * 2479 * PARAMETERS : 2480 * 2481 * 2482 * RETURN : 2483 *==========================================================================*/ 2484 2485void QCamera3HardwareInterface::get_metadata_vendor_tag_ops( 2486 const struct camera3_device *device, 2487 vendor_tag_query_ops_t* ops) 2488{ 2489 QCamera3HardwareInterface *hw = 2490 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 2491 if (!hw) { 2492 ALOGE("%s: NULL camera device", __func__); 2493 return; 2494 } 2495 2496 hw->getMetadataVendorTagOps(ops); 2497 return; 2498} 2499 2500/*=========================================================================== 2501 * FUNCTION : dump 2502 * 2503 * DESCRIPTION: 2504 * 2505 * PARAMETERS : 2506 * 2507 * 2508 * RETURN : 2509 *==========================================================================*/ 2510 2511void QCamera3HardwareInterface::dump( 2512 const struct camera3_device *device, int fd) 2513{ 2514 QCamera3HardwareInterface *hw = 2515 reinterpret_cast<QCamera3HardwareInterface *>(device->priv); 2516 if (!hw) { 2517 ALOGE("%s: NULL camera device", __func__); 2518 return; 2519 } 2520 2521 hw->dump(fd); 2522 return; 2523} 2524 2525/*=========================================================================== 2526 * FUNCTION : close_camera_device 2527 * 2528 * DESCRIPTION: 2529 * 2530 * PARAMETERS : 2531 * 2532 * 2533 * RETURN : 2534 *==========================================================================*/ 2535int QCamera3HardwareInterface::close_camera_device(struct hw_device_t* device) 2536{ 2537 int ret = NO_ERROR; 2538 QCamera3HardwareInterface *hw = 2539 reinterpret_cast<QCamera3HardwareInterface *>( 2540 reinterpret_cast<camera3_device_t *>(device)->priv); 2541 if (!hw) { 2542 ALOGE("NULL camera device"); 2543 return BAD_VALUE; 2544 } 2545 delete hw; 2546 return ret; 2547} 2548 2549}; //end namespace qcamera 2550