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