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
QCameraParametersIntf()48 QCameraParametersIntf::QCameraParametersIntf() :
49 mImpl(NULL)
50 {
51 }
52
~QCameraParametersIntf()53 QCameraParametersIntf::~QCameraParametersIntf()
54 {
55 {
56 Mutex::Autolock lock(mLock);
57 if (mImpl) {
58 delete mImpl;
59 mImpl = NULL;
60 }
61 }
62 }
63
64
allocate()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
init(cam_capability_t * capabilities,mm_camera_vtbl_t * mmOps,QCameraAdjustFPS * adjustFPS)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
deinit()86 void QCameraParametersIntf::deinit()
87 {
88 Mutex::Autolock lock(mLock);
89 CHECK_PARAM_INTF(mImpl);
90 mImpl->deinit();
91 }
92
updateParameters(const String8 & params,bool & needRestart)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
commitParameters()100 int32_t QCameraParametersIntf::commitParameters()
101 {
102 Mutex::Autolock lock(mLock);
103 CHECK_PARAM_INTF(mImpl);
104 return mImpl->commitParameters();
105 }
106
getParameters()107 char* QCameraParametersIntf::QCameraParametersIntf::getParameters()
108 {
109 Mutex::Autolock lock(mLock);
110 CHECK_PARAM_INTF(mImpl);
111 return mImpl->getParameters();
112 }
113
getPreviewFpsRange(int * min_fps,int * max_fps) const114 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
getTsMakeupInfo(int & whiteLevel,int & cleanLevel) const122 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
getPreviewHalPixelFormat()130 int QCameraParametersIntf::getPreviewHalPixelFormat()
131 {
132 Mutex::Autolock lock(mLock);
133 CHECK_PARAM_INTF(mImpl);
134 return mImpl->getPreviewHalPixelFormat();
135 }
136
getStreamRotation(cam_stream_type_t streamType,cam_pp_feature_config_t & featureConfig,cam_dimension_t & dim)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
getStreamFormat(cam_stream_type_t streamType,cam_format_t & format)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
getStreamDimension(cam_stream_type_t streamType,cam_dimension_t & dim)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
getThumbnailSize(int * width,int * height) const163 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
getZSLBurstInterval()170 uint8_t QCameraParametersIntf::getZSLBurstInterval()
171 {
172 Mutex::Autolock lock(mLock);
173 CHECK_PARAM_INTF(mImpl);
174 return mImpl->getZSLBurstInterval();
175 }
176
getZSLQueueDepth()177 uint8_t QCameraParametersIntf::getZSLQueueDepth()
178 {
179 Mutex::Autolock lock(mLock);
180 CHECK_PARAM_INTF(mImpl);
181 return mImpl->getZSLQueueDepth();
182 }
183
getZSLBackLookCount()184 uint8_t QCameraParametersIntf::getZSLBackLookCount()
185 {
186 Mutex::Autolock lock(mLock);
187 CHECK_PARAM_INTF(mImpl);
188 return mImpl->getZSLBackLookCount();
189 }
190
getMaxUnmatchedFramesInQueue()191 uint8_t QCameraParametersIntf::getMaxUnmatchedFramesInQueue()
192 {
193 Mutex::Autolock lock(mLock);
194 CHECK_PARAM_INTF(mImpl);
195 return mImpl->getMaxUnmatchedFramesInQueue();
196 }
197
isZSLMode()198 bool QCameraParametersIntf::isZSLMode()
199 {
200 Mutex::Autolock lock(mLock);
201 CHECK_PARAM_INTF(mImpl);
202 return mImpl->isZSLMode();
203 }
204
isRdiMode()205 bool QCameraParametersIntf::isRdiMode()
206 {
207 Mutex::Autolock lock(mLock);
208 CHECK_PARAM_INTF(mImpl);
209 return mImpl->isRdiMode();
210 }
211
isSecureMode()212 bool QCameraParametersIntf::isSecureMode()
213 {
214 Mutex::Autolock lock(mLock);
215 CHECK_PARAM_INTF(mImpl);
216 return mImpl->isSecureMode();
217 }
218
isNoDisplayMode()219 bool QCameraParametersIntf::isNoDisplayMode()
220 {
221 Mutex::Autolock lock(mLock);
222 CHECK_PARAM_INTF(mImpl);
223 return mImpl->isNoDisplayMode();
224 }
225
isWNREnabled()226 bool QCameraParametersIntf::isWNREnabled()
227 {
228 Mutex::Autolock lock(mLock);
229 CHECK_PARAM_INTF(mImpl);
230 return mImpl->isWNREnabled();
231 }
232
isTNRSnapshotEnabled()233 bool QCameraParametersIntf::isTNRSnapshotEnabled()
234 {
235 Mutex::Autolock lock(mLock);
236 CHECK_PARAM_INTF(mImpl);
237 return mImpl->isTNRSnapshotEnabled();
238 }
239
getCDSMode()240 int32_t QCameraParametersIntf::getCDSMode()
241 {
242 Mutex::Autolock lock(mLock);
243 CHECK_PARAM_INTF(mImpl);
244 return mImpl->getCDSMode();
245 }
246
isLTMForSeeMoreEnabled()247 bool QCameraParametersIntf::isLTMForSeeMoreEnabled()
248 {
249 Mutex::Autolock lock(mLock);
250 CHECK_PARAM_INTF(mImpl);
251 return mImpl->isLTMForSeeMoreEnabled();
252 }
253
isHfrMode()254 bool QCameraParametersIntf::isHfrMode()
255 {
256 Mutex::Autolock lock(mLock);
257 CHECK_PARAM_INTF(mImpl);
258 return mImpl->isHfrMode();
259 }
260
getHfrFps(cam_fps_range_t & pFpsRange)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
getNumOfSnapshots()268 uint8_t QCameraParametersIntf::getNumOfSnapshots()
269 {
270 Mutex::Autolock lock(mLock);
271 CHECK_PARAM_INTF(mImpl);
272 return mImpl->getNumOfSnapshots();
273 }
274
getNumOfRetroSnapshots()275 uint8_t QCameraParametersIntf::getNumOfRetroSnapshots()
276 {
277 Mutex::Autolock lock(mLock);
278 CHECK_PARAM_INTF(mImpl);
279 return mImpl->getNumOfRetroSnapshots();
280 }
281
getNumOfExtraHDRInBufsIfNeeded()282 uint8_t QCameraParametersIntf::getNumOfExtraHDRInBufsIfNeeded()
283 {
284 Mutex::Autolock lock(mLock);
285 CHECK_PARAM_INTF(mImpl);
286 return mImpl->getNumOfExtraHDRInBufsIfNeeded();
287 }
288
getNumOfExtraHDROutBufsIfNeeded()289 uint8_t QCameraParametersIntf::getNumOfExtraHDROutBufsIfNeeded()
290 {
291 Mutex::Autolock lock(mLock);
292 CHECK_PARAM_INTF(mImpl);
293 return mImpl->getNumOfExtraHDROutBufsIfNeeded();
294 }
295
getRecordingHintValue()296 bool QCameraParametersIntf::getRecordingHintValue()
297 {
298 Mutex::Autolock lock(mLock);
299 CHECK_PARAM_INTF(mImpl);
300 return mImpl->getRecordingHintValue();
301 }
302
getJpegQuality()303 uint32_t QCameraParametersIntf::getJpegQuality()
304 {
305 Mutex::Autolock lock(mLock);
306 CHECK_PARAM_INTF(mImpl);
307 return mImpl->getJpegQuality();
308 }
309
getRotation()310 uint32_t QCameraParametersIntf::getRotation()
311 {
312 Mutex::Autolock lock(mLock);
313 CHECK_PARAM_INTF(mImpl);
314 return mImpl->getRotation();
315 }
316
getDeviceRotation()317 uint32_t QCameraParametersIntf::getDeviceRotation()
318 {
319 Mutex::Autolock lock(mLock);
320 CHECK_PARAM_INTF(mImpl);
321 return mImpl->getDeviceRotation();
322 }
323
getJpegExifRotation()324 uint32_t QCameraParametersIntf::getJpegExifRotation()
325 {
326 Mutex::Autolock lock(mLock);
327 CHECK_PARAM_INTF(mImpl);
328 return mImpl->getJpegExifRotation();
329 }
330
useJpegExifRotation()331 bool QCameraParametersIntf::useJpegExifRotation()
332 {
333 Mutex::Autolock lock(mLock);
334 CHECK_PARAM_INTF(mImpl);
335 return mImpl->useJpegExifRotation();
336 }
337
getEffectValue()338 int32_t QCameraParametersIntf::getEffectValue()
339 {
340 Mutex::Autolock lock(mLock);
341 CHECK_PARAM_INTF(mImpl);
342 return mImpl->getEffectValue();
343 }
344
isInstantAECEnabled()345 bool QCameraParametersIntf::isInstantAECEnabled()
346 {
347 Mutex::Autolock lock(mLock);
348 CHECK_PARAM_INTF(mImpl);
349 return mImpl->isInstantAECEnabled();
350 }
351
isInstantCaptureEnabled()352 bool QCameraParametersIntf::isInstantCaptureEnabled()
353 {
354 Mutex::Autolock lock(mLock);
355 CHECK_PARAM_INTF(mImpl);
356 return mImpl->isInstantCaptureEnabled();
357 }
358
getAecFrameBoundValue()359 uint8_t QCameraParametersIntf::getAecFrameBoundValue()
360 {
361 Mutex::Autolock lock(mLock);
362 CHECK_PARAM_INTF(mImpl);
363 return mImpl->getAecFrameBoundValue();
364 }
365
getAecSkipDisplayFrameBound()366 uint8_t QCameraParametersIntf::getAecSkipDisplayFrameBound()
367 {
368 Mutex::Autolock lock(mLock);
369 CHECK_PARAM_INTF(mImpl);
370 return mImpl->getAecSkipDisplayFrameBound();
371 }
372
getExifDateTime(String8 & dateTime,String8 & subsecTime)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
getExifFocalLength(rat_t * focalLength)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
getExifIsoSpeed()388 uint16_t QCameraParametersIntf::getExifIsoSpeed()
389 {
390 Mutex::Autolock lock(mLock);
391 CHECK_PARAM_INTF(mImpl);
392 return mImpl->getExifIsoSpeed();
393 }
394
getExifGpsProcessingMethod(char * gpsProcessingMethod,uint32_t & count)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
getExifLatitude(rat_t * latitude,char * latRef)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
getExifLongitude(rat_t * longitude,char * lonRef)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
getExifAltitude(rat_t * altitude,char * altRef)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
getExifGpsDateTimeStamp(char * gpsDateStamp,uint32_t bufLen,rat_t * gpsTimeStamp)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
isVideoBuffersCached()430 bool QCameraParametersIntf::isVideoBuffersCached()
431 {
432 Mutex::Autolock lock(mLock);
433 CHECK_PARAM_INTF(mImpl);
434 return mImpl->isVideoBuffersCached();
435 }
436
updateFocusDistances(cam_focus_distances_info_t * focusDistances)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
isAEBracketEnabled()444 bool QCameraParametersIntf::isAEBracketEnabled()
445 {
446 Mutex::Autolock lock(mLock);
447 CHECK_PARAM_INTF(mImpl);
448 return mImpl->isAEBracketEnabled();
449 }
450
setAEBracketing()451 int32_t QCameraParametersIntf::setAEBracketing()
452 {
453 Mutex::Autolock lock(mLock);
454 CHECK_PARAM_INTF(mImpl);
455 return mImpl->setAEBracketing();
456 }
457
isFpsDebugEnabled()458 bool QCameraParametersIntf::isFpsDebugEnabled()
459 {
460 Mutex::Autolock lock(mLock);
461 CHECK_PARAM_INTF(mImpl);
462 return mImpl->isFpsDebugEnabled();
463 }
464
isHistogramEnabled()465 bool QCameraParametersIntf::isHistogramEnabled()
466 {
467 Mutex::Autolock lock(mLock);
468 CHECK_PARAM_INTF(mImpl);
469 return mImpl->isHistogramEnabled();
470 }
471
isSceneSelectionEnabled()472 bool QCameraParametersIntf::isSceneSelectionEnabled()
473 {
474 Mutex::Autolock lock(mLock);
475 CHECK_PARAM_INTF(mImpl);
476 return mImpl->isSceneSelectionEnabled();
477 }
478
setSelectedScene(cam_scene_mode_type scene)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
getSelectedScene()486 cam_scene_mode_type QCameraParametersIntf::getSelectedScene()
487 {
488 Mutex::Autolock lock(mLock);
489 CHECK_PARAM_INTF(mImpl);
490 return mImpl->getSelectedScene();
491 }
492
isFaceDetectionEnabled()493 bool QCameraParametersIntf::isFaceDetectionEnabled()
494 {
495 Mutex::Autolock lock(mLock);
496 CHECK_PARAM_INTF(mImpl);
497 return mImpl->isFaceDetectionEnabled();
498 }
499
setFaceDetectionOption(bool enabled)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
setHistogram(bool enabled)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
setFaceDetection(bool enabled,bool initCommit)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
setFrameSkip(enum msm_vfe_frame_skip_pattern pattern)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
getThermalMode()528 qcamera_thermal_mode QCameraParametersIntf::getThermalMode()
529 {
530 Mutex::Autolock lock(mLock);
531 CHECK_PARAM_INTF(mImpl);
532 return mImpl->getThermalMode();
533 }
534
updateRecordingHintValue(int32_t value)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
setHDRAEBracket(cam_exp_bracketing_t hdrBracket)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
isHDREnabled()549 bool QCameraParametersIntf::isHDREnabled()
550 {
551 Mutex::Autolock lock(mLock);
552 CHECK_PARAM_INTF(mImpl);
553 return mImpl->isHDREnabled();
554 }
555
isAutoHDREnabled()556 bool QCameraParametersIntf::isAutoHDREnabled()
557 {
558 Mutex::Autolock lock(mLock);
559 CHECK_PARAM_INTF(mImpl);
560 return mImpl->isAutoHDREnabled();
561 }
562
stopAEBracket()563 int32_t QCameraParametersIntf::stopAEBracket()
564 {
565 Mutex::Autolock lock(mLock);
566 CHECK_PARAM_INTF(mImpl);
567 return mImpl->stopAEBracket();
568 }
569
updateRAW(cam_dimension_t max_dim)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
isDISEnabled()577 bool QCameraParametersIntf::isDISEnabled()
578 {
579 Mutex::Autolock lock(mLock);
580 CHECK_PARAM_INTF(mImpl);
581 return mImpl->isDISEnabled();
582 }
583
getISType()584 cam_is_type_t QCameraParametersIntf::getISType()
585 {
586 Mutex::Autolock lock(mLock);
587 CHECK_PARAM_INTF(mImpl);
588 return mImpl->getISType();
589 }
590
getMobicatMask()591 uint8_t QCameraParametersIntf::getMobicatMask()
592 {
593 Mutex::Autolock lock(mLock);
594 CHECK_PARAM_INTF(mImpl);
595 return mImpl->getMobicatMask();
596 }
597
getFocusMode() const598 cam_focus_mode_type QCameraParametersIntf::getFocusMode() const
599 {
600 Mutex::Autolock lock(mLock);
601 CHECK_PARAM_INTF(mImpl);
602 return mImpl->getFocusMode();
603 }
604
setNumOfSnapshot()605 int32_t QCameraParametersIntf::setNumOfSnapshot()
606 {
607 Mutex::Autolock lock(mLock);
608 CHECK_PARAM_INTF(mImpl);
609 return mImpl->setNumOfSnapshot();
610 }
611
adjustPreviewFpsRange(cam_fps_range_t * fpsRange)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
isJpegPictureFormat()619 bool QCameraParametersIntf::isJpegPictureFormat()
620 {
621 Mutex::Autolock lock(mLock);
622 CHECK_PARAM_INTF(mImpl);
623 return mImpl->isJpegPictureFormat();
624 }
625
isNV16PictureFormat()626 bool QCameraParametersIntf::isNV16PictureFormat()
627 {
628 Mutex::Autolock lock(mLock);
629 CHECK_PARAM_INTF(mImpl);
630 return mImpl->isNV16PictureFormat();
631 }
632
isNV21PictureFormat()633 bool QCameraParametersIntf::isNV21PictureFormat()
634 {
635 Mutex::Autolock lock(mLock);
636 CHECK_PARAM_INTF(mImpl);
637 return mImpl->isNV21PictureFormat();
638 }
639
getDenoiseProcessPlate(cam_intf_parm_type_t type)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
getMaxPicSize(cam_dimension_t & dim)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
getFlipMode(cam_stream_type_t streamType)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
isSnapshotFDNeeded()662 bool QCameraParametersIntf::isSnapshotFDNeeded()
663 {
664 Mutex::Autolock lock(mLock);
665 CHECK_PARAM_INTF(mImpl);
666 return mImpl->isSnapshotFDNeeded();
667 }
668
isHDR1xFrameEnabled()669 bool QCameraParametersIntf::isHDR1xFrameEnabled()
670 {
671 Mutex::Autolock lock(mLock);
672 CHECK_PARAM_INTF(mImpl);
673 return mImpl->isHDR1xFrameEnabled();
674 }
675
isYUVFrameInfoNeeded()676 bool QCameraParametersIntf::isYUVFrameInfoNeeded()
677 {
678 Mutex::Autolock lock(mLock);
679 CHECK_PARAM_INTF(mImpl);
680 return mImpl->isYUVFrameInfoNeeded();
681 }
682
getFrameFmtString(cam_format_t fmt)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
isHDR1xExtraBufferNeeded()690 bool QCameraParametersIntf::isHDR1xExtraBufferNeeded()
691 {
692 Mutex::Autolock lock(mLock);
693 CHECK_PARAM_INTF(mImpl);
694 return mImpl->isHDR1xExtraBufferNeeded();
695 }
696
isHDROutputCropEnabled()697 bool QCameraParametersIntf::isHDROutputCropEnabled()
698 {
699 Mutex::Autolock lock(mLock);
700 CHECK_PARAM_INTF(mImpl);
701 return mImpl->isHDROutputCropEnabled();
702 }
703
isPreviewFlipChanged()704 bool QCameraParametersIntf::isPreviewFlipChanged()
705 {
706 Mutex::Autolock lock(mLock);
707 CHECK_PARAM_INTF(mImpl);
708 return mImpl->isPreviewFlipChanged();
709 }
710
isVideoFlipChanged()711 bool QCameraParametersIntf::isVideoFlipChanged()
712 {
713 Mutex::Autolock lock(mLock);
714 CHECK_PARAM_INTF(mImpl);
715 return mImpl->isVideoFlipChanged();
716 }
717
isSnapshotFlipChanged()718 bool QCameraParametersIntf::isSnapshotFlipChanged()
719 {
720 Mutex::Autolock lock(mLock);
721 CHECK_PARAM_INTF(mImpl);
722 return mImpl->isSnapshotFlipChanged();
723 }
724
setHDRSceneEnable(bool bflag)725 void QCameraParametersIntf::setHDRSceneEnable(bool bflag)
726 {
727 Mutex::Autolock lock(mLock);
728 CHECK_PARAM_INTF(mImpl);
729 mImpl->setHDRSceneEnable(bflag);
730 }
731
updateAWBParams(cam_awb_params_t & awb_params)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
getASDStateString(cam_auto_scene_t scene)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
isHDRThumbnailProcessNeeded()746 bool QCameraParametersIntf::isHDRThumbnailProcessNeeded()
747 {
748 Mutex::Autolock lock(mLock);
749 CHECK_PARAM_INTF(mImpl);
750 return mImpl->isHDRThumbnailProcessNeeded();
751 }
752
setMinPpMask(uint32_t min_pp_mask)753 void QCameraParametersIntf::setMinPpMask(uint32_t min_pp_mask)
754 {
755 Mutex::Autolock lock(mLock);
756 CHECK_PARAM_INTF(mImpl);
757 mImpl->setMinPpMask(min_pp_mask);
758 }
759
setStreamConfigure(bool isCapture,bool previewAsPostview,bool resetConfig)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
addOnlineRotation(uint32_t rotation,uint32_t streamId,int32_t device_rotation)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
getNumOfExtraBuffersForImageProc()777 uint8_t QCameraParametersIntf::getNumOfExtraBuffersForImageProc()
778 {
779 Mutex::Autolock lock(mLock);
780 CHECK_PARAM_INTF(mImpl);
781 return mImpl->getNumOfExtraBuffersForImageProc();
782 }
783
getNumOfExtraBuffersForVideo()784 uint8_t QCameraParametersIntf::getNumOfExtraBuffersForVideo()
785 {
786 Mutex::Autolock lock(mLock);
787 CHECK_PARAM_INTF(mImpl);
788 return mImpl->getNumOfExtraBuffersForVideo();
789 }
790
getNumOfExtraBuffersForPreview()791 uint8_t QCameraParametersIntf::getNumOfExtraBuffersForPreview()
792 {
793 Mutex::Autolock lock(mLock);
794 CHECK_PARAM_INTF(mImpl);
795 return mImpl->getNumOfExtraBuffersForPreview();
796 }
797
getExifBufIndex(uint32_t captureIndex)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
needThumbnailReprocess(uint32_t * pFeatureMask)805 bool QCameraParametersIntf::needThumbnailReprocess(uint32_t *pFeatureMask)
806 {
807 Mutex::Autolock lock(mLock);
808 CHECK_PARAM_INTF(mImpl);
809 return mImpl->needThumbnailReprocess(pFeatureMask);
810 }
811
isUbiFocusEnabled()812 bool QCameraParametersIntf::isUbiFocusEnabled()
813 {
814 Mutex::Autolock lock(mLock);
815 CHECK_PARAM_INTF(mImpl);
816 return mImpl->isUbiFocusEnabled();
817 }
818
isChromaFlashEnabled()819 bool QCameraParametersIntf::isChromaFlashEnabled()
820 {
821 Mutex::Autolock lock(mLock);
822 CHECK_PARAM_INTF(mImpl);
823 return mImpl->isChromaFlashEnabled();
824 }
825
isHighQualityNoiseReductionMode()826 bool QCameraParametersIntf::isHighQualityNoiseReductionMode()
827 {
828 Mutex::Autolock lock(mLock);
829 CHECK_PARAM_INTF(mImpl);
830 return mImpl->isHighQualityNoiseReductionMode();
831 }
832
isTruePortraitEnabled()833 bool QCameraParametersIntf::isTruePortraitEnabled()
834 {
835 Mutex::Autolock lock(mLock);
836 CHECK_PARAM_INTF(mImpl);
837 return mImpl->isTruePortraitEnabled();
838 }
839
getTPMaxMetaSize()840 size_t QCameraParametersIntf::getTPMaxMetaSize()
841 {
842 Mutex::Autolock lock(mLock);
843 CHECK_PARAM_INTF(mImpl);
844 return mImpl->getTPMaxMetaSize();
845 }
846
isSeeMoreEnabled()847 bool QCameraParametersIntf::isSeeMoreEnabled()
848 {
849 Mutex::Autolock lock(mLock);
850 CHECK_PARAM_INTF(mImpl);
851 return mImpl->isSeeMoreEnabled();
852 }
853
isStillMoreEnabled()854 bool QCameraParametersIntf::isStillMoreEnabled()
855 {
856 Mutex::Autolock lock(mLock);
857 CHECK_PARAM_INTF(mImpl);
858 return mImpl->isStillMoreEnabled();
859 }
860
isOptiZoomEnabled()861 bool QCameraParametersIntf::isOptiZoomEnabled()
862 {
863 Mutex::Autolock lock(mLock);
864 CHECK_PARAM_INTF(mImpl);
865 return mImpl->isOptiZoomEnabled();
866 }
867
commitAFBracket(cam_af_bracketing_t afBracket)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
set3ALock(bool lock3A)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
setAndCommitZoom(int zoom_level)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 }
getBurstCountForAdvancedCapture()889 uint8_t QCameraParametersIntf::getBurstCountForAdvancedCapture()
890 {
891 Mutex::Autolock lock(mLock);
892 CHECK_PARAM_INTF(mImpl);
893 return mImpl->getBurstCountForAdvancedCapture();
894 }
getNumberInBufsForSingleShot()895 uint32_t QCameraParametersIntf::getNumberInBufsForSingleShot()
896 {
897 Mutex::Autolock lock(mLock);
898 CHECK_PARAM_INTF(mImpl);
899 return mImpl->getNumberInBufsForSingleShot();
900 }
getNumberOutBufsForSingleShot()901 uint32_t QCameraParametersIntf::getNumberOutBufsForSingleShot()
902 {
903 Mutex::Autolock lock(mLock);
904 CHECK_PARAM_INTF(mImpl);
905 return mImpl->getNumberOutBufsForSingleShot();
906 }
setLongshotEnable(bool enable)907 int32_t QCameraParametersIntf::setLongshotEnable(bool enable)
908 {
909 Mutex::Autolock lock(mLock);
910 CHECK_PARAM_INTF(mImpl);
911 return mImpl->setLongshotEnable(enable);
912 }
dump()913 String8 QCameraParametersIntf::dump()
914 {
915 Mutex::Autolock lock(mLock);
916 CHECK_PARAM_INTF(mImpl);
917 return mImpl->dump();
918 }
isUbiRefocus()919 bool QCameraParametersIntf::isUbiRefocus()
920 {
921 Mutex::Autolock lock(mLock);
922 CHECK_PARAM_INTF(mImpl);
923 return mImpl->isUbiRefocus();
924 }
getRefocusMaxMetaSize()925 uint32_t QCameraParametersIntf::getRefocusMaxMetaSize()
926 {
927 Mutex::Autolock lock(mLock);
928 CHECK_PARAM_INTF(mImpl);
929 return mImpl->getRefocusMaxMetaSize();
930 }
getRefocusOutputCount()931 uint8_t QCameraParametersIntf::getRefocusOutputCount()
932 {
933 Mutex::Autolock lock(mLock);
934 CHECK_PARAM_INTF(mImpl);
935 return mImpl->getRefocusOutputCount();
936 }
937
generateThumbFromMain()938 bool QCameraParametersIntf::generateThumbFromMain()
939 {
940 Mutex::Autolock lock(mLock);
941 CHECK_PARAM_INTF(mImpl);
942 return mImpl->generateThumbFromMain();
943 }
944
updateCurrentFocusPosition(cam_focus_pos_info_t & cur_pos_info)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
updateAEInfo(cam_3a_params_t & ae_params)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
isAdvCamFeaturesEnabled()959 bool QCameraParametersIntf::isAdvCamFeaturesEnabled()
960 {
961 Mutex::Autolock lock(mLock);
962 CHECK_PARAM_INTF(mImpl);
963 return mImpl->isAdvCamFeaturesEnabled();
964 }
965
setAecLock(const char * aecStr)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
updateDebugLevel()973 int32_t QCameraParametersIntf::updateDebugLevel()
974 {
975 Mutex::Autolock lock(mLock);
976 CHECK_PARAM_INTF(mImpl);
977 return mImpl->updateDebugLevel();
978 }
979
is4k2kVideoResolution()980 bool QCameraParametersIntf::is4k2kVideoResolution()
981 {
982 Mutex::Autolock lock(mLock);
983 CHECK_PARAM_INTF(mImpl);
984 return mImpl->is4k2kVideoResolution();
985 }
986
isUBWCEnabled()987 bool QCameraParametersIntf::isUBWCEnabled()
988 {
989 Mutex::Autolock lock(mLock);
990 CHECK_PARAM_INTF(mImpl);
991 return mImpl->isUBWCEnabled();
992 }
getBrightness()993 int QCameraParametersIntf::getBrightness()
994 {
995 Mutex::Autolock lock(mLock);
996 CHECK_PARAM_INTF(mImpl);
997 return mImpl->getBrightness();
998 }
999
updateOisValue(bool oisValue)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
setIntEvent(cam_int_evt_params_t params)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
getofflineRAW()1014 bool QCameraParametersIntf::getofflineRAW()
1015 {
1016 Mutex::Autolock lock(mLock);
1017 CHECK_PARAM_INTF(mImpl);
1018 return mImpl->getofflineRAW();
1019 }
1020
updatePpFeatureMask(cam_stream_type_t stream_type)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
getStreamPpMask(cam_stream_type_t stream_type,uint32_t & pp_mask)1028 int32_t QCameraParametersIntf::getStreamPpMask(cam_stream_type_t stream_type,
1029 uint32_t &pp_mask)
1030 {
1031 Mutex::Autolock lock(mLock);
1032 CHECK_PARAM_INTF(mImpl);
1033 return mImpl->getStreamPpMask(stream_type, pp_mask);
1034 }
1035
getSharpness()1036 int32_t QCameraParametersIntf::getSharpness()
1037 {
1038 Mutex::Autolock lock(mLock);
1039 CHECK_PARAM_INTF(mImpl);
1040 return mImpl->getSharpness();
1041 }
1042
getEffect()1043 int32_t QCameraParametersIntf::getEffect()
1044 {
1045 Mutex::Autolock lock(mLock);
1046 CHECK_PARAM_INTF(mImpl);
1047 return mImpl->getEffect();
1048 }
1049
updateFlashMode(cam_flash_mode_t flash_mode)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
configureAEBracketing(cam_capture_frame_config_t & frame_config)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
configureHDRBracketing(cam_capture_frame_config_t & frame_config)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
configFrameCapture(bool commitSettings)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
resetFrameCapture(bool commitSettings)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
getStillMoreSettings()1085 cam_still_more_t QCameraParametersIntf::getStillMoreSettings()
1086 {
1087 Mutex::Autolock lock(mLock);
1088 CHECK_PARAM_INTF(mImpl);
1089 return mImpl->getStillMoreSettings();
1090 }
1091
setStillMoreSettings(cam_still_more_t stillmore_config)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
getStillMoreCapability()1099 cam_still_more_t QCameraParametersIntf::getStillMoreCapability()
1100 {
1101 Mutex::Autolock lock(mLock);
1102 CHECK_PARAM_INTF(mImpl);
1103 return mImpl->getStillMoreCapability();
1104 }
1105
getDynamicImgData()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
setDynamicImgData(cam_dyn_img_data_t d)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
getParmZoomLevel()1120 int32_t QCameraParametersIntf::getParmZoomLevel()
1121 {
1122 Mutex::Autolock lock(mLock);
1123 CHECK_PARAM_INTF(mImpl);
1124 return mImpl->getParmZoomLevel();
1125 }
1126
1127
getReprocCount()1128 int8_t QCameraParametersIntf::getReprocCount()
1129 {
1130 Mutex::Autolock lock(mLock);
1131 CHECK_PARAM_INTF(mImpl);
1132 return mImpl->getReprocCount();
1133 }
1134
1135
getCurPPCount()1136 int8_t QCameraParametersIntf::getCurPPCount()
1137 {
1138 Mutex::Autolock lock(mLock);
1139 CHECK_PARAM_INTF(mImpl);
1140 return mImpl->getCurPPCount();
1141 }
1142
1143
setReprocCount()1144 void QCameraParametersIntf::setReprocCount()
1145 {
1146 Mutex::Autolock lock(mLock);
1147 CHECK_PARAM_INTF(mImpl);
1148 mImpl->setReprocCount();
1149 }
1150
1151
isPostProcScaling()1152 bool QCameraParametersIntf::isPostProcScaling()
1153 {
1154 Mutex::Autolock lock(mLock);
1155 CHECK_PARAM_INTF(mImpl);
1156 return mImpl->isPostProcScaling();
1157 }
1158
1159
isLLNoiseEnabled()1160 bool QCameraParametersIntf::isLLNoiseEnabled()
1161 {
1162 Mutex::Autolock lock(mLock);
1163 CHECK_PARAM_INTF(mImpl);
1164 return mImpl->isLLNoiseEnabled();
1165 }
1166
1167
setCurPPCount(int8_t count)1168 void QCameraParametersIntf::setCurPPCount(int8_t count)
1169 {
1170 Mutex::Autolock lock(mLock);
1171 CHECK_PARAM_INTF(mImpl);
1172 mImpl->setCurPPCount(count);
1173 }
1174
setToneMapMode(uint32_t value,bool initCommit)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
setTintless(bool enable)1182 void QCameraParametersIntf::setTintless(bool enable)
1183 {
1184 Mutex::Autolock lock(mLock);
1185 CHECK_PARAM_INTF(mImpl);
1186 mImpl->setTintless(enable);
1187 }
1188
getLongshotStages()1189 uint8_t QCameraParametersIntf::getLongshotStages()
1190 {
1191 Mutex::Autolock lock(mLock);
1192 CHECK_PARAM_INTF(mImpl);
1193 return mImpl->getLongshotStages();
1194 }
1195
getBufBatchCount()1196 int8_t QCameraParametersIntf::getBufBatchCount()
1197 {
1198 Mutex::Autolock lock(mLock);
1199 CHECK_PARAM_INTF(mImpl);
1200 return mImpl->getBufBatchCount();
1201 }
1202
getVideoBatchSize()1203 int8_t QCameraParametersIntf::getVideoBatchSize()
1204 {
1205 Mutex::Autolock lock(mLock);
1206 CHECK_PARAM_INTF(mImpl);
1207 return mImpl->getVideoBatchSize();
1208 }
1209
setManualCaptureMode(QCameraManualCaptureModes value)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
getManualCaptureMode()1218 QCameraManualCaptureModes QCameraParametersIntf::getManualCaptureMode()
1219 {
1220 Mutex::Autolock lock(mLock);
1221 CHECK_PARAM_INTF(mImpl);
1222 return mImpl->getManualCaptureMode();
1223 }
1224
getExposureTime()1225 int64_t QCameraParametersIntf::getExposureTime()
1226 {
1227 Mutex::Autolock lock(mLock);
1228 CHECK_PARAM_INTF(mImpl);
1229 return mImpl->getExposureTime();
1230 }
1231
getCaptureFrameConfig()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
setJpegRotation(int rotation)1239 void QCameraParametersIntf::setJpegRotation(int rotation)
1240 {
1241 Mutex::Autolock lock(mLock);
1242 CHECK_PARAM_INTF(mImpl);
1243 mImpl->setJpegRotation(rotation);
1244 }
1245
getJpegRotation()1246 uint32_t QCameraParametersIntf::getJpegRotation()
1247 {
1248 Mutex::Autolock lock(mLock);
1249 CHECK_PARAM_INTF(mImpl);
1250 return mImpl->getJpegRotation();
1251 }
1252
setLowLightLevel(cam_low_light_mode_t value)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
getLowLightLevel()1260 cam_low_light_mode_t QCameraParametersIntf::getLowLightLevel()
1261 {
1262 CHECK_PARAM_INTF(mImpl);
1263 return mImpl->getLowLightLevel();
1264 }
1265
getLowLightCapture()1266 bool QCameraParametersIntf::getLowLightCapture()
1267 {
1268 Mutex::Autolock lock(mLock);
1269 CHECK_PARAM_INTF(mImpl);
1270 return mImpl->getLowLightCapture();
1271 }
1272
getDcrf()1273 bool QCameraParametersIntf::getDcrf()
1274 {
1275 Mutex::Autolock lock(mLock);
1276 CHECK_PARAM_INTF(mImpl);
1277 return mImpl->getDcrf();
1278 }
1279
setRelatedCamSyncInfo(cam_sync_related_sensors_event_info_t * info)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*
getRelatedCamSyncInfo(void)1289 QCameraParametersIntf::getRelatedCamSyncInfo(void)
1290 {
1291 Mutex::Autolock lock(mLock);
1292 CHECK_PARAM_INTF(mImpl);
1293 return mImpl->getRelatedCamSyncInfo();
1294 }
1295
getRelatedCamCalibration(cam_related_system_calibration_data_t * calib)1296 int32_t QCameraParametersIntf::getRelatedCamCalibration(
1297 cam_related_system_calibration_data_t* calib)
1298 {
1299 Mutex::Autolock lock(mLock);
1300 CHECK_PARAM_INTF(mImpl);
1301 return mImpl->getRelatedCamCalibration(calib);
1302 }
1303
bundleRelatedCameras(bool sync,uint32_t sessionid)1304 int32_t QCameraParametersIntf::bundleRelatedCameras(bool sync, uint32_t sessionid)
1305 {
1306 Mutex::Autolock lock(mLock);
1307 CHECK_PARAM_INTF(mImpl);
1308 return mImpl->bundleRelatedCameras(sync, sessionid);
1309 }
1310
fdModeInVideo()1311 uint8_t QCameraParametersIntf::fdModeInVideo()
1312 {
1313 Mutex::Autolock lock(mLock);
1314 CHECK_PARAM_INTF(mImpl);
1315 return mImpl->fdModeInVideo();
1316 }
1317
isOEMFeatEnabled()1318 bool QCameraParametersIntf::isOEMFeatEnabled()
1319 {
1320 Mutex::Autolock lock(mLock);
1321 CHECK_PARAM_INTF(mImpl);
1322 return mImpl->isOEMFeatEnabled();
1323 }
1324
setZslMode(bool value)1325 int32_t QCameraParametersIntf::setZslMode(bool value)
1326 {
1327 Mutex::Autolock lock(mLock);
1328 CHECK_PARAM_INTF(mImpl);
1329 return mImpl->setZslMode(value);
1330 }
1331
updateZSLModeValue(bool value)1332 int32_t QCameraParametersIntf::updateZSLModeValue(bool value)
1333 {
1334 Mutex::Autolock lock(mLock);
1335 CHECK_PARAM_INTF(mImpl);
1336 return mImpl->updateZSLModeValue(value);
1337 }
1338
isReprocScaleEnabled()1339 bool QCameraParametersIntf::isReprocScaleEnabled()
1340 {
1341 Mutex::Autolock lock(mLock);
1342 CHECK_PARAM_INTF(mImpl);
1343 return mImpl->isReprocScaleEnabled();
1344 }
1345
isUnderReprocScaling()1346 bool QCameraParametersIntf::isUnderReprocScaling()
1347 {
1348 Mutex::Autolock lock(mLock);
1349 CHECK_PARAM_INTF(mImpl);
1350 return mImpl->isUnderReprocScaling();
1351 }
1352
getPicSizeFromAPK(int & width,int & height)1353 int32_t QCameraParametersIntf::getPicSizeFromAPK(int &width, int &height)
1354 {
1355 Mutex::Autolock lock(mLock);
1356 CHECK_PARAM_INTF(mImpl);
1357 return mImpl->getPicSizeFromAPK(width, height);
1358 }
1359
checkFeatureConcurrency()1360 int32_t QCameraParametersIntf::checkFeatureConcurrency()
1361 {
1362 Mutex::Autolock lock(mLock);
1363 CHECK_PARAM_INTF(mImpl);
1364 return mImpl->checkFeatureConcurrency();
1365 }
1366
setInstantAEC(uint8_t enable,bool initCommit)1367 int32_t QCameraParametersIntf::setInstantAEC(uint8_t enable, bool initCommit)
1368 {
1369 Mutex::Autolock lock(mLock);
1370 CHECK_PARAM_INTF(mImpl);
1371 return mImpl->setInstantAEC(enable, initCommit);
1372 }
1373
1374 }; // namespace qcamera
1375