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 40extern "C" { 41#include "mm_camera_dbg.h" 42} 43 44namespace qcamera { 45 46#define CHECK_PARAM_INTF(impl) LOG_ALWAYS_FATAL_IF(((impl) == NULL), "impl is NULL!") 47 48QCameraParametersIntf::QCameraParametersIntf() : 49 mImpl(NULL) 50{ 51} 52 53QCameraParametersIntf::~QCameraParametersIntf() 54{ 55 { 56 Mutex::Autolock lock(mLock); 57 if (mImpl) { 58 delete mImpl; 59 mImpl = NULL; 60 } 61 } 62} 63 64 65int32_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 77int32_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 86void QCameraParametersIntf::deinit() 87{ 88 Mutex::Autolock lock(mLock); 89 CHECK_PARAM_INTF(mImpl); 90 mImpl->deinit(); 91} 92 93int32_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 100int32_t QCameraParametersIntf::commitParameters() 101{ 102 Mutex::Autolock lock(mLock); 103 CHECK_PARAM_INTF(mImpl); 104 return mImpl->commitParameters(); 105} 106 107char* QCameraParametersIntf::QCameraParametersIntf::getParameters() 108{ 109 Mutex::Autolock lock(mLock); 110 CHECK_PARAM_INTF(mImpl); 111 return mImpl->getParameters(); 112} 113 114void 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 122bool 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 130int QCameraParametersIntf::getPreviewHalPixelFormat() 131{ 132 Mutex::Autolock lock(mLock); 133 CHECK_PARAM_INTF(mImpl); 134 return mImpl->getPreviewHalPixelFormat(); 135} 136 137int32_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 147int32_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 155int32_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 163void 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 170uint8_t QCameraParametersIntf::getZSLBurstInterval() 171{ 172 Mutex::Autolock lock(mLock); 173 CHECK_PARAM_INTF(mImpl); 174 return mImpl->getZSLBurstInterval(); 175} 176 177uint8_t QCameraParametersIntf::getZSLQueueDepth() 178{ 179 Mutex::Autolock lock(mLock); 180 CHECK_PARAM_INTF(mImpl); 181 return mImpl->getZSLQueueDepth(); 182} 183 184uint8_t QCameraParametersIntf::getZSLBackLookCount() 185{ 186 Mutex::Autolock lock(mLock); 187 CHECK_PARAM_INTF(mImpl); 188 return mImpl->getZSLBackLookCount(); 189} 190 191uint8_t QCameraParametersIntf::getMaxUnmatchedFramesInQueue() 192{ 193 Mutex::Autolock lock(mLock); 194 CHECK_PARAM_INTF(mImpl); 195 return mImpl->getMaxUnmatchedFramesInQueue(); 196} 197 198bool QCameraParametersIntf::isZSLMode() 199{ 200 Mutex::Autolock lock(mLock); 201 CHECK_PARAM_INTF(mImpl); 202 return mImpl->isZSLMode(); 203} 204 205bool QCameraParametersIntf::isRdiMode() 206{ 207 Mutex::Autolock lock(mLock); 208 CHECK_PARAM_INTF(mImpl); 209 return mImpl->isRdiMode(); 210} 211 212bool QCameraParametersIntf::isSecureMode() 213{ 214 Mutex::Autolock lock(mLock); 215 CHECK_PARAM_INTF(mImpl); 216 return mImpl->isSecureMode(); 217} 218 219bool QCameraParametersIntf::isNoDisplayMode() 220{ 221 Mutex::Autolock lock(mLock); 222 CHECK_PARAM_INTF(mImpl); 223 return mImpl->isNoDisplayMode(); 224} 225 226bool QCameraParametersIntf::isWNREnabled() 227{ 228 Mutex::Autolock lock(mLock); 229 CHECK_PARAM_INTF(mImpl); 230 return mImpl->isWNREnabled(); 231} 232 233bool QCameraParametersIntf::isTNRSnapshotEnabled() 234{ 235 Mutex::Autolock lock(mLock); 236 CHECK_PARAM_INTF(mImpl); 237 return mImpl->isTNRSnapshotEnabled(); 238} 239 240int32_t QCameraParametersIntf::getCDSMode() 241{ 242 Mutex::Autolock lock(mLock); 243 CHECK_PARAM_INTF(mImpl); 244 return mImpl->getCDSMode(); 245} 246 247bool QCameraParametersIntf::isLTMForSeeMoreEnabled() 248{ 249 Mutex::Autolock lock(mLock); 250 CHECK_PARAM_INTF(mImpl); 251 return mImpl->isLTMForSeeMoreEnabled(); 252} 253 254bool QCameraParametersIntf::isHfrMode() 255{ 256 Mutex::Autolock lock(mLock); 257 CHECK_PARAM_INTF(mImpl); 258 return mImpl->isHfrMode(); 259} 260 261void QCameraParametersIntf::getHfrFps(cam_fps_range_t &pFpsRange) 262{ 263 Mutex::Autolock lock(mLock); 264 CHECK_PARAM_INTF(mImpl); 265 mImpl->getHfrFps(pFpsRange); 266} 267 268uint8_t QCameraParametersIntf::getNumOfSnapshots() 269{ 270 Mutex::Autolock lock(mLock); 271 CHECK_PARAM_INTF(mImpl); 272 return mImpl->getNumOfSnapshots(); 273} 274 275uint8_t QCameraParametersIntf::getNumOfRetroSnapshots() 276{ 277 Mutex::Autolock lock(mLock); 278 CHECK_PARAM_INTF(mImpl); 279 return mImpl->getNumOfRetroSnapshots(); 280} 281 282uint8_t QCameraParametersIntf::getNumOfExtraHDRInBufsIfNeeded() 283{ 284 Mutex::Autolock lock(mLock); 285 CHECK_PARAM_INTF(mImpl); 286 return mImpl->getNumOfExtraHDRInBufsIfNeeded(); 287} 288 289uint8_t QCameraParametersIntf::getNumOfExtraHDROutBufsIfNeeded() 290{ 291 Mutex::Autolock lock(mLock); 292 CHECK_PARAM_INTF(mImpl); 293 return mImpl->getNumOfExtraHDROutBufsIfNeeded(); 294} 295 296bool QCameraParametersIntf::getRecordingHintValue() 297{ 298 Mutex::Autolock lock(mLock); 299 CHECK_PARAM_INTF(mImpl); 300 return mImpl->getRecordingHintValue(); 301} 302 303uint32_t QCameraParametersIntf::getJpegQuality() 304{ 305 Mutex::Autolock lock(mLock); 306 CHECK_PARAM_INTF(mImpl); 307 return mImpl->getJpegQuality(); 308} 309 310uint32_t QCameraParametersIntf::getRotation() 311{ 312 Mutex::Autolock lock(mLock); 313 CHECK_PARAM_INTF(mImpl); 314 return mImpl->getRotation(); 315} 316 317uint32_t QCameraParametersIntf::getDeviceRotation() 318{ 319 Mutex::Autolock lock(mLock); 320 CHECK_PARAM_INTF(mImpl); 321 return mImpl->getDeviceRotation(); 322} 323 324uint32_t QCameraParametersIntf::getJpegExifRotation() 325{ 326 Mutex::Autolock lock(mLock); 327 CHECK_PARAM_INTF(mImpl); 328 return mImpl->getJpegExifRotation(); 329} 330 331bool QCameraParametersIntf::useJpegExifRotation() 332{ 333 Mutex::Autolock lock(mLock); 334 CHECK_PARAM_INTF(mImpl); 335 return mImpl->useJpegExifRotation(); 336} 337 338int32_t QCameraParametersIntf::getEffectValue() 339{ 340 Mutex::Autolock lock(mLock); 341 CHECK_PARAM_INTF(mImpl); 342 return mImpl->getEffectValue(); 343} 344 345bool QCameraParametersIntf::isInstantAECEnabled() 346{ 347 Mutex::Autolock lock(mLock); 348 CHECK_PARAM_INTF(mImpl); 349 return mImpl->isInstantAECEnabled(); 350} 351 352bool QCameraParametersIntf::isInstantCaptureEnabled() 353{ 354 Mutex::Autolock lock(mLock); 355 CHECK_PARAM_INTF(mImpl); 356 return mImpl->isInstantCaptureEnabled(); 357} 358 359uint8_t QCameraParametersIntf::getAecFrameBoundValue() 360{ 361 Mutex::Autolock lock(mLock); 362 CHECK_PARAM_INTF(mImpl); 363 return mImpl->getAecFrameBoundValue(); 364} 365 366uint8_t QCameraParametersIntf::getAecSkipDisplayFrameBound() 367{ 368 Mutex::Autolock lock(mLock); 369 CHECK_PARAM_INTF(mImpl); 370 return mImpl->getAecSkipDisplayFrameBound(); 371} 372 373int32_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 381int32_t QCameraParametersIntf::getExifFocalLength(rat_t *focalLength) 382{ 383 Mutex::Autolock lock(mLock); 384 CHECK_PARAM_INTF(mImpl); 385 return mImpl->getExifFocalLength(focalLength); 386} 387 388uint16_t QCameraParametersIntf::getExifIsoSpeed() 389{ 390 Mutex::Autolock lock(mLock); 391 CHECK_PARAM_INTF(mImpl); 392 return mImpl->getExifIsoSpeed(); 393} 394 395int32_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 402int32_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 409int32_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 416int32_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 423int32_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 430bool QCameraParametersIntf::isVideoBuffersCached() 431{ 432 Mutex::Autolock lock(mLock); 433 CHECK_PARAM_INTF(mImpl); 434 return mImpl->isVideoBuffersCached(); 435} 436 437int32_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 444bool QCameraParametersIntf::isAEBracketEnabled() 445{ 446 Mutex::Autolock lock(mLock); 447 CHECK_PARAM_INTF(mImpl); 448 return mImpl->isAEBracketEnabled(); 449} 450 451int32_t QCameraParametersIntf::setAEBracketing() 452{ 453 Mutex::Autolock lock(mLock); 454 CHECK_PARAM_INTF(mImpl); 455 return mImpl->setAEBracketing(); 456} 457 458bool QCameraParametersIntf::isFpsDebugEnabled() 459{ 460 Mutex::Autolock lock(mLock); 461 CHECK_PARAM_INTF(mImpl); 462 return mImpl->isFpsDebugEnabled(); 463} 464 465bool QCameraParametersIntf::isHistogramEnabled() 466{ 467 Mutex::Autolock lock(mLock); 468 CHECK_PARAM_INTF(mImpl); 469 return mImpl->isHistogramEnabled(); 470} 471 472bool QCameraParametersIntf::isSceneSelectionEnabled() 473{ 474 Mutex::Autolock lock(mLock); 475 CHECK_PARAM_INTF(mImpl); 476 return mImpl->isSceneSelectionEnabled(); 477} 478 479int32_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 486cam_scene_mode_type QCameraParametersIntf::getSelectedScene() 487{ 488 Mutex::Autolock lock(mLock); 489 CHECK_PARAM_INTF(mImpl); 490 return mImpl->getSelectedScene(); 491} 492 493bool QCameraParametersIntf::isFaceDetectionEnabled() 494{ 495 Mutex::Autolock lock(mLock); 496 CHECK_PARAM_INTF(mImpl); 497 return mImpl->isFaceDetectionEnabled(); 498} 499 500int32_t QCameraParametersIntf::setFaceDetectionOption(bool enabled) 501{ 502 Mutex::Autolock lock(mLock); 503 CHECK_PARAM_INTF(mImpl); 504 return mImpl->setFaceDetectionOption(enabled); 505} 506 507int32_t QCameraParametersIntf::setHistogram(bool enabled) 508{ 509 Mutex::Autolock lock(mLock); 510 CHECK_PARAM_INTF(mImpl); 511 return mImpl->setHistogram(enabled); 512} 513 514int32_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 521int32_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 528qcamera_thermal_mode QCameraParametersIntf::getThermalMode() 529{ 530 Mutex::Autolock lock(mLock); 531 CHECK_PARAM_INTF(mImpl); 532 return mImpl->getThermalMode(); 533} 534 535int32_t QCameraParametersIntf::updateRecordingHintValue(int32_t value) 536{ 537 Mutex::Autolock lock(mLock); 538 CHECK_PARAM_INTF(mImpl); 539 return mImpl->updateRecordingHintValue(value); 540} 541 542int32_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 549bool QCameraParametersIntf::isHDREnabled() 550{ 551 Mutex::Autolock lock(mLock); 552 CHECK_PARAM_INTF(mImpl); 553 return mImpl->isHDREnabled(); 554} 555 556bool QCameraParametersIntf::isAutoHDREnabled() 557{ 558 Mutex::Autolock lock(mLock); 559 CHECK_PARAM_INTF(mImpl); 560 return mImpl->isAutoHDREnabled(); 561} 562 563int32_t QCameraParametersIntf::stopAEBracket() 564{ 565 Mutex::Autolock lock(mLock); 566 CHECK_PARAM_INTF(mImpl); 567 return mImpl->stopAEBracket(); 568} 569 570int32_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 577bool QCameraParametersIntf::isDISEnabled() 578{ 579 Mutex::Autolock lock(mLock); 580 CHECK_PARAM_INTF(mImpl); 581 return mImpl->isDISEnabled(); 582} 583 584cam_is_type_t QCameraParametersIntf::getISType() 585{ 586 Mutex::Autolock lock(mLock); 587 CHECK_PARAM_INTF(mImpl); 588 return mImpl->getISType(); 589} 590 591uint8_t QCameraParametersIntf::getMobicatMask() 592{ 593 Mutex::Autolock lock(mLock); 594 CHECK_PARAM_INTF(mImpl); 595 return mImpl->getMobicatMask(); 596} 597 598cam_focus_mode_type QCameraParametersIntf::getFocusMode() const 599{ 600 Mutex::Autolock lock(mLock); 601 CHECK_PARAM_INTF(mImpl); 602 return mImpl->getFocusMode(); 603} 604 605int32_t QCameraParametersIntf::setNumOfSnapshot() 606{ 607 Mutex::Autolock lock(mLock); 608 CHECK_PARAM_INTF(mImpl); 609 return mImpl->setNumOfSnapshot(); 610} 611 612int32_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 619bool QCameraParametersIntf::isJpegPictureFormat() 620{ 621 Mutex::Autolock lock(mLock); 622 CHECK_PARAM_INTF(mImpl); 623 return mImpl->isJpegPictureFormat(); 624} 625 626bool QCameraParametersIntf::isNV16PictureFormat() 627{ 628 Mutex::Autolock lock(mLock); 629 CHECK_PARAM_INTF(mImpl); 630 return mImpl->isNV16PictureFormat(); 631} 632 633bool QCameraParametersIntf::isNV21PictureFormat() 634{ 635 Mutex::Autolock lock(mLock); 636 CHECK_PARAM_INTF(mImpl); 637 return mImpl->isNV21PictureFormat(); 638} 639 640cam_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 648int32_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 655int 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 662bool QCameraParametersIntf::isSnapshotFDNeeded() 663{ 664 Mutex::Autolock lock(mLock); 665 CHECK_PARAM_INTF(mImpl); 666 return mImpl->isSnapshotFDNeeded(); 667} 668 669bool QCameraParametersIntf::isHDR1xFrameEnabled() 670{ 671 Mutex::Autolock lock(mLock); 672 CHECK_PARAM_INTF(mImpl); 673 return mImpl->isHDR1xFrameEnabled(); 674} 675 676bool QCameraParametersIntf::isYUVFrameInfoNeeded() 677{ 678 Mutex::Autolock lock(mLock); 679 CHECK_PARAM_INTF(mImpl); 680 return mImpl->isYUVFrameInfoNeeded(); 681} 682 683const 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 690bool QCameraParametersIntf::isHDR1xExtraBufferNeeded() 691{ 692 Mutex::Autolock lock(mLock); 693 CHECK_PARAM_INTF(mImpl); 694 return mImpl->isHDR1xExtraBufferNeeded(); 695} 696 697bool QCameraParametersIntf::isHDROutputCropEnabled() 698{ 699 Mutex::Autolock lock(mLock); 700 CHECK_PARAM_INTF(mImpl); 701 return mImpl->isHDROutputCropEnabled(); 702} 703 704bool QCameraParametersIntf::isPreviewFlipChanged() 705{ 706 Mutex::Autolock lock(mLock); 707 CHECK_PARAM_INTF(mImpl); 708 return mImpl->isPreviewFlipChanged(); 709} 710 711bool QCameraParametersIntf::isVideoFlipChanged() 712{ 713 Mutex::Autolock lock(mLock); 714 CHECK_PARAM_INTF(mImpl); 715 return mImpl->isVideoFlipChanged(); 716} 717 718bool QCameraParametersIntf::isSnapshotFlipChanged() 719{ 720 Mutex::Autolock lock(mLock); 721 CHECK_PARAM_INTF(mImpl); 722 return mImpl->isSnapshotFlipChanged(); 723} 724 725void QCameraParametersIntf::setHDRSceneEnable(bool bflag) 726{ 727 Mutex::Autolock lock(mLock); 728 CHECK_PARAM_INTF(mImpl); 729 mImpl->setHDRSceneEnable(bflag); 730} 731 732int32_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 739const 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 746bool QCameraParametersIntf::isHDRThumbnailProcessNeeded() 747{ 748 Mutex::Autolock lock(mLock); 749 CHECK_PARAM_INTF(mImpl); 750 return mImpl->isHDRThumbnailProcessNeeded(); 751} 752 753void 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 760bool 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 769int32_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 777uint8_t QCameraParametersIntf::getNumOfExtraBuffersForImageProc() 778{ 779 Mutex::Autolock lock(mLock); 780 CHECK_PARAM_INTF(mImpl); 781 return mImpl->getNumOfExtraBuffersForImageProc(); 782} 783 784uint8_t QCameraParametersIntf::getNumOfExtraBuffersForVideo() 785{ 786 Mutex::Autolock lock(mLock); 787 CHECK_PARAM_INTF(mImpl); 788 return mImpl->getNumOfExtraBuffersForVideo(); 789} 790 791uint8_t QCameraParametersIntf::getNumOfExtraBuffersForPreview() 792{ 793 Mutex::Autolock lock(mLock); 794 CHECK_PARAM_INTF(mImpl); 795 return mImpl->getNumOfExtraBuffersForPreview(); 796} 797 798uint32_t QCameraParametersIntf::getExifBufIndex(uint32_t captureIndex) 799{ 800 Mutex::Autolock lock(mLock); 801 CHECK_PARAM_INTF(mImpl); 802 return mImpl->getExifBufIndex(captureIndex); 803} 804 805bool 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 812bool QCameraParametersIntf::isUbiFocusEnabled() 813{ 814 Mutex::Autolock lock(mLock); 815 CHECK_PARAM_INTF(mImpl); 816 return mImpl->isUbiFocusEnabled(); 817} 818 819bool QCameraParametersIntf::isChromaFlashEnabled() 820{ 821 Mutex::Autolock lock(mLock); 822 CHECK_PARAM_INTF(mImpl); 823 return mImpl->isChromaFlashEnabled(); 824} 825 826bool QCameraParametersIntf::isHighQualityNoiseReductionMode() 827{ 828 Mutex::Autolock lock(mLock); 829 CHECK_PARAM_INTF(mImpl); 830 return mImpl->isHighQualityNoiseReductionMode(); 831} 832 833bool QCameraParametersIntf::isTruePortraitEnabled() 834{ 835 Mutex::Autolock lock(mLock); 836 CHECK_PARAM_INTF(mImpl); 837 return mImpl->isTruePortraitEnabled(); 838} 839 840size_t QCameraParametersIntf::getTPMaxMetaSize() 841{ 842 Mutex::Autolock lock(mLock); 843 CHECK_PARAM_INTF(mImpl); 844 return mImpl->getTPMaxMetaSize(); 845} 846 847bool QCameraParametersIntf::isSeeMoreEnabled() 848{ 849 Mutex::Autolock lock(mLock); 850 CHECK_PARAM_INTF(mImpl); 851 return mImpl->isSeeMoreEnabled(); 852} 853 854bool QCameraParametersIntf::isStillMoreEnabled() 855{ 856 Mutex::Autolock lock(mLock); 857 CHECK_PARAM_INTF(mImpl); 858 return mImpl->isStillMoreEnabled(); 859} 860 861bool QCameraParametersIntf::isOptiZoomEnabled() 862{ 863 Mutex::Autolock lock(mLock); 864 CHECK_PARAM_INTF(mImpl); 865 return mImpl->isOptiZoomEnabled(); 866} 867 868int32_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 876int32_t QCameraParametersIntf::set3ALock(bool lock3A) 877{ 878 Mutex::Autolock lock(mLock); 879 CHECK_PARAM_INTF(mImpl); 880 return mImpl->set3ALock(lock3A); 881} 882 883int32_t QCameraParametersIntf::setAndCommitZoom(int zoom_level) 884{ 885 Mutex::Autolock lock(mLock); 886 CHECK_PARAM_INTF(mImpl); 887 return mImpl->setAndCommitZoom(zoom_level); 888} 889uint8_t QCameraParametersIntf::getBurstCountForAdvancedCapture() 890{ 891 Mutex::Autolock lock(mLock); 892 CHECK_PARAM_INTF(mImpl); 893 return mImpl->getBurstCountForAdvancedCapture(); 894} 895uint32_t QCameraParametersIntf::getNumberInBufsForSingleShot() 896{ 897 Mutex::Autolock lock(mLock); 898 CHECK_PARAM_INTF(mImpl); 899 return mImpl->getNumberInBufsForSingleShot(); 900} 901uint32_t QCameraParametersIntf::getNumberOutBufsForSingleShot() 902{ 903 Mutex::Autolock lock(mLock); 904 CHECK_PARAM_INTF(mImpl); 905 return mImpl->getNumberOutBufsForSingleShot(); 906} 907int32_t QCameraParametersIntf::setLongshotEnable(bool enable) 908{ 909 Mutex::Autolock lock(mLock); 910 CHECK_PARAM_INTF(mImpl); 911 return mImpl->setLongshotEnable(enable); 912} 913String8 QCameraParametersIntf::dump() 914{ 915 Mutex::Autolock lock(mLock); 916 CHECK_PARAM_INTF(mImpl); 917 return mImpl->dump(); 918} 919bool QCameraParametersIntf::isUbiRefocus() 920{ 921 Mutex::Autolock lock(mLock); 922 CHECK_PARAM_INTF(mImpl); 923 return mImpl->isUbiRefocus(); 924} 925uint32_t QCameraParametersIntf::getRefocusMaxMetaSize() 926{ 927 Mutex::Autolock lock(mLock); 928 CHECK_PARAM_INTF(mImpl); 929 return mImpl->getRefocusMaxMetaSize(); 930} 931uint8_t QCameraParametersIntf::getRefocusOutputCount() 932{ 933 Mutex::Autolock lock(mLock); 934 CHECK_PARAM_INTF(mImpl); 935 return mImpl->getRefocusOutputCount(); 936} 937 938bool QCameraParametersIntf::generateThumbFromMain() 939{ 940 Mutex::Autolock lock(mLock); 941 CHECK_PARAM_INTF(mImpl); 942 return mImpl->generateThumbFromMain(); 943} 944 945void 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 952void 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 959bool QCameraParametersIntf::isAdvCamFeaturesEnabled() 960{ 961 Mutex::Autolock lock(mLock); 962 CHECK_PARAM_INTF(mImpl); 963 return mImpl->isAdvCamFeaturesEnabled(); 964} 965 966int32_t QCameraParametersIntf::setAecLock(const char *aecStr) 967{ 968 Mutex::Autolock lock(mLock); 969 CHECK_PARAM_INTF(mImpl); 970 return mImpl->setAecLock(aecStr); 971} 972 973int32_t QCameraParametersIntf::updateDebugLevel() 974{ 975 Mutex::Autolock lock(mLock); 976 CHECK_PARAM_INTF(mImpl); 977 return mImpl->updateDebugLevel(); 978} 979 980bool QCameraParametersIntf::is4k2kVideoResolution() 981{ 982 Mutex::Autolock lock(mLock); 983 CHECK_PARAM_INTF(mImpl); 984 return mImpl->is4k2kVideoResolution(); 985} 986 987bool QCameraParametersIntf::isUBWCEnabled() 988{ 989 Mutex::Autolock lock(mLock); 990 CHECK_PARAM_INTF(mImpl); 991 return mImpl->isUBWCEnabled(); 992} 993int QCameraParametersIntf::getBrightness() 994{ 995 Mutex::Autolock lock(mLock); 996 CHECK_PARAM_INTF(mImpl); 997 return mImpl->getBrightness(); 998} 999 1000int32_t QCameraParametersIntf::updateOisValue(bool oisValue) 1001{ 1002 Mutex::Autolock lock(mLock); 1003 CHECK_PARAM_INTF(mImpl); 1004 return mImpl->updateOisValue(oisValue); 1005} 1006 1007int32_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 1014bool QCameraParametersIntf::getofflineRAW() 1015{ 1016 Mutex::Autolock lock(mLock); 1017 CHECK_PARAM_INTF(mImpl); 1018 return mImpl->getofflineRAW(); 1019} 1020 1021int32_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 1028int32_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 1036int32_t QCameraParametersIntf::getSharpness() 1037{ 1038 Mutex::Autolock lock(mLock); 1039 CHECK_PARAM_INTF(mImpl); 1040 return mImpl->getSharpness(); 1041} 1042 1043int32_t QCameraParametersIntf::getEffect() 1044{ 1045 Mutex::Autolock lock(mLock); 1046 CHECK_PARAM_INTF(mImpl); 1047 return mImpl->getEffect(); 1048} 1049 1050int32_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 1057int32_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 1064int32_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 1071int32_t QCameraParametersIntf::configFrameCapture(bool commitSettings) 1072{ 1073 Mutex::Autolock lock(mLock); 1074 CHECK_PARAM_INTF(mImpl); 1075 return mImpl->configFrameCapture(commitSettings); 1076} 1077 1078int32_t QCameraParametersIntf::resetFrameCapture(bool commitSettings) 1079{ 1080 Mutex::Autolock lock(mLock); 1081 CHECK_PARAM_INTF(mImpl); 1082 return mImpl->resetFrameCapture(commitSettings); 1083} 1084 1085cam_still_more_t QCameraParametersIntf::getStillMoreSettings() 1086{ 1087 Mutex::Autolock lock(mLock); 1088 CHECK_PARAM_INTF(mImpl); 1089 return mImpl->getStillMoreSettings(); 1090} 1091 1092void 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 1099cam_still_more_t QCameraParametersIntf::getStillMoreCapability() 1100{ 1101 Mutex::Autolock lock(mLock); 1102 CHECK_PARAM_INTF(mImpl); 1103 return mImpl->getStillMoreCapability(); 1104} 1105 1106cam_dyn_img_data_t QCameraParametersIntf::getDynamicImgData() 1107{ 1108 Mutex::Autolock lock(mLock); 1109 CHECK_PARAM_INTF(mImpl); 1110 return mImpl->getDynamicImgData(); 1111} 1112 1113void 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 1120int32_t QCameraParametersIntf::getParmZoomLevel() 1121{ 1122 Mutex::Autolock lock(mLock); 1123 CHECK_PARAM_INTF(mImpl); 1124 return mImpl->getParmZoomLevel(); 1125} 1126 1127 1128int8_t QCameraParametersIntf::getReprocCount() 1129{ 1130 Mutex::Autolock lock(mLock); 1131 CHECK_PARAM_INTF(mImpl); 1132 return mImpl->getReprocCount(); 1133} 1134 1135 1136int8_t QCameraParametersIntf::getCurPPCount() 1137{ 1138 Mutex::Autolock lock(mLock); 1139 CHECK_PARAM_INTF(mImpl); 1140 return mImpl->getCurPPCount(); 1141} 1142 1143 1144void QCameraParametersIntf::setReprocCount() 1145{ 1146 Mutex::Autolock lock(mLock); 1147 CHECK_PARAM_INTF(mImpl); 1148 mImpl->setReprocCount(); 1149} 1150 1151 1152bool QCameraParametersIntf::isPostProcScaling() 1153{ 1154 Mutex::Autolock lock(mLock); 1155 CHECK_PARAM_INTF(mImpl); 1156 return mImpl->isPostProcScaling(); 1157} 1158 1159 1160bool QCameraParametersIntf::isLLNoiseEnabled() 1161{ 1162 Mutex::Autolock lock(mLock); 1163 CHECK_PARAM_INTF(mImpl); 1164 return mImpl->isLLNoiseEnabled(); 1165} 1166 1167 1168void QCameraParametersIntf::setCurPPCount(int8_t count) 1169{ 1170 Mutex::Autolock lock(mLock); 1171 CHECK_PARAM_INTF(mImpl); 1172 mImpl->setCurPPCount(count); 1173} 1174 1175int32_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 1182void QCameraParametersIntf::setTintless(bool enable) 1183{ 1184 Mutex::Autolock lock(mLock); 1185 CHECK_PARAM_INTF(mImpl); 1186 mImpl->setTintless(enable); 1187} 1188 1189uint8_t QCameraParametersIntf::getLongshotStages() 1190{ 1191 Mutex::Autolock lock(mLock); 1192 CHECK_PARAM_INTF(mImpl); 1193 return mImpl->getLongshotStages(); 1194} 1195 1196int8_t QCameraParametersIntf::getBufBatchCount() 1197{ 1198 Mutex::Autolock lock(mLock); 1199 CHECK_PARAM_INTF(mImpl); 1200 return mImpl->getBufBatchCount(); 1201} 1202 1203int8_t QCameraParametersIntf::getVideoBatchSize() 1204{ 1205 Mutex::Autolock lock(mLock); 1206 CHECK_PARAM_INTF(mImpl); 1207 return mImpl->getVideoBatchSize(); 1208} 1209 1210int32_t QCameraParametersIntf::setManualCaptureMode( 1211 QCameraManualCaptureModes value) 1212{ 1213 Mutex::Autolock lock(mLock); 1214 CHECK_PARAM_INTF(mImpl); 1215 return mImpl->setManualCaptureMode(value); 1216} 1217 1218QCameraManualCaptureModes QCameraParametersIntf::getManualCaptureMode() 1219{ 1220 Mutex::Autolock lock(mLock); 1221 CHECK_PARAM_INTF(mImpl); 1222 return mImpl->getManualCaptureMode(); 1223} 1224 1225int64_t QCameraParametersIntf::getExposureTime() 1226{ 1227 Mutex::Autolock lock(mLock); 1228 CHECK_PARAM_INTF(mImpl); 1229 return mImpl->getExposureTime(); 1230} 1231 1232cam_capture_frame_config_t QCameraParametersIntf::getCaptureFrameConfig() 1233{ 1234 Mutex::Autolock lock(mLock); 1235 CHECK_PARAM_INTF(mImpl); 1236 return mImpl->getCaptureFrameConfig(); 1237} 1238 1239void QCameraParametersIntf::setJpegRotation(int rotation) 1240{ 1241 Mutex::Autolock lock(mLock); 1242 CHECK_PARAM_INTF(mImpl); 1243 mImpl->setJpegRotation(rotation); 1244} 1245 1246uint32_t QCameraParametersIntf::getJpegRotation() 1247{ 1248 Mutex::Autolock lock(mLock); 1249 CHECK_PARAM_INTF(mImpl); 1250 return mImpl->getJpegRotation(); 1251} 1252 1253void 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 1260cam_low_light_mode_t QCameraParametersIntf::getLowLightLevel() 1261{ 1262 CHECK_PARAM_INTF(mImpl); 1263 return mImpl->getLowLightLevel(); 1264} 1265 1266bool QCameraParametersIntf::getLowLightCapture() 1267{ 1268 Mutex::Autolock lock(mLock); 1269 CHECK_PARAM_INTF(mImpl); 1270 return mImpl->getLowLightCapture(); 1271} 1272 1273bool QCameraParametersIntf::getDcrf() 1274{ 1275 Mutex::Autolock lock(mLock); 1276 CHECK_PARAM_INTF(mImpl); 1277 return mImpl->getDcrf(); 1278} 1279 1280int32_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 1288const 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 1296int32_t QCameraParametersIntf::setFrameSyncEnabled( 1297 bool enable) 1298{ 1299 Mutex::Autolock lock(mLock); 1300 CHECK_PARAM_INTF(mImpl); 1301 return mImpl->setFrameSyncEnabled(enable); 1302} 1303 1304bool QCameraParametersIntf::isFrameSyncEnabled(void) 1305{ 1306 Mutex::Autolock lock(mLock); 1307 CHECK_PARAM_INTF(mImpl); 1308 return mImpl->isFrameSyncEnabled(); 1309} 1310 1311int32_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 1319int32_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 1326uint8_t QCameraParametersIntf::fdModeInVideo() 1327{ 1328 Mutex::Autolock lock(mLock); 1329 CHECK_PARAM_INTF(mImpl); 1330 return mImpl->fdModeInVideo(); 1331} 1332 1333bool QCameraParametersIntf::isOEMFeatEnabled() 1334{ 1335 Mutex::Autolock lock(mLock); 1336 CHECK_PARAM_INTF(mImpl); 1337 return mImpl->isOEMFeatEnabled(); 1338} 1339 1340int32_t QCameraParametersIntf::setZslMode(bool value) 1341{ 1342 Mutex::Autolock lock(mLock); 1343 CHECK_PARAM_INTF(mImpl); 1344 return mImpl->setZslMode(value); 1345} 1346 1347int32_t QCameraParametersIntf::updateZSLModeValue(bool value) 1348{ 1349 Mutex::Autolock lock(mLock); 1350 CHECK_PARAM_INTF(mImpl); 1351 return mImpl->updateZSLModeValue(value); 1352} 1353 1354bool QCameraParametersIntf::isReprocScaleEnabled() 1355{ 1356 Mutex::Autolock lock(mLock); 1357 CHECK_PARAM_INTF(mImpl); 1358 return mImpl->isReprocScaleEnabled(); 1359} 1360 1361bool QCameraParametersIntf::isUnderReprocScaling() 1362{ 1363 Mutex::Autolock lock(mLock); 1364 CHECK_PARAM_INTF(mImpl); 1365 return mImpl->isUnderReprocScaling(); 1366} 1367 1368int32_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 1375int32_t QCameraParametersIntf::checkFeatureConcurrency() 1376{ 1377 Mutex::Autolock lock(mLock); 1378 CHECK_PARAM_INTF(mImpl); 1379 return mImpl->checkFeatureConcurrency(); 1380} 1381 1382int32_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 1389int32_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