1 /*
2  * Copyright (c) 2019-2022 Rockchip Eletronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 #include "RkAiqCamGroupAcacHandle.h"
17 
18 namespace RkCam {
19 
20 #if RKAIQ_HAVE_CAC_V03 || RKAIQ_HAVE_CAC_V10 || RKAIQ_HAVE_CAC_V11
21 
updateConfig(bool needSync)22 XCamReturn RkAiqCamGroupAcacHandleInt::updateConfig(bool needSync) {
23     ENTER_ANALYZER_FUNCTION();
24 
25     XCamReturn ret = XCAM_RETURN_NO_ERROR;
26     if (needSync) mCfgMutex.lock();
27 
28     if (updateAttV03) {
29         mCurAttV03 = mNewAttV03;
30         rk_aiq_uapi_acac_v03_SetAttrib(mAlgoCtx, &mCurAttV03, false);
31         updateAttV03 = false;
32         sendSignal(mCurAttV03.sync.sync_mode);
33     }
34 
35     if (updateAttV10) {
36         mCurAttV10 = mNewAttV10;
37         rk_aiq_uapi_acac_v10_SetAttrib(mAlgoCtx, &mCurAttV10, false);
38         updateAttV10 = false;
39         sendSignal(mCurAttV10.sync.sync_mode);
40     }
41 
42     if (updateAttV11) {
43         mCurAttV11 = mNewAttV11;
44         rk_aiq_uapi_acac_v11_SetAttrib(mAlgoCtx, &mCurAttV11, false);
45         updateAttV11 = false;
46         sendSignal(mCurAttV11.sync.sync_mode);
47     }
48 
49     if (needSync) mCfgMutex.unlock();
50 
51     EXIT_ANALYZER_FUNCTION();
52     return ret;
53 }
54 
setAttribV03(const rkaiq_cac_v03_api_attr_t * att)55 XCamReturn RkAiqCamGroupAcacHandleInt::setAttribV03(const rkaiq_cac_v03_api_attr_t* att) {
56     ENTER_ANALYZER_FUNCTION();
57 
58     XCamReturn ret = XCAM_RETURN_NO_ERROR;
59     mCfgMutex.lock();
60 
61     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
62     // if something changed, set att to mNewAtt, and
63     // the new params will be effective later when updateConfig
64     // called by RkAiqCore
65     bool isChanged = false;
66     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && memcmp(&mNewAttV03, att, sizeof(*att)))
67         isChanged = true;
68     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
69              memcmp(&mCurAttV03, att, sizeof(*att)))
70         isChanged = true;
71 
72     // if something changed
73     if (isChanged) {
74         mNewAttV03   = *att;
75         updateAttV03 = true;
76         waitSignal(att->sync.sync_mode);
77     }
78 
79     mCfgMutex.unlock();
80 
81     EXIT_ANALYZER_FUNCTION();
82     return ret;
83 }
84 
getAttribV03(rkaiq_cac_v03_api_attr_t * att)85 XCamReturn RkAiqCamGroupAcacHandleInt::getAttribV03(rkaiq_cac_v03_api_attr_t* att) {
86     ENTER_ANALYZER_FUNCTION();
87 
88     XCamReturn ret = XCAM_RETURN_NO_ERROR;
89 
90     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
91         mCfgMutex.lock();
92         rk_aiq_uapi_acac_v03_GetAttrib(mAlgoCtx, att);
93         att->sync.done = true;
94         mCfgMutex.unlock();
95     } else {
96         if (updateAttV03) {
97             memcpy(att, &mNewAttV03, sizeof(mNewAttV03));
98             att->sync.done = false;
99         } else {
100             rk_aiq_uapi_acac_v03_GetAttrib(mAlgoCtx, att);
101             att->sync.sync_mode = mNewAttV03.sync.sync_mode;
102             att->sync.done      = true;
103         }
104     }
105 
106     EXIT_ANALYZER_FUNCTION();
107     return ret;
108 }
109 
setAttribV10(const rkaiq_cac_v10_api_attr_t * att)110 XCamReturn RkAiqCamGroupAcacHandleInt::setAttribV10(const rkaiq_cac_v10_api_attr_t* att) {
111     ENTER_ANALYZER_FUNCTION();
112 
113     XCamReturn ret = XCAM_RETURN_NO_ERROR;
114     mCfgMutex.lock();
115 
116     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
117     // if something changed, set att to mNewAtt, and
118     // the new params will be effective later when updateConfig
119     // called by RkAiqCore
120     bool isChanged = false;
121     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && memcmp(&mNewAttV10, att, sizeof(*att)))
122         isChanged = true;
123     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
124              memcmp(&mCurAttV10, att, sizeof(*att)))
125         isChanged = true;
126 
127     // if something changed
128     if (isChanged) {
129         mNewAttV10   = *att;
130         updateAttV10 = true;
131         waitSignal(att->sync.sync_mode);
132     }
133 
134     mCfgMutex.unlock();
135 
136     EXIT_ANALYZER_FUNCTION();
137     return ret;
138 }
139 
getAttribV10(rkaiq_cac_v10_api_attr_t * att)140 XCamReturn RkAiqCamGroupAcacHandleInt::getAttribV10(rkaiq_cac_v10_api_attr_t* att) {
141     ENTER_ANALYZER_FUNCTION();
142 
143     XCamReturn ret = XCAM_RETURN_NO_ERROR;
144 
145     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
146         mCfgMutex.lock();
147         rk_aiq_uapi_acac_v10_GetAttrib(mAlgoCtx, att);
148         att->sync.done = true;
149         mCfgMutex.unlock();
150     } else {
151         if (updateAttV10) {
152             memcpy(att, &mNewAttV10, sizeof(mNewAttV10));
153             att->sync.done = false;
154         } else {
155             rk_aiq_uapi_acac_v10_GetAttrib(mAlgoCtx, att);
156             att->sync.sync_mode = mNewAttV10.sync.sync_mode;
157             att->sync.done      = true;
158         }
159     }
160 
161     EXIT_ANALYZER_FUNCTION();
162     return ret;
163 }
164 
setAttribV11(const rkaiq_cac_v11_api_attr_t * att)165 XCamReturn RkAiqCamGroupAcacHandleInt::setAttribV11(const rkaiq_cac_v11_api_attr_t* att) {
166     ENTER_ANALYZER_FUNCTION();
167 
168     XCamReturn ret = XCAM_RETURN_NO_ERROR;
169     mCfgMutex.lock();
170 
171     // check if there is different between att & mCurAtt(sync)/mNewAtt(async)
172     // if something changed, set att to mNewAtt, and
173     // the new params will be effective later when updateConfig
174     // called by RkAiqCore
175     bool isChanged = false;
176     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_ASYNC && memcmp(&mNewAttV11, att, sizeof(*att)))
177         isChanged = true;
178     else if (att->sync.sync_mode != RK_AIQ_UAPI_MODE_ASYNC &&
179              memcmp(&mCurAttV11, att, sizeof(*att)))
180         isChanged = true;
181 
182     // if something changed
183     if (isChanged) {
184         mNewAttV11   = *att;
185         updateAttV11 = true;
186         waitSignal(att->sync.sync_mode);
187     }
188 
189     mCfgMutex.unlock();
190 
191     EXIT_ANALYZER_FUNCTION();
192     return ret;
193 }
194 
getAttribV11(rkaiq_cac_v11_api_attr_t * att)195 XCamReturn RkAiqCamGroupAcacHandleInt::getAttribV11(rkaiq_cac_v11_api_attr_t* att) {
196     ENTER_ANALYZER_FUNCTION();
197 
198     XCamReturn ret = XCAM_RETURN_NO_ERROR;
199 
200     if (att->sync.sync_mode == RK_AIQ_UAPI_MODE_SYNC) {
201         mCfgMutex.lock();
202         rk_aiq_uapi_acac_v11_GetAttrib(mAlgoCtx, att);
203         att->sync.done = true;
204         mCfgMutex.unlock();
205     } else {
206         if (updateAttV11) {
207             memcpy(att, &mNewAttV11, sizeof(mNewAttV11));
208             att->sync.done = false;
209         } else {
210             rk_aiq_uapi_acac_v11_GetAttrib(mAlgoCtx, att);
211             att->sync.sync_mode = mNewAttV11.sync.sync_mode;
212             att->sync.done      = true;
213         }
214     }
215 
216     EXIT_ANALYZER_FUNCTION();
217     return ret;
218 }
219 
220 #endif
221 
222 }  // namespace RkCam
223