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