1 /* Copyright (c) 2015-2016, The Linux Foundation. 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 "QCameraParametersIntf" 31 32 // System dependencies 33 #include <utils/Mutex.h> 34 35 // Camera dependencies 36 #include "QCameraParameters.h" 37 #include "QCameraParametersIntf.h" 38 #include "QCameraTrace.h" 39 40 extern "C" { 41 #include "mm_camera_dbg.h" 42 } 43 44 namespace qcamera { 45 46 #define CHECK_PARAM_INTF(impl) LOG_ALWAYS_FATAL_IF(((impl) == NULL), "impl is NULL!") 47 48 QCameraParametersIntf::QCameraParametersIntf() : 49 mImpl(NULL) 50 { 51 } 52 53 QCameraParametersIntf::~QCameraParametersIntf() 54 { 55 { 56 Mutex::Autolock lock(mLock); 57 if (mImpl) { 58 delete mImpl; 59 mImpl = NULL; 60 } 61 } 62 } 63 64 65 int32_t QCameraParametersIntf::allocate() 66 { 67 Mutex::Autolock lock(mLock); 68 mImpl = new QCameraParameters(); 69 if (!mImpl) { 70 LOGE("Out of memory"); 71 return NO_MEMORY; 72 } 73 74 return mImpl->allocate(); 75 } 76 77 int32_t QCameraParametersIntf::init(cam_capability_t *capabilities, 78 mm_camera_vtbl_t *mmOps, 79 QCameraAdjustFPS *adjustFPS) 80 { 81 Mutex::Autolock lock(mLock); 82 CHECK_PARAM_INTF(mImpl); 83 return mImpl->init(capabilities, mmOps, adjustFPS); 84 } 85 86 void QCameraParametersIntf::deinit() 87 { 88 Mutex::Autolock lock(mLock); 89 CHECK_PARAM_INTF(mImpl); 90 mImpl->deinit(); 91 } 92 93 int32_t QCameraParametersIntf::updateParameters(const String8& params, bool &needRestart) 94 { 95 Mutex::Autolock lock(mLock); 96 CHECK_PARAM_INTF(mImpl); 97 return mImpl->updateParameters(params, needRestart); 98 } 99 100 int32_t QCameraParametersIntf::commitParameters() 101 { 102 Mutex::Autolock lock(mLock); 103 CHECK_PARAM_INTF(mImpl); 104 return mImpl->commitParameters(); 105 } 106 107 char* QCameraParametersIntf::QCameraParametersIntf::getParameters() 108 { 109 Mutex::Autolock lock(mLock); 110 CHECK_PARAM_INTF(mImpl); 111 return mImpl->getParameters(); 112 } 113 114 void QCameraParametersIntf::getPreviewFpsRange(int *min_fps, int *max_fps) const 115 { 116 Mutex::Autolock lock(mLock); 117 CHECK_PARAM_INTF(mImpl); 118 mImpl->getPreviewFpsRange(min_fps, max_fps); 119 } 120 121 #ifdef TARGET_TS_MAKEUP 122 bool QCameraParametersIntf::getTsMakeupInfo(int &whiteLevel, int &cleanLevel) const 123 { 124 Mutex::Autolock lock(mLock); 125 CHECK_PARAM_INTF(mImpl); 126 return mImpl->getTsMakeupInfo(whiteLevel, cleanLevel); 127 } 128 #endif 129 130 int QCameraParametersIntf::getPreviewHalPixelFormat() 131 { 132 Mutex::Autolock lock(mLock); 133 CHECK_PARAM_INTF(mImpl); 134 return mImpl->getPreviewHalPixelFormat(); 135 } 136 137 int32_t QCameraParametersIntf::getStreamRotation(cam_stream_type_t streamType, 138 cam_pp_feature_config_t &featureConfig, 139 cam_dimension_t &dim) 140 { 141 Mutex::Autolock lock(mLock); 142 CHECK_PARAM_INTF(mImpl); 143 return mImpl->getStreamRotation(streamType, featureConfig, dim); 144 145 } 146 147 int32_t QCameraParametersIntf::getStreamFormat(cam_stream_type_t streamType, 148 cam_format_t &format) 149 { 150 Mutex::Autolock lock(mLock); 151 CHECK_PARAM_INTF(mImpl); 152 return mImpl->getStreamFormat(streamType, format); 153 } 154 155 int32_t QCameraParametersIntf::getStreamDimension(cam_stream_type_t streamType, 156 cam_dimension_t &dim) 157 { 158 Mutex::Autolock lock(mLock); 159 CHECK_PARAM_INTF(mImpl); 160 return mImpl->getStreamDimension(streamType, dim); 161 } 162 163 void QCameraParametersIntf::getThumbnailSize(int *width, int *height) const 164 { 165 Mutex::Autolock lock(mLock); 166 CHECK_PARAM_INTF(mImpl); 167 mImpl->getThumbnailSize(width, height); 168 } 169 170 uint8_t QCameraParametersIntf::getZSLBurstInterval() 171 { 172 Mutex::Autolock lock(mLock); 173 CHECK_PARAM_INTF(mImpl); 174 return mImpl->getZSLBurstInterval(); 175 } 176 177 uint8_t QCameraParametersIntf::getZSLQueueDepth() 178 { 179 Mutex::Autolock lock(mLock); 180 CHECK_PARAM_INTF(mImpl); 181 return mImpl->getZSLQueueDepth(); 182 } 183 184 uint8_t QCameraParametersIntf::getZSLBackLookCount() 185 { 186 Mutex::Autolock lock(mLock); 187 CHECK_PARAM_INTF(mImpl); 188 return mImpl->getZSLBackLookCount(); 189 } 190 191 uint8_t QCameraParametersIntf::getMaxUnmatchedFramesInQueue() 192 { 193 Mutex::Autolock lock(mLock); 194 CHECK_PARAM_INTF(mImpl); 195 return mImpl->getMaxUnmatchedFramesInQueue(); 196 } 197 198 bool QCameraParametersIntf::isZSLMode() 199 { 200 Mutex::Autolock lock(mLock); 201 CHECK_PARAM_INTF(mImpl); 202 return mImpl->isZSLMode(); 203 } 204 205 bool QCameraParametersIntf::isRdiMode() 206 { 207 Mutex::Autolock lock(mLock); 208 CHECK_PARAM_INTF(mImpl); 209 return mImpl->isRdiMode(); 210 } 211 212 bool QCameraParametersIntf::isSecureMode() 213 { 214 Mutex::Autolock lock(mLock); 215 CHECK_PARAM_INTF(mImpl); 216 return mImpl->isSecureMode(); 217 } 218 219 bool QCameraParametersIntf::isNoDisplayMode() 220 { 221 Mutex::Autolock lock(mLock); 222 CHECK_PARAM_INTF(mImpl); 223 return mImpl->isNoDisplayMode(); 224 } 225 226 bool QCameraParametersIntf::isWNREnabled() 227 { 228 Mutex::Autolock lock(mLock); 229 CHECK_PARAM_INTF(mImpl); 230 return mImpl->isWNREnabled(); 231 } 232 233 bool QCameraParametersIntf::isTNRSnapshotEnabled() 234 { 235 Mutex::Autolock lock(mLock); 236 CHECK_PARAM_INTF(mImpl); 237 return mImpl->isTNRSnapshotEnabled(); 238 } 239 240 int32_t QCameraParametersIntf::getCDSMode() 241 { 242 Mutex::Autolock lock(mLock); 243 CHECK_PARAM_INTF(mImpl); 244 return mImpl->getCDSMode(); 245 } 246 247 bool QCameraParametersIntf::isLTMForSeeMoreEnabled() 248 { 249 Mutex::Autolock lock(mLock); 250 CHECK_PARAM_INTF(mImpl); 251 return mImpl->isLTMForSeeMoreEnabled(); 252 } 253 254 bool QCameraParametersIntf::isHfrMode() 255 { 256 Mutex::Autolock lock(mLock); 257 CHECK_PARAM_INTF(mImpl); 258 return mImpl->isHfrMode(); 259 } 260 261 void QCameraParametersIntf::getHfrFps(cam_fps_range_t &pFpsRange) 262 { 263 Mutex::Autolock lock(mLock); 264 CHECK_PARAM_INTF(mImpl); 265 mImpl->getHfrFps(pFpsRange); 266 } 267 268 uint8_t QCameraParametersIntf::getNumOfSnapshots() 269 { 270 Mutex::Autolock lock(mLock); 271 CHECK_PARAM_INTF(mImpl); 272 return mImpl->getNumOfSnapshots(); 273 } 274 275 uint8_t QCameraParametersIntf::getNumOfRetroSnapshots() 276 { 277 Mutex::Autolock lock(mLock); 278 CHECK_PARAM_INTF(mImpl); 279 return mImpl->getNumOfRetroSnapshots(); 280 } 281 282 uint8_t QCameraParametersIntf::getNumOfExtraHDRInBufsIfNeeded() 283 { 284 Mutex::Autolock lock(mLock); 285 CHECK_PARAM_INTF(mImpl); 286 return mImpl->getNumOfExtraHDRInBufsIfNeeded(); 287 } 288 289 uint8_t QCameraParametersIntf::getNumOfExtraHDROutBufsIfNeeded() 290 { 291 Mutex::Autolock lock(mLock); 292 CHECK_PARAM_INTF(mImpl); 293 return mImpl->getNumOfExtraHDROutBufsIfNeeded(); 294 } 295 296 bool QCameraParametersIntf::getRecordingHintValue() 297 { 298 Mutex::Autolock lock(mLock); 299 CHECK_PARAM_INTF(mImpl); 300 return mImpl->getRecordingHintValue(); 301 } 302 303 uint32_t QCameraParametersIntf::getJpegQuality() 304 { 305 Mutex::Autolock lock(mLock); 306 CHECK_PARAM_INTF(mImpl); 307 return mImpl->getJpegQuality(); 308 } 309 310 uint32_t QCameraParametersIntf::getRotation() 311 { 312 Mutex::Autolock lock(mLock); 313 CHECK_PARAM_INTF(mImpl); 314 return mImpl->getRotation(); 315 } 316 317 uint32_t QCameraParametersIntf::getDeviceRotation() 318 { 319 Mutex::Autolock lock(mLock); 320 CHECK_PARAM_INTF(mImpl); 321 return mImpl->getDeviceRotation(); 322 } 323 324 uint32_t QCameraParametersIntf::getJpegExifRotation() 325 { 326 Mutex::Autolock lock(mLock); 327 CHECK_PARAM_INTF(mImpl); 328 return mImpl->getJpegExifRotation(); 329 } 330 331 bool QCameraParametersIntf::useJpegExifRotation() 332 { 333 Mutex::Autolock lock(mLock); 334 CHECK_PARAM_INTF(mImpl); 335 return mImpl->useJpegExifRotation(); 336 } 337 338 int32_t QCameraParametersIntf::getEffectValue() 339 { 340 Mutex::Autolock lock(mLock); 341 CHECK_PARAM_INTF(mImpl); 342 return mImpl->getEffectValue(); 343 } 344 345 bool QCameraParametersIntf::isInstantAECEnabled() 346 { 347 Mutex::Autolock lock(mLock); 348 CHECK_PARAM_INTF(mImpl); 349 return mImpl->isInstantAECEnabled(); 350 } 351 352 bool QCameraParametersIntf::isInstantCaptureEnabled() 353 { 354 Mutex::Autolock lock(mLock); 355 CHECK_PARAM_INTF(mImpl); 356 return mImpl->isInstantCaptureEnabled(); 357 } 358 359 uint8_t QCameraParametersIntf::getAecFrameBoundValue() 360 { 361 Mutex::Autolock lock(mLock); 362 CHECK_PARAM_INTF(mImpl); 363 return mImpl->getAecFrameBoundValue(); 364 } 365 366 uint8_t QCameraParametersIntf::getAecSkipDisplayFrameBound() 367 { 368 Mutex::Autolock lock(mLock); 369 CHECK_PARAM_INTF(mImpl); 370 return mImpl->getAecSkipDisplayFrameBound(); 371 } 372 373 int32_t QCameraParametersIntf::getExifDateTime( 374 String8 &dateTime, String8 &subsecTime) 375 { 376 Mutex::Autolock lock(mLock); 377 CHECK_PARAM_INTF(mImpl); 378 return mImpl->getExifDateTime(dateTime, subsecTime); 379 } 380 381 int32_t QCameraParametersIntf::getExifFocalLength(rat_t *focalLength) 382 { 383 Mutex::Autolock lock(mLock); 384 CHECK_PARAM_INTF(mImpl); 385 return mImpl->getExifFocalLength(focalLength); 386 } 387 388 uint16_t QCameraParametersIntf::getExifIsoSpeed() 389 { 390 Mutex::Autolock lock(mLock); 391 CHECK_PARAM_INTF(mImpl); 392 return mImpl->getExifIsoSpeed(); 393 } 394 395 int32_t QCameraParametersIntf::getExifGpsProcessingMethod(char *gpsProcessingMethod, uint32_t &count) 396 { 397 Mutex::Autolock lock(mLock); 398 CHECK_PARAM_INTF(mImpl); 399 return mImpl->getExifGpsProcessingMethod(gpsProcessingMethod, count); 400 } 401 402 int32_t QCameraParametersIntf::getExifLatitude(rat_t *latitude, char *latRef) 403 { 404 Mutex::Autolock lock(mLock); 405 CHECK_PARAM_INTF(mImpl); 406 return mImpl->getExifLatitude(latitude, latRef); 407 } 408 409 int32_t QCameraParametersIntf::getExifLongitude(rat_t *longitude, char *lonRef) 410 { 411 Mutex::Autolock lock(mLock); 412 CHECK_PARAM_INTF(mImpl); 413 return mImpl->getExifLongitude(longitude, lonRef); 414 } 415 416 int32_t QCameraParametersIntf::getExifAltitude(rat_t *altitude, char *altRef) 417 { 418 Mutex::Autolock lock(mLock); 419 CHECK_PARAM_INTF(mImpl); 420 return mImpl->getExifAltitude(altitude, altRef); 421 } 422 423 int32_t QCameraParametersIntf::getExifGpsDateTimeStamp(char *gpsDateStamp, uint32_t bufLen, rat_t *gpsTimeStamp) 424 { 425 Mutex::Autolock lock(mLock); 426 CHECK_PARAM_INTF(mImpl); 427 return mImpl->getExifGpsDateTimeStamp(gpsDateStamp, bufLen, gpsTimeStamp); 428 } 429 430 bool QCameraParametersIntf::isVideoBuffersCached() 431 { 432 Mutex::Autolock lock(mLock); 433 CHECK_PARAM_INTF(mImpl); 434 return mImpl->isVideoBuffersCached(); 435 } 436 437 int32_t QCameraParametersIntf::updateFocusDistances(cam_focus_distances_info_t *focusDistances) 438 { 439 Mutex::Autolock lock(mLock); 440 CHECK_PARAM_INTF(mImpl); 441 return mImpl->updateFocusDistances(focusDistances); 442 } 443 444 bool QCameraParametersIntf::isAEBracketEnabled() 445 { 446 Mutex::Autolock lock(mLock); 447 CHECK_PARAM_INTF(mImpl); 448 return mImpl->isAEBracketEnabled(); 449 } 450 451 int32_t QCameraParametersIntf::setAEBracketing() 452 { 453 Mutex::Autolock lock(mLock); 454 CHECK_PARAM_INTF(mImpl); 455 return mImpl->setAEBracketing(); 456 } 457 458 bool QCameraParametersIntf::isFpsDebugEnabled() 459 { 460 Mutex::Autolock lock(mLock); 461 CHECK_PARAM_INTF(mImpl); 462 return mImpl->isFpsDebugEnabled(); 463 } 464 465 bool QCameraParametersIntf::isHistogramEnabled() 466 { 467 Mutex::Autolock lock(mLock); 468 CHECK_PARAM_INTF(mImpl); 469 return mImpl->isHistogramEnabled(); 470 } 471 472 bool QCameraParametersIntf::isSceneSelectionEnabled() 473 { 474 Mutex::Autolock lock(mLock); 475 CHECK_PARAM_INTF(mImpl); 476 return mImpl->isSceneSelectionEnabled(); 477 } 478 479 int32_t QCameraParametersIntf::setSelectedScene(cam_scene_mode_type scene) 480 { 481 Mutex::Autolock lock(mLock); 482 CHECK_PARAM_INTF(mImpl); 483 return mImpl->setSelectedScene(scene); 484 } 485 486 cam_scene_mode_type QCameraParametersIntf::getSelectedScene() 487 { 488 Mutex::Autolock lock(mLock); 489 CHECK_PARAM_INTF(mImpl); 490 return mImpl->getSelectedScene(); 491 } 492 493 bool QCameraParametersIntf::isFaceDetectionEnabled() 494 { 495 Mutex::Autolock lock(mLock); 496 CHECK_PARAM_INTF(mImpl); 497 return mImpl->isFaceDetectionEnabled(); 498 } 499 500 int32_t QCameraParametersIntf::setFaceDetectionOption(bool enabled) 501 { 502 Mutex::Autolock lock(mLock); 503 CHECK_PARAM_INTF(mImpl); 504 return mImpl->setFaceDetectionOption(enabled); 505 } 506 507 int32_t QCameraParametersIntf::setHistogram(bool enabled) 508 { 509 Mutex::Autolock lock(mLock); 510 CHECK_PARAM_INTF(mImpl); 511 return mImpl->setHistogram(enabled); 512 } 513 514 int32_t QCameraParametersIntf::setFaceDetection(bool enabled, bool initCommit) 515 { 516 Mutex::Autolock lock(mLock); 517 CHECK_PARAM_INTF(mImpl); 518 return mImpl->setFaceDetection(enabled, initCommit); 519 } 520 521 int32_t QCameraParametersIntf::setFrameSkip(enum msm_vfe_frame_skip_pattern pattern) 522 { 523 Mutex::Autolock lock(mLock); 524 CHECK_PARAM_INTF(mImpl); 525 return mImpl->setFrameSkip(pattern); 526 } 527 528 qcamera_thermal_mode QCameraParametersIntf::getThermalMode() 529 { 530 Mutex::Autolock lock(mLock); 531 CHECK_PARAM_INTF(mImpl); 532 return mImpl->getThermalMode(); 533 } 534 535 int32_t QCameraParametersIntf::updateRecordingHintValue(int32_t value) 536 { 537 Mutex::Autolock lock(mLock); 538 CHECK_PARAM_INTF(mImpl); 539 return mImpl->updateRecordingHintValue(value); 540 } 541 542 int32_t QCameraParametersIntf::setHDRAEBracket(cam_exp_bracketing_t hdrBracket) 543 { 544 Mutex::Autolock lock(mLock); 545 CHECK_PARAM_INTF(mImpl); 546 return mImpl->setHDRAEBracket(hdrBracket); 547 } 548 549 bool QCameraParametersIntf::isHDREnabled() 550 { 551 Mutex::Autolock lock(mLock); 552 CHECK_PARAM_INTF(mImpl); 553 return mImpl->isHDREnabled(); 554 } 555 556 bool QCameraParametersIntf::isAutoHDREnabled() 557 { 558 Mutex::Autolock lock(mLock); 559 CHECK_PARAM_INTF(mImpl); 560 return mImpl->isAutoHDREnabled(); 561 } 562 563 int32_t QCameraParametersIntf::stopAEBracket() 564 { 565 Mutex::Autolock lock(mLock); 566 CHECK_PARAM_INTF(mImpl); 567 return mImpl->stopAEBracket(); 568 } 569 570 int32_t QCameraParametersIntf::updateRAW(cam_dimension_t max_dim) 571 { 572 Mutex::Autolock lock(mLock); 573 CHECK_PARAM_INTF(mImpl); 574 return mImpl->updateRAW(max_dim); 575 } 576 577 bool QCameraParametersIntf::isDISEnabled() 578 { 579 Mutex::Autolock lock(mLock); 580 CHECK_PARAM_INTF(mImpl); 581 return mImpl->isDISEnabled(); 582 } 583 584 cam_is_type_t QCameraParametersIntf::getISType() 585 { 586 Mutex::Autolock lock(mLock); 587 CHECK_PARAM_INTF(mImpl); 588 return mImpl->getISType(); 589 } 590 591 uint8_t QCameraParametersIntf::getMobicatMask() 592 { 593 Mutex::Autolock lock(mLock); 594 CHECK_PARAM_INTF(mImpl); 595 return mImpl->getMobicatMask(); 596 } 597 598 cam_focus_mode_type QCameraParametersIntf::getFocusMode() const 599 { 600 Mutex::Autolock lock(mLock); 601 CHECK_PARAM_INTF(mImpl); 602 return mImpl->getFocusMode(); 603 } 604 605 int32_t QCameraParametersIntf::setNumOfSnapshot() 606 { 607 Mutex::Autolock lock(mLock); 608 CHECK_PARAM_INTF(mImpl); 609 return mImpl->setNumOfSnapshot(); 610 } 611 612 int32_t QCameraParametersIntf::adjustPreviewFpsRange(cam_fps_range_t *fpsRange) 613 { 614 Mutex::Autolock lock(mLock); 615 CHECK_PARAM_INTF(mImpl); 616 return mImpl->adjustPreviewFpsRange(fpsRange); 617 } 618 619 bool QCameraParametersIntf::isJpegPictureFormat() 620 { 621 Mutex::Autolock lock(mLock); 622 CHECK_PARAM_INTF(mImpl); 623 return mImpl->isJpegPictureFormat(); 624 } 625 626 bool QCameraParametersIntf::isNV16PictureFormat() 627 { 628 Mutex::Autolock lock(mLock); 629 CHECK_PARAM_INTF(mImpl); 630 return mImpl->isNV16PictureFormat(); 631 } 632 633 bool QCameraParametersIntf::isNV21PictureFormat() 634 { 635 Mutex::Autolock lock(mLock); 636 CHECK_PARAM_INTF(mImpl); 637 return mImpl->isNV21PictureFormat(); 638 } 639 640 cam_denoise_process_type_t QCameraParametersIntf::getDenoiseProcessPlate( 641 cam_intf_parm_type_t type) 642 { 643 Mutex::Autolock lock(mLock); 644 CHECK_PARAM_INTF(mImpl); 645 return mImpl->getDenoiseProcessPlate(type); 646 } 647 648 int32_t QCameraParametersIntf::getMaxPicSize(cam_dimension_t &dim) 649 { 650 Mutex::Autolock lock(mLock); 651 CHECK_PARAM_INTF(mImpl); 652 return mImpl->getMaxPicSize(dim); 653 } 654 655 int QCameraParametersIntf::getFlipMode(cam_stream_type_t streamType) 656 { 657 Mutex::Autolock lock(mLock); 658 CHECK_PARAM_INTF(mImpl); 659 return mImpl->getFlipMode(streamType); 660 } 661 662 bool QCameraParametersIntf::isSnapshotFDNeeded() 663 { 664 Mutex::Autolock lock(mLock); 665 CHECK_PARAM_INTF(mImpl); 666 return mImpl->isSnapshotFDNeeded(); 667 } 668 669 bool QCameraParametersIntf::isHDR1xFrameEnabled() 670 { 671 Mutex::Autolock lock(mLock); 672 CHECK_PARAM_INTF(mImpl); 673 return mImpl->isHDR1xFrameEnabled(); 674 } 675 676 bool QCameraParametersIntf::isYUVFrameInfoNeeded() 677 { 678 Mutex::Autolock lock(mLock); 679 CHECK_PARAM_INTF(mImpl); 680 return mImpl->isYUVFrameInfoNeeded(); 681 } 682 683 const char* QCameraParametersIntf::getFrameFmtString(cam_format_t fmt) 684 { 685 Mutex::Autolock lock(mLock); 686 CHECK_PARAM_INTF(mImpl); 687 return mImpl->getFrameFmtString(fmt); 688 } 689 690 bool QCameraParametersIntf::isHDR1xExtraBufferNeeded() 691 { 692 Mutex::Autolock lock(mLock); 693 CHECK_PARAM_INTF(mImpl); 694 return mImpl->isHDR1xExtraBufferNeeded(); 695 } 696 697 bool QCameraParametersIntf::isHDROutputCropEnabled() 698 { 699 Mutex::Autolock lock(mLock); 700 CHECK_PARAM_INTF(mImpl); 701 return mImpl->isHDROutputCropEnabled(); 702 } 703 704 bool QCameraParametersIntf::isPreviewFlipChanged() 705 { 706 Mutex::Autolock lock(mLock); 707 CHECK_PARAM_INTF(mImpl); 708 return mImpl->isPreviewFlipChanged(); 709 } 710 711 bool QCameraParametersIntf::isVideoFlipChanged() 712 { 713 Mutex::Autolock lock(mLock); 714 CHECK_PARAM_INTF(mImpl); 715 return mImpl->isVideoFlipChanged(); 716 } 717 718 bool QCameraParametersIntf::isSnapshotFlipChanged() 719 { 720 Mutex::Autolock lock(mLock); 721 CHECK_PARAM_INTF(mImpl); 722 return mImpl->isSnapshotFlipChanged(); 723 } 724 725 void QCameraParametersIntf::setHDRSceneEnable(bool bflag) 726 { 727 Mutex::Autolock lock(mLock); 728 CHECK_PARAM_INTF(mImpl); 729 mImpl->setHDRSceneEnable(bflag); 730 } 731 732 int32_t QCameraParametersIntf::updateAWBParams(cam_awb_params_t &awb_params) 733 { 734 Mutex::Autolock lock(mLock); 735 CHECK_PARAM_INTF(mImpl); 736 return mImpl->updateAWBParams(awb_params); 737 } 738 739 const char * QCameraParametersIntf::getASDStateString(cam_auto_scene_t scene) 740 { 741 Mutex::Autolock lock(mLock); 742 CHECK_PARAM_INTF(mImpl); 743 return mImpl->getASDStateString(scene); 744 } 745 746 bool QCameraParametersIntf::isHDRThumbnailProcessNeeded() 747 { 748 Mutex::Autolock lock(mLock); 749 CHECK_PARAM_INTF(mImpl); 750 return mImpl->isHDRThumbnailProcessNeeded(); 751 } 752 753 void QCameraParametersIntf::setMinPpMask(cam_feature_mask_t min_pp_mask) 754 { 755 Mutex::Autolock lock(mLock); 756 CHECK_PARAM_INTF(mImpl); 757 mImpl->setMinPpMask(min_pp_mask); 758 } 759 760 bool QCameraParametersIntf::setStreamConfigure(bool isCapture, 761 bool previewAsPostview, bool resetConfig) 762 { 763 Mutex::Autolock lock(mLock); 764 CHECK_PARAM_INTF(mImpl); 765 return mImpl->setStreamConfigure(isCapture, 766 previewAsPostview, resetConfig); 767 } 768 769 int32_t QCameraParametersIntf::addOnlineRotation(uint32_t rotation, 770 uint32_t streamId, int32_t device_rotation) 771 { 772 Mutex::Autolock lock(mLock); 773 CHECK_PARAM_INTF(mImpl); 774 return mImpl->addOnlineRotation(rotation, streamId, device_rotation); 775 } 776 777 uint8_t QCameraParametersIntf::getNumOfExtraBuffersForImageProc() 778 { 779 Mutex::Autolock lock(mLock); 780 CHECK_PARAM_INTF(mImpl); 781 return mImpl->getNumOfExtraBuffersForImageProc(); 782 } 783 784 uint8_t QCameraParametersIntf::getNumOfExtraBuffersForVideo() 785 { 786 Mutex::Autolock lock(mLock); 787 CHECK_PARAM_INTF(mImpl); 788 return mImpl->getNumOfExtraBuffersForVideo(); 789 } 790 791 uint8_t QCameraParametersIntf::getNumOfExtraBuffersForPreview() 792 { 793 Mutex::Autolock lock(mLock); 794 CHECK_PARAM_INTF(mImpl); 795 return mImpl->getNumOfExtraBuffersForPreview(); 796 } 797 798 uint32_t QCameraParametersIntf::getExifBufIndex(uint32_t captureIndex) 799 { 800 Mutex::Autolock lock(mLock); 801 CHECK_PARAM_INTF(mImpl); 802 return mImpl->getExifBufIndex(captureIndex); 803 } 804 805 bool QCameraParametersIntf::needThumbnailReprocess(cam_feature_mask_t *pFeatureMask) 806 { 807 Mutex::Autolock lock(mLock); 808 CHECK_PARAM_INTF(mImpl); 809 return mImpl->needThumbnailReprocess(pFeatureMask); 810 } 811 812 bool QCameraParametersIntf::isUbiFocusEnabled() 813 { 814 Mutex::Autolock lock(mLock); 815 CHECK_PARAM_INTF(mImpl); 816 return mImpl->isUbiFocusEnabled(); 817 } 818 819 bool QCameraParametersIntf::isChromaFlashEnabled() 820 { 821 Mutex::Autolock lock(mLock); 822 CHECK_PARAM_INTF(mImpl); 823 return mImpl->isChromaFlashEnabled(); 824 } 825 826 bool QCameraParametersIntf::isHighQualityNoiseReductionMode() 827 { 828 Mutex::Autolock lock(mLock); 829 CHECK_PARAM_INTF(mImpl); 830 return mImpl->isHighQualityNoiseReductionMode(); 831 } 832 833 bool QCameraParametersIntf::isTruePortraitEnabled() 834 { 835 Mutex::Autolock lock(mLock); 836 CHECK_PARAM_INTF(mImpl); 837 return mImpl->isTruePortraitEnabled(); 838 } 839 840 size_t QCameraParametersIntf::getTPMaxMetaSize() 841 { 842 Mutex::Autolock lock(mLock); 843 CHECK_PARAM_INTF(mImpl); 844 return mImpl->getTPMaxMetaSize(); 845 } 846 847 bool QCameraParametersIntf::isSeeMoreEnabled() 848 { 849 Mutex::Autolock lock(mLock); 850 CHECK_PARAM_INTF(mImpl); 851 return mImpl->isSeeMoreEnabled(); 852 } 853 854 bool QCameraParametersIntf::isStillMoreEnabled() 855 { 856 Mutex::Autolock lock(mLock); 857 CHECK_PARAM_INTF(mImpl); 858 return mImpl->isStillMoreEnabled(); 859 } 860 861 bool QCameraParametersIntf::isOptiZoomEnabled() 862 { 863 Mutex::Autolock lock(mLock); 864 CHECK_PARAM_INTF(mImpl); 865 return mImpl->isOptiZoomEnabled(); 866 } 867 868 int32_t QCameraParametersIntf::commitAFBracket(cam_af_bracketing_t afBracket) 869 { 870 Mutex::Autolock lock(mLock); 871 CHECK_PARAM_INTF(mImpl); 872 return mImpl->commitAFBracket(afBracket); 873 } 874 875 876 int32_t QCameraParametersIntf::set3ALock(bool lock3A) 877 { 878 Mutex::Autolock lock(mLock); 879 CHECK_PARAM_INTF(mImpl); 880 return mImpl->set3ALock(lock3A); 881 } 882 883 int32_t QCameraParametersIntf::setAndCommitZoom(int zoom_level) 884 { 885 Mutex::Autolock lock(mLock); 886 CHECK_PARAM_INTF(mImpl); 887 return mImpl->setAndCommitZoom(zoom_level); 888 } 889 uint8_t QCameraParametersIntf::getBurstCountForAdvancedCapture() 890 { 891 Mutex::Autolock lock(mLock); 892 CHECK_PARAM_INTF(mImpl); 893 return mImpl->getBurstCountForAdvancedCapture(); 894 } 895 uint32_t QCameraParametersIntf::getNumberInBufsForSingleShot() 896 { 897 Mutex::Autolock lock(mLock); 898 CHECK_PARAM_INTF(mImpl); 899 return mImpl->getNumberInBufsForSingleShot(); 900 } 901 uint32_t QCameraParametersIntf::getNumberOutBufsForSingleShot() 902 { 903 Mutex::Autolock lock(mLock); 904 CHECK_PARAM_INTF(mImpl); 905 return mImpl->getNumberOutBufsForSingleShot(); 906 } 907 int32_t QCameraParametersIntf::setLongshotEnable(bool enable) 908 { 909 Mutex::Autolock lock(mLock); 910 CHECK_PARAM_INTF(mImpl); 911 return mImpl->setLongshotEnable(enable); 912 } 913 String8 QCameraParametersIntf::dump() 914 { 915 Mutex::Autolock lock(mLock); 916 CHECK_PARAM_INTF(mImpl); 917 return mImpl->dump(); 918 } 919 bool QCameraParametersIntf::isUbiRefocus() 920 { 921 Mutex::Autolock lock(mLock); 922 CHECK_PARAM_INTF(mImpl); 923 return mImpl->isUbiRefocus(); 924 } 925 uint32_t QCameraParametersIntf::getRefocusMaxMetaSize() 926 { 927 Mutex::Autolock lock(mLock); 928 CHECK_PARAM_INTF(mImpl); 929 return mImpl->getRefocusMaxMetaSize(); 930 } 931 uint8_t QCameraParametersIntf::getRefocusOutputCount() 932 { 933 Mutex::Autolock lock(mLock); 934 CHECK_PARAM_INTF(mImpl); 935 return mImpl->getRefocusOutputCount(); 936 } 937 938 bool QCameraParametersIntf::generateThumbFromMain() 939 { 940 Mutex::Autolock lock(mLock); 941 CHECK_PARAM_INTF(mImpl); 942 return mImpl->generateThumbFromMain(); 943 } 944 945 void QCameraParametersIntf::updateCurrentFocusPosition(cam_focus_pos_info_t &cur_pos_info) 946 { 947 Mutex::Autolock lock(mLock); 948 CHECK_PARAM_INTF(mImpl); 949 mImpl->updateCurrentFocusPosition(cur_pos_info); 950 } 951 952 void QCameraParametersIntf::updateAEInfo(cam_3a_params_t &ae_params) 953 { 954 Mutex::Autolock lock(mLock); 955 CHECK_PARAM_INTF(mImpl); 956 mImpl->updateAEInfo(ae_params); 957 } 958 959 bool QCameraParametersIntf::isAdvCamFeaturesEnabled() 960 { 961 Mutex::Autolock lock(mLock); 962 CHECK_PARAM_INTF(mImpl); 963 return mImpl->isAdvCamFeaturesEnabled(); 964 } 965 966 int32_t QCameraParametersIntf::setAecLock(const char *aecStr) 967 { 968 Mutex::Autolock lock(mLock); 969 CHECK_PARAM_INTF(mImpl); 970 return mImpl->setAecLock(aecStr); 971 } 972 973 int32_t QCameraParametersIntf::updateDebugLevel() 974 { 975 Mutex::Autolock lock(mLock); 976 CHECK_PARAM_INTF(mImpl); 977 return mImpl->updateDebugLevel(); 978 } 979 980 bool QCameraParametersIntf::is4k2kVideoResolution() 981 { 982 Mutex::Autolock lock(mLock); 983 CHECK_PARAM_INTF(mImpl); 984 return mImpl->is4k2kVideoResolution(); 985 } 986 987 bool QCameraParametersIntf::isUBWCEnabled() 988 { 989 Mutex::Autolock lock(mLock); 990 CHECK_PARAM_INTF(mImpl); 991 return mImpl->isUBWCEnabled(); 992 } 993 int QCameraParametersIntf::getBrightness() 994 { 995 Mutex::Autolock lock(mLock); 996 CHECK_PARAM_INTF(mImpl); 997 return mImpl->getBrightness(); 998 } 999 1000 int32_t QCameraParametersIntf::updateOisValue(bool oisValue) 1001 { 1002 Mutex::Autolock lock(mLock); 1003 CHECK_PARAM_INTF(mImpl); 1004 return mImpl->updateOisValue(oisValue); 1005 } 1006 1007 int32_t QCameraParametersIntf::setIntEvent(cam_int_evt_params_t params) 1008 { 1009 Mutex::Autolock lock(mLock); 1010 CHECK_PARAM_INTF(mImpl); 1011 return mImpl->setIntEvent(params); 1012 } 1013 1014 bool QCameraParametersIntf::getofflineRAW() 1015 { 1016 Mutex::Autolock lock(mLock); 1017 CHECK_PARAM_INTF(mImpl); 1018 return mImpl->getofflineRAW(); 1019 } 1020 1021 int32_t QCameraParametersIntf::updatePpFeatureMask(cam_stream_type_t stream_type) 1022 { 1023 Mutex::Autolock lock(mLock); 1024 CHECK_PARAM_INTF(mImpl); 1025 return mImpl->updatePpFeatureMask(stream_type); 1026 } 1027 1028 int32_t QCameraParametersIntf::getStreamPpMask(cam_stream_type_t stream_type, 1029 cam_feature_mask_t &pp_mask) 1030 { 1031 Mutex::Autolock lock(mLock); 1032 CHECK_PARAM_INTF(mImpl); 1033 return mImpl->getStreamPpMask(stream_type, pp_mask); 1034 } 1035 1036 int32_t QCameraParametersIntf::getSharpness() 1037 { 1038 Mutex::Autolock lock(mLock); 1039 CHECK_PARAM_INTF(mImpl); 1040 return mImpl->getSharpness(); 1041 } 1042 1043 int32_t QCameraParametersIntf::getEffect() 1044 { 1045 Mutex::Autolock lock(mLock); 1046 CHECK_PARAM_INTF(mImpl); 1047 return mImpl->getEffect(); 1048 } 1049 1050 int32_t QCameraParametersIntf::updateFlashMode(cam_flash_mode_t flash_mode) 1051 { 1052 Mutex::Autolock lock(mLock); 1053 CHECK_PARAM_INTF(mImpl); 1054 return mImpl->updateFlashMode(flash_mode); 1055 } 1056 1057 int32_t QCameraParametersIntf::configureAEBracketing(cam_capture_frame_config_t &frame_config) 1058 { 1059 Mutex::Autolock lock(mLock); 1060 CHECK_PARAM_INTF(mImpl); 1061 return mImpl->configureAEBracketing(frame_config); 1062 } 1063 1064 int32_t QCameraParametersIntf::configureHDRBracketing(cam_capture_frame_config_t &frame_config) 1065 { 1066 Mutex::Autolock lock(mLock); 1067 CHECK_PARAM_INTF(mImpl); 1068 return mImpl->configureHDRBracketing(frame_config); 1069 } 1070 1071 int32_t QCameraParametersIntf::configFrameCapture(bool commitSettings) 1072 { 1073 Mutex::Autolock lock(mLock); 1074 CHECK_PARAM_INTF(mImpl); 1075 return mImpl->configFrameCapture(commitSettings); 1076 } 1077 1078 int32_t QCameraParametersIntf::resetFrameCapture(bool commitSettings) 1079 { 1080 Mutex::Autolock lock(mLock); 1081 CHECK_PARAM_INTF(mImpl); 1082 return mImpl->resetFrameCapture(commitSettings); 1083 } 1084 1085 cam_still_more_t QCameraParametersIntf::getStillMoreSettings() 1086 { 1087 Mutex::Autolock lock(mLock); 1088 CHECK_PARAM_INTF(mImpl); 1089 return mImpl->getStillMoreSettings(); 1090 } 1091 1092 void QCameraParametersIntf::setStillMoreSettings(cam_still_more_t stillmore_config) 1093 { 1094 Mutex::Autolock lock(mLock); 1095 CHECK_PARAM_INTF(mImpl); 1096 mImpl->setStillMoreSettings(stillmore_config); 1097 } 1098 1099 cam_still_more_t QCameraParametersIntf::getStillMoreCapability() 1100 { 1101 Mutex::Autolock lock(mLock); 1102 CHECK_PARAM_INTF(mImpl); 1103 return mImpl->getStillMoreCapability(); 1104 } 1105 1106 cam_dyn_img_data_t QCameraParametersIntf::getDynamicImgData() 1107 { 1108 Mutex::Autolock lock(mLock); 1109 CHECK_PARAM_INTF(mImpl); 1110 return mImpl->getDynamicImgData(); 1111 } 1112 1113 void QCameraParametersIntf::setDynamicImgData(cam_dyn_img_data_t d) 1114 { 1115 Mutex::Autolock lock(mLock); 1116 CHECK_PARAM_INTF(mImpl); 1117 mImpl->setDynamicImgData(d); 1118 } 1119 1120 int32_t QCameraParametersIntf::getParmZoomLevel() 1121 { 1122 Mutex::Autolock lock(mLock); 1123 CHECK_PARAM_INTF(mImpl); 1124 return mImpl->getParmZoomLevel(); 1125 } 1126 1127 1128 int8_t QCameraParametersIntf::getReprocCount() 1129 { 1130 Mutex::Autolock lock(mLock); 1131 CHECK_PARAM_INTF(mImpl); 1132 return mImpl->getReprocCount(); 1133 } 1134 1135 1136 int8_t QCameraParametersIntf::getCurPPCount() 1137 { 1138 Mutex::Autolock lock(mLock); 1139 CHECK_PARAM_INTF(mImpl); 1140 return mImpl->getCurPPCount(); 1141 } 1142 1143 1144 void QCameraParametersIntf::setReprocCount() 1145 { 1146 Mutex::Autolock lock(mLock); 1147 CHECK_PARAM_INTF(mImpl); 1148 mImpl->setReprocCount(); 1149 } 1150 1151 1152 bool QCameraParametersIntf::isPostProcScaling() 1153 { 1154 Mutex::Autolock lock(mLock); 1155 CHECK_PARAM_INTF(mImpl); 1156 return mImpl->isPostProcScaling(); 1157 } 1158 1159 1160 bool QCameraParametersIntf::isLLNoiseEnabled() 1161 { 1162 Mutex::Autolock lock(mLock); 1163 CHECK_PARAM_INTF(mImpl); 1164 return mImpl->isLLNoiseEnabled(); 1165 } 1166 1167 1168 void QCameraParametersIntf::setCurPPCount(int8_t count) 1169 { 1170 Mutex::Autolock lock(mLock); 1171 CHECK_PARAM_INTF(mImpl); 1172 mImpl->setCurPPCount(count); 1173 } 1174 1175 int32_t QCameraParametersIntf::setToneMapMode(uint32_t value, bool initCommit) 1176 { 1177 Mutex::Autolock lock(mLock); 1178 CHECK_PARAM_INTF(mImpl); 1179 return mImpl->setToneMapMode(value, initCommit); 1180 } 1181 1182 void QCameraParametersIntf::setTintless(bool enable) 1183 { 1184 Mutex::Autolock lock(mLock); 1185 CHECK_PARAM_INTF(mImpl); 1186 mImpl->setTintless(enable); 1187 } 1188 1189 uint8_t QCameraParametersIntf::getLongshotStages() 1190 { 1191 Mutex::Autolock lock(mLock); 1192 CHECK_PARAM_INTF(mImpl); 1193 return mImpl->getLongshotStages(); 1194 } 1195 1196 int8_t QCameraParametersIntf::getBufBatchCount() 1197 { 1198 Mutex::Autolock lock(mLock); 1199 CHECK_PARAM_INTF(mImpl); 1200 return mImpl->getBufBatchCount(); 1201 } 1202 1203 int8_t QCameraParametersIntf::getVideoBatchSize() 1204 { 1205 Mutex::Autolock lock(mLock); 1206 CHECK_PARAM_INTF(mImpl); 1207 return mImpl->getVideoBatchSize(); 1208 } 1209 1210 int32_t QCameraParametersIntf::setManualCaptureMode( 1211 QCameraManualCaptureModes value) 1212 { 1213 Mutex::Autolock lock(mLock); 1214 CHECK_PARAM_INTF(mImpl); 1215 return mImpl->setManualCaptureMode(value); 1216 } 1217 1218 QCameraManualCaptureModes QCameraParametersIntf::getManualCaptureMode() 1219 { 1220 Mutex::Autolock lock(mLock); 1221 CHECK_PARAM_INTF(mImpl); 1222 return mImpl->getManualCaptureMode(); 1223 } 1224 1225 int64_t QCameraParametersIntf::getExposureTime() 1226 { 1227 Mutex::Autolock lock(mLock); 1228 CHECK_PARAM_INTF(mImpl); 1229 return mImpl->getExposureTime(); 1230 } 1231 1232 cam_capture_frame_config_t QCameraParametersIntf::getCaptureFrameConfig() 1233 { 1234 Mutex::Autolock lock(mLock); 1235 CHECK_PARAM_INTF(mImpl); 1236 return mImpl->getCaptureFrameConfig(); 1237 } 1238 1239 void QCameraParametersIntf::setJpegRotation(int rotation) 1240 { 1241 Mutex::Autolock lock(mLock); 1242 CHECK_PARAM_INTF(mImpl); 1243 mImpl->setJpegRotation(rotation); 1244 } 1245 1246 uint32_t QCameraParametersIntf::getJpegRotation() 1247 { 1248 Mutex::Autolock lock(mLock); 1249 CHECK_PARAM_INTF(mImpl); 1250 return mImpl->getJpegRotation(); 1251 } 1252 1253 void QCameraParametersIntf::setLowLightLevel(cam_low_light_mode_t value) 1254 { 1255 Mutex::Autolock lock(mLock); 1256 CHECK_PARAM_INTF(mImpl); 1257 mImpl->setLowLightLevel(value); 1258 } 1259 1260 cam_low_light_mode_t QCameraParametersIntf::getLowLightLevel() 1261 { 1262 CHECK_PARAM_INTF(mImpl); 1263 return mImpl->getLowLightLevel(); 1264 } 1265 1266 bool QCameraParametersIntf::getLowLightCapture() 1267 { 1268 Mutex::Autolock lock(mLock); 1269 CHECK_PARAM_INTF(mImpl); 1270 return mImpl->getLowLightCapture(); 1271 } 1272 1273 bool QCameraParametersIntf::getDcrf() 1274 { 1275 Mutex::Autolock lock(mLock); 1276 CHECK_PARAM_INTF(mImpl); 1277 return mImpl->getDcrf(); 1278 } 1279 1280 int32_t QCameraParametersIntf::setRelatedCamSyncInfo( 1281 cam_sync_related_sensors_event_info_t* info) 1282 { 1283 Mutex::Autolock lock(mLock); 1284 CHECK_PARAM_INTF(mImpl); 1285 return mImpl->setRelatedCamSyncInfo(info); 1286 } 1287 1288 const cam_sync_related_sensors_event_info_t* 1289 QCameraParametersIntf::getRelatedCamSyncInfo(void) 1290 { 1291 Mutex::Autolock lock(mLock); 1292 CHECK_PARAM_INTF(mImpl); 1293 return mImpl->getRelatedCamSyncInfo(); 1294 } 1295 1296 int32_t QCameraParametersIntf::setFrameSyncEnabled( 1297 bool enable) 1298 { 1299 Mutex::Autolock lock(mLock); 1300 CHECK_PARAM_INTF(mImpl); 1301 return mImpl->setFrameSyncEnabled(enable); 1302 } 1303 1304 bool QCameraParametersIntf::isFrameSyncEnabled(void) 1305 { 1306 Mutex::Autolock lock(mLock); 1307 CHECK_PARAM_INTF(mImpl); 1308 return mImpl->isFrameSyncEnabled(); 1309 } 1310 1311 int32_t QCameraParametersIntf::getRelatedCamCalibration( 1312 cam_related_system_calibration_data_t* calib) 1313 { 1314 Mutex::Autolock lock(mLock); 1315 CHECK_PARAM_INTF(mImpl); 1316 return mImpl->getRelatedCamCalibration(calib); 1317 } 1318 1319 int32_t QCameraParametersIntf::bundleRelatedCameras(bool sync, uint32_t sessionid) 1320 { 1321 Mutex::Autolock lock(mLock); 1322 CHECK_PARAM_INTF(mImpl); 1323 return mImpl->bundleRelatedCameras(sync, sessionid); 1324 } 1325 1326 uint8_t QCameraParametersIntf::fdModeInVideo() 1327 { 1328 Mutex::Autolock lock(mLock); 1329 CHECK_PARAM_INTF(mImpl); 1330 return mImpl->fdModeInVideo(); 1331 } 1332 1333 bool QCameraParametersIntf::isOEMFeatEnabled() 1334 { 1335 Mutex::Autolock lock(mLock); 1336 CHECK_PARAM_INTF(mImpl); 1337 return mImpl->isOEMFeatEnabled(); 1338 } 1339 1340 int32_t QCameraParametersIntf::setZslMode(bool value) 1341 { 1342 Mutex::Autolock lock(mLock); 1343 CHECK_PARAM_INTF(mImpl); 1344 return mImpl->setZslMode(value); 1345 } 1346 1347 int32_t QCameraParametersIntf::updateZSLModeValue(bool value) 1348 { 1349 Mutex::Autolock lock(mLock); 1350 CHECK_PARAM_INTF(mImpl); 1351 return mImpl->updateZSLModeValue(value); 1352 } 1353 1354 bool QCameraParametersIntf::isReprocScaleEnabled() 1355 { 1356 Mutex::Autolock lock(mLock); 1357 CHECK_PARAM_INTF(mImpl); 1358 return mImpl->isReprocScaleEnabled(); 1359 } 1360 1361 bool QCameraParametersIntf::isUnderReprocScaling() 1362 { 1363 Mutex::Autolock lock(mLock); 1364 CHECK_PARAM_INTF(mImpl); 1365 return mImpl->isUnderReprocScaling(); 1366 } 1367 1368 int32_t QCameraParametersIntf::getPicSizeFromAPK(int &width, int &height) 1369 { 1370 Mutex::Autolock lock(mLock); 1371 CHECK_PARAM_INTF(mImpl); 1372 return mImpl->getPicSizeFromAPK(width, height); 1373 } 1374 1375 int32_t QCameraParametersIntf::checkFeatureConcurrency() 1376 { 1377 Mutex::Autolock lock(mLock); 1378 CHECK_PARAM_INTF(mImpl); 1379 return mImpl->checkFeatureConcurrency(); 1380 } 1381 1382 int32_t QCameraParametersIntf::setInstantAEC(uint8_t enable, bool initCommit) 1383 { 1384 Mutex::Autolock lock(mLock); 1385 CHECK_PARAM_INTF(mImpl); 1386 return mImpl->setInstantAEC(enable, initCommit); 1387 } 1388 1389 int32_t QCameraParametersIntf::getAnalysisInfo( 1390 bool fdVideoEnabled, 1391 bool hal3, 1392 uint32_t featureMask, 1393 cam_analysis_info_t *pAnalysisInfo) 1394 { 1395 Mutex::Autolock lock(mLock); 1396 CHECK_PARAM_INTF(mImpl); 1397 return mImpl->getAnalysisInfo(fdVideoEnabled, hal3, featureMask, pAnalysisInfo); 1398 } 1399 1400 }; // namespace qcamera 1401