1 /*
2 * Copyright (c) 2019 Rockchip Corporation
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 */
17
18 #include "Isp20Params.h"
19
20 #include <climits>
21 #include <cstring>
22 #include <type_traits>
23
24 #include "common/rkisp21-config.h"
25
26 namespace RkCam {
27
28 #ifndef DISABLE_PARAMS_ASSEMBLER
29 uint32_t IspParamsAssembler::MAX_PENDING_PARAMS = 2;
30
IspParamsAssembler(const char * name)31 IspParamsAssembler::IspParamsAssembler (const char* name)
32 : mLatestReadyFrmId(-1)
33 , mReadyMask(0)
34 , mReadyNums(0)
35 , mName(name)
36 , mCondNum(0)
37 , started(false)
38 {
39 }
40
~IspParamsAssembler()41 IspParamsAssembler::~IspParamsAssembler ()
42 {
43 }
44
45 void
rmReadyCondition(uint32_t cond)46 IspParamsAssembler::rmReadyCondition(uint32_t cond)
47 {
48 SmartLock locker (mParamsMutex);
49 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: enter \n",
50 __FUNCTION__, __LINE__, mName.c_str());
51 if (mCondMaskMap.find(cond) != mCondMaskMap.end()) {
52 mReadyMask &= ~mCondMaskMap[cond];
53 }
54 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: exit \n",
55 __FUNCTION__, __LINE__, mName.c_str());
56 }
57
58 void
addReadyCondition(uint32_t cond)59 IspParamsAssembler::addReadyCondition(uint32_t cond)
60 {
61 SmartLock locker (mParamsMutex);
62 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: enter \n",
63 __FUNCTION__, __LINE__, mName.c_str());
64
65 if (mCondMaskMap.find(cond) == mCondMaskMap.end()) {
66 if (mCondNum > 63) {
67 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: max condintion num exceed 32",
68 mName.c_str());
69 return;
70 }
71
72 mCondMaskMap[cond] = 1 << mCondNum;
73 mReadyMask |= mCondMaskMap[cond];
74 mCondNum++;
75 LOGI_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: map cond %s 0x%x -> 0x%llx, mask: 0x%llx",
76 mName.c_str(), Cam3aResultType2Str[cond], cond, mCondMaskMap[cond], mReadyMask);
77 } else {
78 LOGI_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: map cond %s 0x%x -> 0x%llx already added",
79 mName.c_str(), Cam3aResultType2Str[cond], cond, mCondMaskMap[cond]);
80 }
81
82 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: exit \n",
83 __FUNCTION__, __LINE__, mName.c_str());
84 }
85
86 XCamReturn
queue(SmartPtr<cam3aResult> & result)87 IspParamsAssembler::queue(SmartPtr<cam3aResult>& result)
88 {
89 SmartLock locker (mParamsMutex);
90 return queue_locked(result);
91 }
92
93 XCamReturn
queue_locked(SmartPtr<cam3aResult> & result)94 IspParamsAssembler::queue_locked(SmartPtr<cam3aResult>& result)
95 {
96 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: enter \n",
97 __FUNCTION__, __LINE__, mName.c_str());
98
99 XCamReturn ret = XCAM_RETURN_NO_ERROR;
100
101 if (!result.ptr()) {
102 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: null result", mName.c_str());
103 return ret;
104 }
105
106 uint32_t frame_id = result->getId();
107 int type = result->getType();
108
109 if (!started) {
110 LOGI_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: intial params type %s , result_id[%d] !",
111 mName.c_str(), Cam3aResultType2Str[type], frame_id);
112 if (frame_id != 0)
113 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: intial params type %s , result_id[%d] != 0",
114 mName.c_str(), Cam3aResultType2Str[type], frame_id);
115 mInitParamsList.push_back(result);
116
117 return XCAM_RETURN_NO_ERROR;
118 }
119
120 #if 0 // allow non-mandatory params
121 if (mCondMaskMap.find(type) == mCondMaskMap.end()) {
122 LOGI_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: result type: 0x%x is not required, skip ",
123 mName.c_str(), type);
124 for (auto cond_it : mCondMaskMap)
125 LOGI_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: -->need type: 0x%x", mName.c_str(), cond_it.first);
126 return ret;
127 }
128 #endif
129 // exception case 1 : wrong result frame_id
130 if (frame_id != (uint32_t)(-1) && (frame_id <= mLatestReadyFrmId)) {
131 // merged to the oldest one
132 bool found = false;
133 for (const auto& iter : mParamsMap) {
134 if (!(iter.second.flags & mCondMaskMap[type])) {
135 frame_id = iter.first;
136 found = true;
137 break;
138 }
139 }
140 if (!found) {
141 if (!mParamsMap.empty())
142 frame_id = (mParamsMap.rbegin())->first + 1;
143 else {
144 // except for initial 3 frame params
145 if ((mLatestReadyFrmId == (uint32_t)(-1)) || (mLatestReadyFrmId < 3)) {
146 frame_id = mLatestReadyFrmId + 1;
147 } else {
148 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: type %s, mLatestReadyFrmId %u, frame_id %u, "
149 "can't find a proper unready params, impossible case, drop it",
150 mName.c_str(), Cam3aResultType2Str[type], mLatestReadyFrmId, frame_id);
151 return ret;
152 }
153 }
154 }
155 LOGI_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: type %s , delayed result_id[%u], merged to %u",
156 mName.c_str(), Cam3aResultType2Str[type], result->getId(), frame_id);
157 result->setId(frame_id);
158 } else if (frame_id != 0 && mLatestReadyFrmId == (uint32_t)(-1)) {
159 LOGW_CAMHW_SUBM(ISP20PARAM_SUBM,
160 "Wrong initial id %u set to 0, last %u", frame_id,
161 mLatestReadyFrmId);
162 frame_id = 0;
163 result->setId(0);
164 } else if (frame_id == (uint32_t)(-1)) {
165 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "type:%s, frame_id == -1 && mLatestReadyFrmId == %d ",
166 Cam3aResultType2Str[type], mLatestReadyFrmId);
167 return ret;
168 }
169
170 mParamsMap[frame_id].params.push_back(result);
171 mParamsMap[frame_id].flags |= mCondMaskMap[type];
172
173 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s, new params: frame: %u, type:%s, flag: 0x%llx",
174 mName.c_str(), frame_id, Cam3aResultType2Str[type], mCondMaskMap[type]);
175
176 bool ready =
177 (mReadyMask == mParamsMap[frame_id].flags) ? true : false;
178
179 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s, frame: %d, flags: 0x%llx, mask: 0x%llx, ready status: %d !",
180 mName.c_str(), frame_id, mParamsMap[frame_id].flags, mReadyMask, ready);
181
182 mParamsMap[frame_id].ready = ready;
183
184 if (ready) {
185 mReadyNums++;
186 if (mLatestReadyFrmId == (uint32_t)(-1) || (frame_id == 0) || (frame_id > mLatestReadyFrmId))
187 mLatestReadyFrmId = frame_id;
188 else {
189 // impossible case
190 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s, wrong ready params, latest %u <= new %u, drop it !",
191 mName.c_str(), mLatestReadyFrmId, frame_id);
192 mParamsMap.erase(mParamsMap.find(frame_id));
193 return ret;
194 }
195 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s, camId:%d, frameId:%d params ready, mReadyNums: %d !",
196 mName.c_str(), mCamPhyId, frame_id, mReadyNums);
197 }
198
199 bool overflow = false;
200 if (mParamsMap.size() > MAX_PENDING_PARAMS) {
201 LOGW_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: pending params overflow, max is %d",
202 mName.c_str(), MAX_PENDING_PARAMS);
203 overflow = true;
204 }
205 bool ready_disorder = false;
206 if (mReadyNums > 0 && !(mParamsMap.begin())->second.ready) {
207 ready_disorder = true;
208 LOGW_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: ready params disordered",
209 mName.c_str());
210 }
211 if (overflow || ready_disorder) {
212 // exception case 2 : current ready one is not the first one in
213 // mParamsMap, this means some conditions frame_id may be NOT
214 // continuous, should check the AIQCORE and isp driver,
215 // so far we merge all disordered to one.
216 std::map<uint32_t, params_t>::iterator it = mParamsMap.begin();
217 cam3aResultList merge_list;
218 uint32_t merge_id = 0;
219 for (it = mParamsMap.begin(); it != mParamsMap.end();) {
220 if (!(it->second.ready)) {
221 LOGW_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: ready disorderd, NOT ready id(flags:0x%llx) %u < ready %u !",
222 mName.c_str(), it->second.flags, it->first, frame_id);
223 // print missing params
224 std::string missing_conds;
225 for (auto cond : mCondMaskMap) {
226 if (!(cond.second & it->second.flags)) {
227 missing_conds.append(Cam3aResultType2Str[cond.first]);
228 missing_conds.append(",");
229 }
230 }
231 if (!missing_conds.empty()) {
232 LOGW_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: [%u] missing conditions: %s !",
233 mName.c_str(), it->first, missing_conds.c_str());
234 }
235 // forced to ready
236 merge_list.insert(merge_list.end(), it->second.params.begin(), it->second.params.end());
237 merge_id = it->first;
238 it = mParamsMap.erase(it);
239 } else
240 break;
241 }
242
243 if (merge_list.size() > 0) {
244 mReadyNums++;
245 if (mLatestReadyFrmId == (uint32_t)(-1) || merge_id > mLatestReadyFrmId)
246 mLatestReadyFrmId = merge_id;
247 mParamsMap[merge_id].params.clear();
248 mParamsMap[merge_id].params.assign(merge_list.begin(), merge_list.end());
249 LOGW_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: merge all pending disorderd to frame %u !",
250 mName.c_str(), merge_id);
251 mParamsMap[merge_id].flags = mReadyMask;
252 mParamsMap[merge_id].ready = true;
253 }
254 }
255
256 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: exit \n",
257 __FUNCTION__, __LINE__, mName.c_str());
258
259 return ret;
260
261 }
262
263 XCamReturn
queue(cam3aResultList & results)264 IspParamsAssembler::queue(cam3aResultList& results)
265 {
266 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: enter \n", __FUNCTION__, __LINE__, mName.c_str());
267
268 XCamReturn ret = XCAM_RETURN_NO_ERROR;
269
270 SmartLock locker (mParamsMutex);
271
272 for (auto result : results)
273 queue_locked(result);
274
275 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: exit \n",
276 __FUNCTION__, __LINE__, mName.c_str());
277
278 return ret;
279 }
280
281 void
forceReady(uint32_t force_frame_id)282 IspParamsAssembler::forceReady(uint32_t force_frame_id)
283 {
284 SmartLock locker (mParamsMutex);
285 uint32_t frame_id = 0;
286
287 for (auto& item : mParamsMap) {
288 frame_id = item.first;
289 if (frame_id < force_frame_id) {
290 if (!mParamsMap[frame_id].ready && 0 != mParamsMap[frame_id].flags) {
291 // print missing params
292 std::string missing_conds;
293 for (auto cond : mCondMaskMap) {
294 if (!(cond.second & mParamsMap[frame_id].flags)) {
295 missing_conds.append(Cam3aResultType2Str[cond.first]);
296 missing_conds.append(",");
297 }
298 }
299 if (!missing_conds.empty()) {
300 LOGW_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: %s: [%u] missing conditions: %s !",
301 mName.c_str(), __func__, frame_id, missing_conds.c_str());
302 }
303 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:%s: [%d] params forced to ready",
304 mName.c_str(), __func__, frame_id);
305 mReadyNums++;
306 if (mLatestReadyFrmId == (uint32_t)(-1) || frame_id > mLatestReadyFrmId)
307 mLatestReadyFrmId = frame_id;
308 mParamsMap[frame_id].flags = mReadyMask;
309 mParamsMap[frame_id].ready = true;
310 } else {
311 LOGW_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:%s: [%d] params is already ready",
312 mName.c_str(), __func__, frame_id);
313 }
314 }
315 }
316 }
317
318 bool
ready()319 IspParamsAssembler::ready()
320 {
321 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: enter \n",
322 __FUNCTION__, __LINE__, mName.c_str());
323 SmartLock locker (mParamsMutex);
324 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: ready params num %d", mName.c_str(), mReadyNums);
325 return mReadyNums > 0 ? true : false;
326 }
327
328 XCamReturn
deQueOne(cam3aResultList & results,uint32_t & frame_id)329 IspParamsAssembler::deQueOne(cam3aResultList& results, uint32_t& frame_id)
330 {
331 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: enter \n",
332 __FUNCTION__, __LINE__, mName.c_str());
333
334 XCamReturn ret = XCAM_RETURN_NO_ERROR;
335
336 SmartLock locker (mParamsMutex);
337 if (mReadyNums > 0) {
338 // get next params id, the first one in map
339 std::map<uint32_t, params_t>::iterator it = mParamsMap.begin();
340
341 if (it == mParamsMap.end()) {
342 LOGI_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: mParamsMap is empty !", mName.c_str());
343 return XCAM_RETURN_ERROR_PARAM;
344 } else {
345 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: deque frame %u params, ready %d",
346 mName.c_str(), it->first, it->second.ready);
347 results = it->second.params;
348 frame_id = it->first;
349 mParamsMap.erase(it);
350 mReadyNums--;
351 }
352 } else {
353 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: no ready params", mName.c_str());
354
355 if (mParamsMap.size() > 0) {
356 std::map<uint32_t, params_t>::reverse_iterator rit = mParamsMap.rbegin();
357
358 if (rit->first - mLatestReadyFrmId != (uint32_t)(-1) && rit->first - mLatestReadyFrmId > 5) {
359 std::map<uint32_t, params_t>::iterator it = mParamsMap.begin();
360 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "not ready params num over 5, force ready: %d", it->first);
361
362 mLatestReadyFrmId = it->first;
363 results = it->second.params;
364 mParamsMap.erase(it);
365 } else {
366 LOGI_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: mParamsMap is %d %d!", mName.c_str(), mParamsMap.size(), __LINE__);
367 return XCAM_RETURN_ERROR_PARAM;
368 }
369 } else {
370 LOGI_CAMHW_SUBM(ISP20PARAM_SUBM, "%s: mParamsMap is empty %d!", mName.c_str(), __LINE__);
371 return XCAM_RETURN_ERROR_PARAM;
372 }
373 }
374 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: exit \n",
375 __FUNCTION__, __LINE__, mName.c_str());
376
377 return ret;
378 }
379
380 void
reset()381 IspParamsAssembler::reset()
382 {
383 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: enter \n",
384 __FUNCTION__, __LINE__, mName.c_str());
385 SmartLock locker (mParamsMutex);
386 reset_locked();
387 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: exit \n",
388 __FUNCTION__, __LINE__, mName.c_str());
389 }
390
391 void
reset_locked()392 IspParamsAssembler::reset_locked()
393 {
394 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: enter \n",
395 __FUNCTION__, __LINE__, mName.c_str());
396 mParamsMap.clear();
397 mLatestReadyFrmId = (uint32_t)(-1);
398 mReadyMask = 0;
399 mReadyNums = 0;
400 mCondNum = 0;
401 mCondMaskMap.clear();
402 mInitParamsList.clear();
403 started = false;
404 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) %s: exit \n",
405 __FUNCTION__, __LINE__, mName.c_str());
406 }
407
408 XCamReturn
start()409 IspParamsAssembler::start()
410 {
411 SmartLock locker (mParamsMutex);
412 if (started)
413 return XCAM_RETURN_NO_ERROR;
414
415 started = true;
416
417 for (auto result : mInitParamsList)
418 queue_locked(result);
419
420 mInitParamsList.clear();
421
422 return XCAM_RETURN_NO_ERROR;
423 }
424
425 void
stop()426 IspParamsAssembler::stop() {
427 SmartLock locker (mParamsMutex);
428 if (!started)
429 return;
430 started = false;
431 reset_locked();
432 }
433 #endif
434
435 template <typename T>
436 struct ConvertAeHelper {
437 template < typename U = T, typename std::enable_if <
438 (std::is_same<U, struct isp2x_isp_params_cfg>::value ||
439 std::is_same<U, struct isp21_isp_params_cfg>::value),
440 bool >::type = true >
copyYuvAeCfgRkCam::ConvertAeHelper441 void copyYuvAeCfg(U& cfg, const rk_aiq_isp_aec_meas_t& aec_meas) {
442 memcpy(&cfg.meas.yuvae, &aec_meas.yuvae, sizeof(aec_meas.yuvae));
443 }
444
445 template < typename U = T,
446 typename std::enable_if < !(std::is_same<U, struct isp2x_isp_params_cfg>::value ||
447 std::is_same<U, struct isp21_isp_params_cfg>::value),
448 bool >::type = false >
copyYuvAeCfgRkCam::ConvertAeHelper449 void copyYuvAeCfg(U& cfg, const rk_aiq_isp_aec_meas_t& aec_meas) {}
450
451 template < typename U = T,
452 typename std::enable_if < (std::is_same<U, struct isp2x_isp_params_cfg>::value ||
453 std::is_same<U, struct isp21_isp_params_cfg>::value),
454 bool >::type = true >
copyAeHistCfgRkCam::ConvertAeHelper455 void copyAeHistCfg(U& cfg, const rk_aiq_isp_hist_meas_t& hist_meas) {
456 memcpy(&cfg.meas.sihst, &hist_meas.sihist, sizeof(hist_meas.sihist));
457 }
458
459 template < typename U = T,
460 typename std::enable_if < !(std::is_same<U, struct isp2x_isp_params_cfg>::value ||
461 std::is_same<U, struct isp21_isp_params_cfg>::value),
462 bool >::type = false >
copyAeHistCfgRkCam::ConvertAeHelper463 void copyAeHistCfg(U& cfg, const rk_aiq_isp_hist_meas_t& hist_meas) {}
464 };
465
466 template <class T>
convertAiqAeToIsp20Params(T & isp_cfg,const rk_aiq_isp_aec_meas_t & aec_meas)467 void Isp20Params::convertAiqAeToIsp20Params(T& isp_cfg, const rk_aiq_isp_aec_meas_t& aec_meas) {
468 /* ae update */
469 if(/*aec_meas.ae_meas_en*/1) {
470 #if 0
471 if(_working_mode == RK_AIQ_WORKING_MODE_NORMAL) { // normal
472 switch(aec_meas.rawae0.rawae_sel) {
473 case 0:
474 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE0_ID;
475 break;
476 case 1:
477 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE1_ID;
478 break;
479 case 2:
480 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE2_ID;
481 break;
482 }
483 } else if(_working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3) { //hdr 2
484 switch(aec_meas.rawae0.rawae_sel) {
485 case 0:
486 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE0_ID;
487 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE1_ID;
488 break;
489 case 1:
490 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE0_ID;
491 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE1_ID;
492 break;
493 case 2:
494 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE1_ID;
495 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE2_ID;
496 break;
497 }
498 } else { // hdr 3
499 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE0_ID;
500 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE1_ID;
501 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE2_ID;
502 }
503 #else
504 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE0_ID;
505 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE1_ID;
506 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE2_ID;
507 #endif
508 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWAE3_ID;
509 isp_cfg.module_ens |= 1LL << RK_ISP2X_YUVAE_ID;
510
511
512 if(/*aec_meas.ae_meas_update*/1) {
513 isp_cfg.module_en_update |= 1LL << RK_ISP2X_RAWAE0_ID;
514 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_RAWAE0_ID;
515
516 isp_cfg.module_en_update |= 1LL << RK_ISP2X_RAWAE1_ID;
517 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_RAWAE1_ID;
518
519 isp_cfg.module_en_update |= 1LL << RK_ISP2X_RAWAE2_ID;
520 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_RAWAE2_ID;
521
522 isp_cfg.module_en_update |= 1LL << RK_ISP2X_RAWAE3_ID;
523 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_RAWAE3_ID;
524
525 isp_cfg.module_en_update |= 1LL << RK_ISP2X_YUVAE_ID;
526 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_YUVAE_ID;
527 } else {
528 return;
529 }
530 } else {
531 return;
532 }
533
534 memcpy(&isp_cfg.meas.rawae3, &aec_meas.rawae3, sizeof(aec_meas.rawae3));
535 memcpy(&isp_cfg.meas.rawae1, &aec_meas.rawae1, sizeof(aec_meas.rawae1));
536 memcpy(&isp_cfg.meas.rawae2, &aec_meas.rawae2, sizeof(aec_meas.rawae2));
537 memcpy(&isp_cfg.meas.rawae0, &aec_meas.rawae0, sizeof(aec_meas.rawae0));
538 #if defined(ISP_HW_V20) || defined(ISP_HW_V21)
539 ConvertAeHelper<T> helper;
540 helper.copyYuvAeCfg(isp_cfg, aec_meas);
541 #endif
542 /*
543 * LOGD_CAMHW_SUBM(ISP20PARAM_SUBM,"xuhf-debug: hist_meas-isp_cfg size: [%dx%d]-[%dx%d]-[%dx%d]-[%dx%d]\n",
544 * sizeof(aec_meas.rawae3),
545 * sizeof(isp_cfg.meas.rawae3),
546 * sizeof(aec_meas.rawae1),
547 * sizeof(isp_cfg.meas.rawae1),
548 * sizeof(aec_meas.rawae2),
549 * sizeof(isp_cfg.meas.rawae2),
550 * sizeof(aec_meas.rawae0),
551 * sizeof(isp_cfg.meas.rawae0));
552 *
553 * LOGD_CAMHW_SUBM(ISP20PARAM_SUBM,"xuhf-debug: aec_meas: win size: [%dx%d]-[%dx%d]-[%dx%d]-[%dx%d]\n",
554 * aec_meas.rawae0.win.h_size,
555 * aec_meas.rawae0.win.v_size,
556 * aec_meas.rawae1.win.h_size,
557 * aec_meas.rawae1.win.v_size,
558 * aec_meas.rawae2.win.h_size,
559 * aec_meas.rawae2.win.v_size,
560 * aec_meas.rawae3.win.h_size,
561 * aec_meas.rawae3.win.v_size);
562 *
563 * LOGD_CAMHW_SUBM(ISP20PARAM_SUBM,"xuhf-debug: isp_cfg: win size: [%dx%d]-[%dx%d]-[%dx%d]-[%dx%d]\n",
564 * isp_cfg.meas.rawae0.win.h_size,
565 * isp_cfg.meas.rawae0.win.v_size,
566 * isp_cfg.meas.rawae1.win.h_size,
567 * isp_cfg.meas.rawae1.win.v_size,
568 * isp_cfg.meas.rawae2.win.h_size,
569 * isp_cfg.meas.rawae2.win.v_size,
570 * isp_cfg.meas.rawae3.win.h_size,
571 * isp_cfg.meas.rawae3.win.v_size);
572 */
573 memcpy(&isp_cfg.meas.rawae3, &aec_meas.rawae3, sizeof(aec_meas.rawae3));
574 memcpy(&isp_cfg.meas.rawae1, &aec_meas.rawae1, sizeof(aec_meas.rawae1));
575 memcpy(&isp_cfg.meas.rawae2, &aec_meas.rawae2, sizeof(aec_meas.rawae2));
576 memcpy(&isp_cfg.meas.rawae0, &aec_meas.rawae0, sizeof(aec_meas.rawae0));
577 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
578 mLatestMeasCfg.rawae3 = isp_cfg.meas.rawae3;
579 mLatestMeasCfg.rawae1 = isp_cfg.meas.rawae1;
580 mLatestMeasCfg.rawae2 = isp_cfg.meas.rawae2;
581 mLatestMeasCfg.rawae0 = isp_cfg.meas.rawae0;
582 #endif
583 }
584
585 template<class T>
586 void
convertAiqHistToIsp20Params(T & isp_cfg,const rk_aiq_isp_hist_meas_t & hist_meas)587 Isp20Params::convertAiqHistToIsp20Params
588 (
589 T& isp_cfg,
590 const rk_aiq_isp_hist_meas_t& hist_meas
591 )
592 {
593 /* hist update */
594 if(/*hist_meas.hist_meas_en*/1) {
595 #if 0
596 if(_working_mode == RK_AIQ_WORKING_MODE_NORMAL) { // normal
597 switch(hist_meas.ae_swap) {
598 case 0:
599 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST0_ID;
600 break;
601 case 1:
602 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST1_ID;
603 break;
604 case 2:
605 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST2_ID;
606
607 break;
608 }
609 } else if(_working_mode < RK_AIQ_WORKING_MODE_ISP_HDR3) { //hdr 2
610 switch(hist_meas.ae_swap) {
611 case 0:
612 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST0_ID;
613 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST1_ID;
614 break;
615 case 1:
616 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST0_ID;
617 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST1_ID;
618 break;
619 case 2:
620 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST1_ID;
621 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST2_ID;
622 break;
623 }
624 } else { // hdr 3
625 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST0_ID;
626 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST1_ID;
627 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST2_ID;
628 }
629 #else
630 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST0_ID;
631 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST1_ID;
632 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST2_ID;
633 #endif
634 isp_cfg.module_ens |= 1LL << RK_ISP2X_RAWHIST3_ID;
635 isp_cfg.module_ens |= 1LL << RK_ISP2X_SIHST_ID;
636
637 if(/*hist_meas.hist_meas_update*/1) {
638 isp_cfg.module_en_update |= 1LL << RK_ISP2X_RAWHIST0_ID;
639 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_RAWHIST0_ID;
640
641 isp_cfg.module_en_update |= 1LL << RK_ISP2X_RAWHIST1_ID;
642 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_RAWHIST1_ID;
643
644 isp_cfg.module_en_update |= 1LL << RK_ISP2X_RAWHIST2_ID;
645 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_RAWHIST2_ID;
646
647 isp_cfg.module_en_update |= 1LL << RK_ISP2X_RAWHIST3_ID;
648 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_RAWHIST3_ID;
649
650 isp_cfg.module_en_update |= 1LL << RK_ISP2X_SIHST_ID;
651 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_SIHST_ID;
652
653 } else {
654 return;
655 }
656 } else {
657 return;
658 }
659
660 memcpy(&isp_cfg.meas.rawhist3, &hist_meas.rawhist3, sizeof(hist_meas.rawhist3));
661 memcpy(&isp_cfg.meas.rawhist1, &hist_meas.rawhist1, sizeof(hist_meas.rawhist1));
662 memcpy(&isp_cfg.meas.rawhist2, &hist_meas.rawhist2, sizeof(hist_meas.rawhist2));
663 memcpy(&isp_cfg.meas.rawhist0, &hist_meas.rawhist0, sizeof(hist_meas.rawhist0));
664 #if defined(ISP_HW_V20) || defined(ISP_HW_V21)
665 ConvertAeHelper<T> helper;
666 helper.copyAeHistCfg(isp_cfg, hist_meas);
667 #endif
668 /*
669 * LOGD_CAMHW_SUBM(ISP20PARAM_SUBM,"xuhf-debug: hist_meas-isp_cfg size: [%dx%d]-[%dx%d]-[%dx%d]-[%dx%d]\n",
670 * sizeof(hist_meas.rawhist3),
671 * sizeof(isp_cfg.meas.rawhist3),
672 * sizeof(hist_meas.rawhist1),
673 * sizeof(isp_cfg.meas.rawhist1),
674 * sizeof(hist_meas.rawhist2),
675 * sizeof(isp_cfg.meas.rawhist2),
676 * sizeof(hist_meas.rawhist0),
677 * sizeof(isp_cfg.meas.rawhist0));
678 *
679 * LOGD_CAMHW_SUBM(ISP20PARAM_SUBM,"xuhf-debug: hist_meas: hist win size: [%dx%d]-[%dx%d]-[%dx%d]-[%dx%d]\n",
680 * hist_meas.rawhist0.win.h_size,
681 * hist_meas.rawhist0.win.v_size,
682 * hist_meas.rawhist1.win.h_size,
683 * hist_meas.rawhist1.win.v_size,
684 * hist_meas.rawhist2.win.h_size,
685 * hist_meas.rawhist2.win.v_size,
686 * hist_meas.rawhist3.win.h_size,
687 * hist_meas.rawhist3.win.v_size);
688 *
689 * LOGD_CAMHW_SUBM(ISP20PARAM_SUBM,"xuhf-debug: isp_cfg: hist win size: [%dx%d]-[%dx%d]-[%dx%d]-[%dx%d]\n",
690 * isp_cfg.meas.rawhist0.win.h_size,
691 * isp_cfg.meas.rawhist0.win.v_size,
692 * isp_cfg.meas.rawhist1.win.h_size,
693 * isp_cfg.meas.rawhist1.win.v_size,
694 * isp_cfg.meas.rawhist2.win.h_size,
695 * isp_cfg.meas.rawhist2.win.v_size,
696 * isp_cfg.meas.rawhist3.win.h_size,
697 * isp_cfg.meas.rawhist3.win.v_size);
698 */
699 #if defined(ISP_HW_V32) || defined(ISP_HW_V32_LITE)
700 mLatestMeasCfg.rawhist3 = isp_cfg.meas.rawhist3;
701 mLatestMeasCfg.rawhist1 = isp_cfg.meas.rawhist1;
702 mLatestMeasCfg.rawhist2 = isp_cfg.meas.rawhist2;
703 mLatestMeasCfg.rawhist0 = isp_cfg.meas.rawhist0;
704 #endif
705 }
706
707 #if RKAIQ_HAVE_AWB_V20
708 template<class T>
709 void
convertAiqAwbToIsp20Params(T & isp_cfg,const rk_aiq_awb_stat_cfg_v200_t & awb_meas,bool awb_cfg_udpate)710 Isp20Params::convertAiqAwbToIsp20Params(T& isp_cfg,
711 const rk_aiq_awb_stat_cfg_v200_t& awb_meas, bool awb_cfg_udpate)
712 {
713 if(awb_cfg_udpate) {
714 if(awb_meas.awbEnable) {
715 isp_cfg.module_ens |= ISP2X_MODULE_RAWAWB;
716 isp_cfg.module_cfg_update |= ISP2X_MODULE_RAWAWB;
717 isp_cfg.module_en_update |= ISP2X_MODULE_RAWAWB;
718 }
719 } else {
720 return;
721 }
722
723 struct isp2x_rawawb_meas_cfg * awb_cfg_v200 = &isp_cfg.meas.rawawb;
724 awb_cfg_v200->rawawb_sel = awb_meas.frameChoose;
725 awb_cfg_v200->sw_rawawb_xy_en = awb_meas.xyDetectionEnable;
726 awb_cfg_v200->sw_rawawb_uv_en = awb_meas.uvDetectionEnable;
727 awb_cfg_v200->sw_rawlsc_bypass_en = awb_meas.lscBypEnable;
728 awb_cfg_v200->sw_rawawb_3dyuv_ls_idx0 = awb_meas.threeDyuvIllu[0];
729 awb_cfg_v200->sw_rawawb_3dyuv_ls_idx1 = awb_meas.threeDyuvIllu[1];
730 awb_cfg_v200->sw_rawawb_3dyuv_ls_idx2 = awb_meas.threeDyuvIllu[2];
731 awb_cfg_v200->sw_rawawb_3dyuv_ls_idx3 = awb_meas.threeDyuvIllu[3];
732 awb_cfg_v200->sw_rawawb_blk_measure_mode = awb_meas.blkMeasureMode;
733 awb_cfg_v200->sw_rawawb_store_wp_th0 = awb_meas.blkMeasWpTh[0];
734 awb_cfg_v200->sw_rawawb_store_wp_th1 = awb_meas.blkMeasWpTh[1];
735 awb_cfg_v200->sw_rawawb_store_wp_th2 = awb_meas.blkMeasWpTh[2];
736
737 awb_cfg_v200->sw_rawawb_light_num = awb_meas.lightNum;
738 awb_cfg_v200->sw_rawawb_h_offs = awb_meas.windowSet[0];
739 awb_cfg_v200->sw_rawawb_v_offs = awb_meas.windowSet[1];
740 awb_cfg_v200->sw_rawawb_h_size = awb_meas.windowSet[2];
741 awb_cfg_v200->sw_rawawb_v_size = awb_meas.windowSet[3];
742 switch(awb_meas.dsMode) {
743 case RK_AIQ_AWB_DS_4X4:
744 awb_cfg_v200->sw_rawawb_wind_size = 0;
745 break;
746 default:
747 awb_cfg_v200->sw_rawawb_wind_size = 1;
748 }
749 awb_cfg_v200->sw_rawawb_r_max = awb_meas.maxR;
750 awb_cfg_v200->sw_rawawb_g_max = awb_meas.maxG;
751 awb_cfg_v200->sw_rawawb_b_max = awb_meas.maxB;
752 awb_cfg_v200->sw_rawawb_y_max = awb_meas.maxY;
753 awb_cfg_v200->sw_rawawb_r_min = awb_meas.minR;
754 awb_cfg_v200->sw_rawawb_g_min = awb_meas.minG;
755 awb_cfg_v200->sw_rawawb_b_min = awb_meas.minB;
756 awb_cfg_v200->sw_rawawb_y_min = awb_meas.minY;
757 awb_cfg_v200->sw_rawawb_c_range = awb_meas.rgb2yuv_c_range;
758 awb_cfg_v200->sw_rawawb_y_range = awb_meas.rgb2yuv_y_range;
759 awb_cfg_v200->sw_rawawb_coeff_y_r = awb_meas.rgb2yuv_matrix[0];
760 awb_cfg_v200->sw_rawawb_coeff_y_g = awb_meas.rgb2yuv_matrix[1];
761 awb_cfg_v200->sw_rawawb_coeff_y_b = awb_meas.rgb2yuv_matrix[2];
762 awb_cfg_v200->sw_rawawb_coeff_u_r = awb_meas.rgb2yuv_matrix[3];
763 awb_cfg_v200->sw_rawawb_coeff_u_g = awb_meas.rgb2yuv_matrix[4];
764 awb_cfg_v200->sw_rawawb_coeff_u_b = awb_meas.rgb2yuv_matrix[5];
765 awb_cfg_v200->sw_rawawb_coeff_v_r = awb_meas.rgb2yuv_matrix[6];
766 awb_cfg_v200->sw_rawawb_coeff_v_g = awb_meas.rgb2yuv_matrix[7];
767 awb_cfg_v200->sw_rawawb_coeff_v_b = awb_meas.rgb2yuv_matrix[8];
768 //uv
769 awb_cfg_v200->sw_rawawb_vertex0_u_0 = awb_meas.uvRange_param[0].pu_region[0];
770 awb_cfg_v200->sw_rawawb_vertex0_v_0 = awb_meas.uvRange_param[0].pv_region[0];
771 awb_cfg_v200->sw_rawawb_vertex1_u_0 = awb_meas.uvRange_param[0].pu_region[1];
772 awb_cfg_v200->sw_rawawb_vertex1_v_0 = awb_meas.uvRange_param[0].pv_region[1];
773 awb_cfg_v200->sw_rawawb_vertex2_u_0 = awb_meas.uvRange_param[0].pu_region[2];
774 awb_cfg_v200->sw_rawawb_vertex2_v_0 = awb_meas.uvRange_param[0].pv_region[2];
775 awb_cfg_v200->sw_rawawb_vertex3_u_0 = awb_meas.uvRange_param[0].pu_region[3];
776 awb_cfg_v200->sw_rawawb_vertex3_v_0 = awb_meas.uvRange_param[0].pv_region[3];
777 awb_cfg_v200->sw_rawawb_islope01_0 = awb_meas.uvRange_param[0].slope_inv[0];
778 awb_cfg_v200->sw_rawawb_islope12_0 = awb_meas.uvRange_param[0].slope_inv[1];
779 awb_cfg_v200->sw_rawawb_islope23_0 = awb_meas.uvRange_param[0].slope_inv[2];
780 awb_cfg_v200->sw_rawawb_islope30_0 = awb_meas.uvRange_param[0].slope_inv[3];
781 awb_cfg_v200->sw_rawawb_vertex0_u_1 = awb_meas.uvRange_param[1].pu_region[0];
782 awb_cfg_v200->sw_rawawb_vertex0_v_1 = awb_meas.uvRange_param[1].pv_region[0];
783 awb_cfg_v200->sw_rawawb_vertex1_u_1 = awb_meas.uvRange_param[1].pu_region[1];
784 awb_cfg_v200->sw_rawawb_vertex1_v_1 = awb_meas.uvRange_param[1].pv_region[1];
785 awb_cfg_v200->sw_rawawb_vertex2_u_1 = awb_meas.uvRange_param[1].pu_region[2];
786 awb_cfg_v200->sw_rawawb_vertex2_v_1 = awb_meas.uvRange_param[1].pv_region[2];
787 awb_cfg_v200->sw_rawawb_vertex3_u_1 = awb_meas.uvRange_param[1].pu_region[3];
788 awb_cfg_v200->sw_rawawb_vertex3_v_1 = awb_meas.uvRange_param[1].pv_region[3];
789 awb_cfg_v200->sw_rawawb_islope01_1 = awb_meas.uvRange_param[1].slope_inv[0];
790 awb_cfg_v200->sw_rawawb_islope12_1 = awb_meas.uvRange_param[1].slope_inv[1];
791 awb_cfg_v200->sw_rawawb_islope23_1 = awb_meas.uvRange_param[1].slope_inv[2];
792 awb_cfg_v200->sw_rawawb_islope30_1 = awb_meas.uvRange_param[1].slope_inv[3];
793 awb_cfg_v200->sw_rawawb_vertex0_u_2 = awb_meas.uvRange_param[2].pu_region[0];
794 awb_cfg_v200->sw_rawawb_vertex0_v_2 = awb_meas.uvRange_param[2].pv_region[0];
795 awb_cfg_v200->sw_rawawb_vertex1_u_2 = awb_meas.uvRange_param[2].pu_region[1];
796 awb_cfg_v200->sw_rawawb_vertex1_v_2 = awb_meas.uvRange_param[2].pv_region[1];
797 awb_cfg_v200->sw_rawawb_vertex2_u_2 = awb_meas.uvRange_param[2].pu_region[2];
798 awb_cfg_v200->sw_rawawb_vertex2_v_2 = awb_meas.uvRange_param[2].pv_region[2];
799 awb_cfg_v200->sw_rawawb_vertex3_u_2 = awb_meas.uvRange_param[2].pu_region[3];
800 awb_cfg_v200->sw_rawawb_vertex3_v_2 = awb_meas.uvRange_param[2].pv_region[3];
801 awb_cfg_v200->sw_rawawb_islope01_2 = awb_meas.uvRange_param[2].slope_inv[0];
802 awb_cfg_v200->sw_rawawb_islope12_2 = awb_meas.uvRange_param[2].slope_inv[1];
803 awb_cfg_v200->sw_rawawb_islope23_2 = awb_meas.uvRange_param[2].slope_inv[2];
804 awb_cfg_v200->sw_rawawb_islope30_2 = awb_meas.uvRange_param[2].slope_inv[3];
805 awb_cfg_v200->sw_rawawb_vertex0_u_3 = awb_meas.uvRange_param[3].pu_region[0];
806 awb_cfg_v200->sw_rawawb_vertex0_v_3 = awb_meas.uvRange_param[3].pv_region[0];
807 awb_cfg_v200->sw_rawawb_vertex1_u_3 = awb_meas.uvRange_param[3].pu_region[1];
808 awb_cfg_v200->sw_rawawb_vertex1_v_3 = awb_meas.uvRange_param[3].pv_region[1];
809 awb_cfg_v200->sw_rawawb_vertex2_u_3 = awb_meas.uvRange_param[3].pu_region[2];
810 awb_cfg_v200->sw_rawawb_vertex2_v_3 = awb_meas.uvRange_param[3].pv_region[2];
811 awb_cfg_v200->sw_rawawb_vertex3_u_3 = awb_meas.uvRange_param[3].pu_region[3];
812 awb_cfg_v200->sw_rawawb_vertex3_v_3 = awb_meas.uvRange_param[3].pv_region[3];
813 awb_cfg_v200->sw_rawawb_islope01_3 = awb_meas.uvRange_param[3].slope_inv[0];
814 awb_cfg_v200->sw_rawawb_islope12_3 = awb_meas.uvRange_param[3].slope_inv[1];
815 awb_cfg_v200->sw_rawawb_islope23_3 = awb_meas.uvRange_param[3].slope_inv[2];
816 awb_cfg_v200->sw_rawawb_islope30_3 = awb_meas.uvRange_param[3].slope_inv[3];
817 awb_cfg_v200->sw_rawawb_vertex0_u_4 = awb_meas.uvRange_param[4].pu_region[0];
818 awb_cfg_v200->sw_rawawb_vertex0_v_4 = awb_meas.uvRange_param[4].pv_region[0];
819 awb_cfg_v200->sw_rawawb_vertex1_u_4 = awb_meas.uvRange_param[4].pu_region[1];
820 awb_cfg_v200->sw_rawawb_vertex1_v_4 = awb_meas.uvRange_param[4].pv_region[1];
821 awb_cfg_v200->sw_rawawb_vertex2_u_4 = awb_meas.uvRange_param[4].pu_region[2];
822 awb_cfg_v200->sw_rawawb_vertex2_v_4 = awb_meas.uvRange_param[4].pv_region[2];
823 awb_cfg_v200->sw_rawawb_vertex3_u_4 = awb_meas.uvRange_param[4].pu_region[3];
824 awb_cfg_v200->sw_rawawb_vertex3_v_4 = awb_meas.uvRange_param[4].pv_region[3];
825 awb_cfg_v200->sw_rawawb_islope01_4 = awb_meas.uvRange_param[4].slope_inv[0];
826 awb_cfg_v200->sw_rawawb_islope12_4 = awb_meas.uvRange_param[4].slope_inv[1];
827 awb_cfg_v200->sw_rawawb_islope23_4 = awb_meas.uvRange_param[4].slope_inv[2];
828 awb_cfg_v200->sw_rawawb_islope30_4 = awb_meas.uvRange_param[4].slope_inv[3];
829 awb_cfg_v200->sw_rawawb_vertex0_u_5 = awb_meas.uvRange_param[5].pu_region[0];
830 awb_cfg_v200->sw_rawawb_vertex0_v_5 = awb_meas.uvRange_param[5].pv_region[0];
831 awb_cfg_v200->sw_rawawb_vertex1_u_5 = awb_meas.uvRange_param[5].pu_region[1];
832 awb_cfg_v200->sw_rawawb_vertex1_v_5 = awb_meas.uvRange_param[5].pv_region[1];
833 awb_cfg_v200->sw_rawawb_vertex2_u_5 = awb_meas.uvRange_param[5].pu_region[2];
834 awb_cfg_v200->sw_rawawb_vertex2_v_5 = awb_meas.uvRange_param[5].pv_region[2];
835 awb_cfg_v200->sw_rawawb_vertex3_u_5 = awb_meas.uvRange_param[5].pu_region[3];
836 awb_cfg_v200->sw_rawawb_vertex3_v_5 = awb_meas.uvRange_param[5].pv_region[3];
837 awb_cfg_v200->sw_rawawb_islope01_5 = awb_meas.uvRange_param[5].slope_inv[0];
838 awb_cfg_v200->sw_rawawb_islope12_5 = awb_meas.uvRange_param[5].slope_inv[1];
839 awb_cfg_v200->sw_rawawb_islope23_5 = awb_meas.uvRange_param[5].slope_inv[2];
840 awb_cfg_v200->sw_rawawb_islope30_5 = awb_meas.uvRange_param[5].slope_inv[3];
841 awb_cfg_v200->sw_rawawb_vertex0_u_6 = awb_meas.uvRange_param[6].pu_region[0];
842 awb_cfg_v200->sw_rawawb_vertex0_v_6 = awb_meas.uvRange_param[6].pv_region[0];
843 awb_cfg_v200->sw_rawawb_vertex1_u_6 = awb_meas.uvRange_param[6].pu_region[1];
844 awb_cfg_v200->sw_rawawb_vertex1_v_6 = awb_meas.uvRange_param[6].pv_region[1];
845 awb_cfg_v200->sw_rawawb_vertex2_u_6 = awb_meas.uvRange_param[6].pu_region[2];
846 awb_cfg_v200->sw_rawawb_vertex2_v_6 = awb_meas.uvRange_param[6].pv_region[2];
847 awb_cfg_v200->sw_rawawb_vertex3_u_6 = awb_meas.uvRange_param[6].pu_region[3];
848 awb_cfg_v200->sw_rawawb_vertex3_v_6 = awb_meas.uvRange_param[6].pv_region[3];
849 awb_cfg_v200->sw_rawawb_islope01_6 = awb_meas.uvRange_param[6].slope_inv[0];
850 awb_cfg_v200->sw_rawawb_islope12_6 = awb_meas.uvRange_param[6].slope_inv[1];
851 awb_cfg_v200->sw_rawawb_islope23_6 = awb_meas.uvRange_param[6].slope_inv[2];
852 awb_cfg_v200->sw_rawawb_islope30_6 = awb_meas.uvRange_param[6].slope_inv[3];
853 //yuv
854 awb_cfg_v200->sw_rawawb_b_uv_0 = awb_meas.yuvRange_param[0].b_uv;
855 awb_cfg_v200->sw_rawawb_slope_ydis_0 = awb_meas.yuvRange_param[0].slope_ydis;
856 awb_cfg_v200->sw_rawawb_b_ydis_0 = awb_meas.yuvRange_param[0].b_ydis;
857 awb_cfg_v200->sw_rawawb_slope_vtcuv_0 = awb_meas.yuvRange_param[0].slope_inv_neg_uv;
858 awb_cfg_v200->sw_rawawb_inv_dslope_0 = awb_meas.yuvRange_param[0].slope_factor_uv;
859 awb_cfg_v200->sw_rawawb_b_uv_1 = awb_meas.yuvRange_param[1].b_uv;
860 awb_cfg_v200->sw_rawawb_slope_ydis_1 = awb_meas.yuvRange_param[1].slope_ydis;
861 awb_cfg_v200->sw_rawawb_b_ydis_1 = awb_meas.yuvRange_param[1].b_ydis;
862 awb_cfg_v200->sw_rawawb_slope_vtcuv_1 = awb_meas.yuvRange_param[1].slope_inv_neg_uv;
863 awb_cfg_v200->sw_rawawb_inv_dslope_1 = awb_meas.yuvRange_param[1].slope_factor_uv;
864 awb_cfg_v200->sw_rawawb_b_uv_2 = awb_meas.yuvRange_param[2].b_uv;
865 awb_cfg_v200->sw_rawawb_slope_ydis_2 = awb_meas.yuvRange_param[2].slope_ydis;
866 awb_cfg_v200->sw_rawawb_b_ydis_2 = awb_meas.yuvRange_param[2].b_ydis;
867 awb_cfg_v200->sw_rawawb_slope_vtcuv_2 = awb_meas.yuvRange_param[2].slope_inv_neg_uv;
868 awb_cfg_v200->sw_rawawb_inv_dslope_2 = awb_meas.yuvRange_param[2].slope_factor_uv;
869 awb_cfg_v200->sw_rawawb_b_uv_3 = awb_meas.yuvRange_param[3].b_uv;
870 awb_cfg_v200->sw_rawawb_slope_ydis_3 = awb_meas.yuvRange_param[3].slope_ydis;
871 awb_cfg_v200->sw_rawawb_b_ydis_3 = awb_meas.yuvRange_param[3].b_ydis;
872 awb_cfg_v200->sw_rawawb_slope_vtcuv_3 = awb_meas.yuvRange_param[3].slope_inv_neg_uv;
873 awb_cfg_v200->sw_rawawb_inv_dslope_3 = awb_meas.yuvRange_param[3].slope_factor_uv;
874 awb_cfg_v200->sw_rawawb_ref_u = awb_meas.yuvRange_param[0].ref_u;
875 awb_cfg_v200->sw_rawawb_ref_v_0 = awb_meas.yuvRange_param[0].ref_v;
876 awb_cfg_v200->sw_rawawb_ref_v_1 = awb_meas.yuvRange_param[1].ref_v;
877 awb_cfg_v200->sw_rawawb_ref_v_2 = awb_meas.yuvRange_param[2].ref_v;
878 awb_cfg_v200->sw_rawawb_ref_v_3 = awb_meas.yuvRange_param[3].ref_v;
879 awb_cfg_v200->sw_rawawb_dis0_0 = awb_meas.yuvRange_param[0].dis[0];
880 awb_cfg_v200->sw_rawawb_dis1_0 = awb_meas.yuvRange_param[0].dis[1];
881 awb_cfg_v200->sw_rawawb_dis2_0 = awb_meas.yuvRange_param[0].dis[2];
882 awb_cfg_v200->sw_rawawb_dis3_0 = awb_meas.yuvRange_param[0].dis[3];
883 awb_cfg_v200->sw_rawawb_dis4_0 = awb_meas.yuvRange_param[0].dis[4];
884 awb_cfg_v200->sw_rawawb_dis5_0 = awb_meas.yuvRange_param[0].dis[5];
885 awb_cfg_v200->sw_rawawb_th0_0 = awb_meas.yuvRange_param[0].th[0];
886 awb_cfg_v200->sw_rawawb_th1_0 = awb_meas.yuvRange_param[0].th[1];
887 awb_cfg_v200->sw_rawawb_th2_0 = awb_meas.yuvRange_param[0].th[2];
888 awb_cfg_v200->sw_rawawb_th3_0 = awb_meas.yuvRange_param[0].th[3];
889 awb_cfg_v200->sw_rawawb_th4_0 = awb_meas.yuvRange_param[0].th[4];
890 awb_cfg_v200->sw_rawawb_th5_0 = awb_meas.yuvRange_param[0].th[5];
891 awb_cfg_v200->sw_rawawb_dis0_1 = awb_meas.yuvRange_param[1].dis[0];
892 awb_cfg_v200->sw_rawawb_dis1_1 = awb_meas.yuvRange_param[1].dis[1];
893 awb_cfg_v200->sw_rawawb_dis2_1 = awb_meas.yuvRange_param[1].dis[2];
894 awb_cfg_v200->sw_rawawb_dis3_1 = awb_meas.yuvRange_param[1].dis[3];
895 awb_cfg_v200->sw_rawawb_dis4_1 = awb_meas.yuvRange_param[1].dis[4];
896 awb_cfg_v200->sw_rawawb_dis5_1 = awb_meas.yuvRange_param[1].dis[5];
897 awb_cfg_v200->sw_rawawb_th0_1 = awb_meas.yuvRange_param[1].th[0];
898 awb_cfg_v200->sw_rawawb_th1_1 = awb_meas.yuvRange_param[1].th[1];
899 awb_cfg_v200->sw_rawawb_th2_1 = awb_meas.yuvRange_param[1].th[2];
900 awb_cfg_v200->sw_rawawb_th3_1 = awb_meas.yuvRange_param[1].th[3];
901 awb_cfg_v200->sw_rawawb_th4_1 = awb_meas.yuvRange_param[1].th[4];
902 awb_cfg_v200->sw_rawawb_th5_1 = awb_meas.yuvRange_param[1].th[5];
903 awb_cfg_v200->sw_rawawb_dis0_2 = awb_meas.yuvRange_param[2].dis[0];
904 awb_cfg_v200->sw_rawawb_dis1_2 = awb_meas.yuvRange_param[2].dis[1];
905 awb_cfg_v200->sw_rawawb_dis2_2 = awb_meas.yuvRange_param[2].dis[2];
906 awb_cfg_v200->sw_rawawb_dis3_2 = awb_meas.yuvRange_param[2].dis[3];
907 awb_cfg_v200->sw_rawawb_dis4_2 = awb_meas.yuvRange_param[2].dis[4];
908 awb_cfg_v200->sw_rawawb_dis5_2 = awb_meas.yuvRange_param[2].dis[5];
909 awb_cfg_v200->sw_rawawb_th0_2 = awb_meas.yuvRange_param[2].th[0];
910 awb_cfg_v200->sw_rawawb_th1_2 = awb_meas.yuvRange_param[2].th[1];
911 awb_cfg_v200->sw_rawawb_th2_2 = awb_meas.yuvRange_param[2].th[2];
912 awb_cfg_v200->sw_rawawb_th3_2 = awb_meas.yuvRange_param[2].th[3];
913 awb_cfg_v200->sw_rawawb_th4_2 = awb_meas.yuvRange_param[2].th[4];
914 awb_cfg_v200->sw_rawawb_th5_2 = awb_meas.yuvRange_param[2].th[5];
915 awb_cfg_v200->sw_rawawb_dis0_3 = awb_meas.yuvRange_param[3].dis[0];
916 awb_cfg_v200->sw_rawawb_dis1_3 = awb_meas.yuvRange_param[3].dis[1];
917 awb_cfg_v200->sw_rawawb_dis2_3 = awb_meas.yuvRange_param[3].dis[2];
918 awb_cfg_v200->sw_rawawb_dis3_3 = awb_meas.yuvRange_param[3].dis[3];
919 awb_cfg_v200->sw_rawawb_dis4_3 = awb_meas.yuvRange_param[3].dis[4];
920 awb_cfg_v200->sw_rawawb_dis5_3 = awb_meas.yuvRange_param[3].dis[5];
921 awb_cfg_v200->sw_rawawb_th0_3 = awb_meas.yuvRange_param[3].th[0];
922 awb_cfg_v200->sw_rawawb_th1_3 = awb_meas.yuvRange_param[3].th[1];
923 awb_cfg_v200->sw_rawawb_th2_3 = awb_meas.yuvRange_param[3].th[2];
924 awb_cfg_v200->sw_rawawb_th3_3 = awb_meas.yuvRange_param[3].th[3];
925 awb_cfg_v200->sw_rawawb_th4_3 = awb_meas.yuvRange_param[3].th[4];
926 awb_cfg_v200->sw_rawawb_th5_3 = awb_meas.yuvRange_param[3].th[5];
927 //xy
928 awb_cfg_v200->sw_rawawb_wt0 = awb_meas.rgb2xy_param.pseudoLuminanceWeight[0];
929 awb_cfg_v200->sw_rawawb_wt1 = awb_meas.rgb2xy_param.pseudoLuminanceWeight[1];
930 awb_cfg_v200->sw_rawawb_wt2 = awb_meas.rgb2xy_param.pseudoLuminanceWeight[2];
931 awb_cfg_v200->sw_rawawb_mat0_x = awb_meas.rgb2xy_param.rotationMat[0];
932 awb_cfg_v200->sw_rawawb_mat1_x = awb_meas.rgb2xy_param.rotationMat[1];
933 awb_cfg_v200->sw_rawawb_mat2_x = awb_meas.rgb2xy_param.rotationMat[2];
934 awb_cfg_v200->sw_rawawb_mat0_y = awb_meas.rgb2xy_param.rotationMat[3];
935 awb_cfg_v200->sw_rawawb_mat1_y = awb_meas.rgb2xy_param.rotationMat[4];
936 awb_cfg_v200->sw_rawawb_mat2_y = awb_meas.rgb2xy_param.rotationMat[5];
937 awb_cfg_v200->sw_rawawb_nor_x0_0 = awb_meas.xyRange_param[0].NorrangeX[0];
938 awb_cfg_v200->sw_rawawb_nor_x1_0 = awb_meas.xyRange_param[0].NorrangeX[1];
939 awb_cfg_v200->sw_rawawb_nor_y0_0 = awb_meas.xyRange_param[0].NorrangeY[0];
940 awb_cfg_v200->sw_rawawb_nor_y1_0 = awb_meas.xyRange_param[0].NorrangeY[1];
941 awb_cfg_v200->sw_rawawb_big_x0_0 = awb_meas.xyRange_param[0].SperangeX[0];
942 awb_cfg_v200->sw_rawawb_big_x1_0 = awb_meas.xyRange_param[0].SperangeX[1];
943 awb_cfg_v200->sw_rawawb_big_y0_0 = awb_meas.xyRange_param[0].SperangeY[0];
944 awb_cfg_v200->sw_rawawb_big_y1_0 = awb_meas.xyRange_param[0].SperangeY[1];
945 awb_cfg_v200->sw_rawawb_sma_x0_0 = awb_meas.xyRange_param[0].SmalrangeX[0];
946 awb_cfg_v200->sw_rawawb_sma_x1_0 = awb_meas.xyRange_param[0].SmalrangeX[1];
947 awb_cfg_v200->sw_rawawb_sma_y0_0 = awb_meas.xyRange_param[0].SmalrangeY[0];
948 awb_cfg_v200->sw_rawawb_sma_y1_0 = awb_meas.xyRange_param[0].SmalrangeY[1];
949 awb_cfg_v200->sw_rawawb_nor_x0_1 = awb_meas.xyRange_param[1].NorrangeX[0];
950 awb_cfg_v200->sw_rawawb_nor_x1_1 = awb_meas.xyRange_param[1].NorrangeX[1];
951 awb_cfg_v200->sw_rawawb_nor_y0_1 = awb_meas.xyRange_param[1].NorrangeY[0];
952 awb_cfg_v200->sw_rawawb_nor_y1_1 = awb_meas.xyRange_param[1].NorrangeY[1];
953 awb_cfg_v200->sw_rawawb_big_x0_1 = awb_meas.xyRange_param[1].SperangeX[0];
954 awb_cfg_v200->sw_rawawb_big_x1_1 = awb_meas.xyRange_param[1].SperangeX[1];
955 awb_cfg_v200->sw_rawawb_big_y0_1 = awb_meas.xyRange_param[1].SperangeY[0];
956 awb_cfg_v200->sw_rawawb_big_y1_1 = awb_meas.xyRange_param[1].SperangeY[1];
957 awb_cfg_v200->sw_rawawb_sma_x0_1 = awb_meas.xyRange_param[1].SmalrangeX[0];
958 awb_cfg_v200->sw_rawawb_sma_x1_1 = awb_meas.xyRange_param[1].SmalrangeX[1];
959 awb_cfg_v200->sw_rawawb_sma_y0_1 = awb_meas.xyRange_param[1].SmalrangeY[0];
960 awb_cfg_v200->sw_rawawb_sma_y1_1 = awb_meas.xyRange_param[1].SmalrangeY[1];
961 awb_cfg_v200->sw_rawawb_nor_x0_2 = awb_meas.xyRange_param[2].NorrangeX[0];
962 awb_cfg_v200->sw_rawawb_nor_x1_2 = awb_meas.xyRange_param[2].NorrangeX[1];
963 awb_cfg_v200->sw_rawawb_nor_y0_2 = awb_meas.xyRange_param[2].NorrangeY[0];
964 awb_cfg_v200->sw_rawawb_nor_y1_2 = awb_meas.xyRange_param[2].NorrangeY[1];
965 awb_cfg_v200->sw_rawawb_big_x0_2 = awb_meas.xyRange_param[2].SperangeX[0];
966 awb_cfg_v200->sw_rawawb_big_x1_2 = awb_meas.xyRange_param[2].SperangeX[1];
967 awb_cfg_v200->sw_rawawb_big_y0_2 = awb_meas.xyRange_param[2].SperangeY[0];
968 awb_cfg_v200->sw_rawawb_big_y1_2 = awb_meas.xyRange_param[2].SperangeY[1];
969 awb_cfg_v200->sw_rawawb_sma_x0_2 = awb_meas.xyRange_param[2].SmalrangeX[0];
970 awb_cfg_v200->sw_rawawb_sma_x1_2 = awb_meas.xyRange_param[2].SmalrangeX[1];
971 awb_cfg_v200->sw_rawawb_sma_y0_2 = awb_meas.xyRange_param[2].SmalrangeY[0];
972 awb_cfg_v200->sw_rawawb_sma_y1_2 = awb_meas.xyRange_param[2].SmalrangeY[1];
973 awb_cfg_v200->sw_rawawb_nor_x0_3 = awb_meas.xyRange_param[3].NorrangeX[0];
974 awb_cfg_v200->sw_rawawb_nor_x1_3 = awb_meas.xyRange_param[3].NorrangeX[1];
975 awb_cfg_v200->sw_rawawb_nor_y0_3 = awb_meas.xyRange_param[3].NorrangeY[0];
976 awb_cfg_v200->sw_rawawb_nor_y1_3 = awb_meas.xyRange_param[3].NorrangeY[1];
977 awb_cfg_v200->sw_rawawb_big_x0_3 = awb_meas.xyRange_param[3].SperangeX[0];
978 awb_cfg_v200->sw_rawawb_big_x1_3 = awb_meas.xyRange_param[3].SperangeX[1];
979 awb_cfg_v200->sw_rawawb_big_y0_3 = awb_meas.xyRange_param[3].SperangeY[0];
980 awb_cfg_v200->sw_rawawb_big_y1_3 = awb_meas.xyRange_param[3].SperangeY[1];
981 awb_cfg_v200->sw_rawawb_sma_x0_3 = awb_meas.xyRange_param[3].SmalrangeX[0];
982 awb_cfg_v200->sw_rawawb_sma_x1_3 = awb_meas.xyRange_param[3].SmalrangeX[1];
983 awb_cfg_v200->sw_rawawb_sma_y0_3 = awb_meas.xyRange_param[3].SmalrangeY[0];
984 awb_cfg_v200->sw_rawawb_sma_y1_3 = awb_meas.xyRange_param[3].SmalrangeY[1];
985 awb_cfg_v200->sw_rawawb_nor_x0_4 = awb_meas.xyRange_param[4].NorrangeX[0];
986 awb_cfg_v200->sw_rawawb_nor_x1_4 = awb_meas.xyRange_param[4].NorrangeX[1];
987 awb_cfg_v200->sw_rawawb_nor_y0_4 = awb_meas.xyRange_param[4].NorrangeY[0];
988 awb_cfg_v200->sw_rawawb_nor_y1_4 = awb_meas.xyRange_param[4].NorrangeY[1];
989 awb_cfg_v200->sw_rawawb_big_x0_4 = awb_meas.xyRange_param[4].SperangeX[0];
990 awb_cfg_v200->sw_rawawb_big_x1_4 = awb_meas.xyRange_param[4].SperangeX[1];
991 awb_cfg_v200->sw_rawawb_big_y0_4 = awb_meas.xyRange_param[4].SperangeY[0];
992 awb_cfg_v200->sw_rawawb_big_y1_4 = awb_meas.xyRange_param[4].SperangeY[1];
993 awb_cfg_v200->sw_rawawb_sma_x0_4 = awb_meas.xyRange_param[4].SmalrangeX[0];
994 awb_cfg_v200->sw_rawawb_sma_x1_4 = awb_meas.xyRange_param[4].SmalrangeX[1];
995 awb_cfg_v200->sw_rawawb_sma_y0_4 = awb_meas.xyRange_param[4].SmalrangeY[0];
996 awb_cfg_v200->sw_rawawb_sma_y1_4 = awb_meas.xyRange_param[4].SmalrangeY[1];
997 awb_cfg_v200->sw_rawawb_nor_x0_5 = awb_meas.xyRange_param[5].NorrangeX[0];
998 awb_cfg_v200->sw_rawawb_nor_x1_5 = awb_meas.xyRange_param[5].NorrangeX[1];
999 awb_cfg_v200->sw_rawawb_nor_y0_5 = awb_meas.xyRange_param[5].NorrangeY[0];
1000 awb_cfg_v200->sw_rawawb_nor_y1_5 = awb_meas.xyRange_param[5].NorrangeY[1];
1001 awb_cfg_v200->sw_rawawb_big_x0_5 = awb_meas.xyRange_param[5].SperangeX[0];
1002 awb_cfg_v200->sw_rawawb_big_x1_5 = awb_meas.xyRange_param[5].SperangeX[1];
1003 awb_cfg_v200->sw_rawawb_big_y0_5 = awb_meas.xyRange_param[5].SperangeY[0];
1004 awb_cfg_v200->sw_rawawb_big_y1_5 = awb_meas.xyRange_param[5].SperangeY[1];
1005 awb_cfg_v200->sw_rawawb_sma_x0_5 = awb_meas.xyRange_param[5].SmalrangeX[0];
1006 awb_cfg_v200->sw_rawawb_sma_x1_5 = awb_meas.xyRange_param[5].SmalrangeX[1];
1007 awb_cfg_v200->sw_rawawb_sma_y0_5 = awb_meas.xyRange_param[5].SmalrangeY[0];
1008 awb_cfg_v200->sw_rawawb_sma_y1_5 = awb_meas.xyRange_param[5].SmalrangeY[1];
1009 awb_cfg_v200->sw_rawawb_nor_x0_6 = awb_meas.xyRange_param[6].NorrangeX[0];
1010 awb_cfg_v200->sw_rawawb_nor_x1_6 = awb_meas.xyRange_param[6].NorrangeX[1];
1011 awb_cfg_v200->sw_rawawb_nor_y0_6 = awb_meas.xyRange_param[6].NorrangeY[0];
1012 awb_cfg_v200->sw_rawawb_nor_y1_6 = awb_meas.xyRange_param[6].NorrangeY[1];
1013 awb_cfg_v200->sw_rawawb_big_x0_6 = awb_meas.xyRange_param[6].SperangeX[0];
1014 awb_cfg_v200->sw_rawawb_big_x1_6 = awb_meas.xyRange_param[6].SperangeX[1];
1015 awb_cfg_v200->sw_rawawb_big_y0_6 = awb_meas.xyRange_param[6].SperangeY[0];
1016 awb_cfg_v200->sw_rawawb_big_y1_6 = awb_meas.xyRange_param[6].SperangeY[1];
1017 awb_cfg_v200->sw_rawawb_sma_x0_6 = awb_meas.xyRange_param[6].SmalrangeX[0];
1018 awb_cfg_v200->sw_rawawb_sma_x1_6 = awb_meas.xyRange_param[6].SmalrangeX[1];
1019 awb_cfg_v200->sw_rawawb_sma_y0_6 = awb_meas.xyRange_param[6].SmalrangeY[0];
1020 awb_cfg_v200->sw_rawawb_sma_y1_6 = awb_meas.xyRange_param[6].SmalrangeY[1];
1021 //multiwindow
1022 awb_cfg_v200->sw_rawawb_multiwindow_en = awb_meas.multiwindow_en;
1023 awb_cfg_v200->sw_rawawb_multiwindow0_h_offs = awb_meas.multiwindow[0][0];
1024 awb_cfg_v200->sw_rawawb_multiwindow0_v_offs = awb_meas.multiwindow[0][1];
1025 awb_cfg_v200->sw_rawawb_multiwindow0_h_size = awb_meas.multiwindow[0][2];
1026 awb_cfg_v200->sw_rawawb_multiwindow0_v_size = awb_meas.multiwindow[0][3];
1027 awb_cfg_v200->sw_rawawb_multiwindow1_h_offs = awb_meas.multiwindow[1][0];
1028 awb_cfg_v200->sw_rawawb_multiwindow1_v_offs = awb_meas.multiwindow[1][1];
1029 awb_cfg_v200->sw_rawawb_multiwindow1_h_size = awb_meas.multiwindow[1][2];
1030 awb_cfg_v200->sw_rawawb_multiwindow1_v_size = awb_meas.multiwindow[1][3];
1031 awb_cfg_v200->sw_rawawb_multiwindow2_h_offs = awb_meas.multiwindow[2][0];
1032 awb_cfg_v200->sw_rawawb_multiwindow2_v_offs = awb_meas.multiwindow[2][1];
1033 awb_cfg_v200->sw_rawawb_multiwindow2_h_size = awb_meas.multiwindow[2][2];
1034 awb_cfg_v200->sw_rawawb_multiwindow2_v_size = awb_meas.multiwindow[2][3];
1035 awb_cfg_v200->sw_rawawb_multiwindow3_h_offs = awb_meas.multiwindow[3][0];
1036 awb_cfg_v200->sw_rawawb_multiwindow3_v_offs = awb_meas.multiwindow[3][1];
1037 awb_cfg_v200->sw_rawawb_multiwindow3_h_size = awb_meas.multiwindow[3][2];
1038 awb_cfg_v200->sw_rawawb_multiwindow3_v_size = awb_meas.multiwindow[3][3];
1039 awb_cfg_v200->sw_rawawb_multiwindow4_h_offs = awb_meas.multiwindow[4][0];
1040 awb_cfg_v200->sw_rawawb_multiwindow4_v_offs = awb_meas.multiwindow[4][1];
1041 awb_cfg_v200->sw_rawawb_multiwindow4_h_size = awb_meas.multiwindow[4][2];
1042 awb_cfg_v200->sw_rawawb_multiwindow4_v_size = awb_meas.multiwindow[4][3];
1043 awb_cfg_v200->sw_rawawb_multiwindow5_h_offs = awb_meas.multiwindow[5][0];
1044 awb_cfg_v200->sw_rawawb_multiwindow5_v_offs = awb_meas.multiwindow[5][1];
1045 awb_cfg_v200->sw_rawawb_multiwindow5_h_size = awb_meas.multiwindow[5][2];
1046 awb_cfg_v200->sw_rawawb_multiwindow5_v_size = awb_meas.multiwindow[5][3];
1047 awb_cfg_v200->sw_rawawb_multiwindow6_h_offs = awb_meas.multiwindow[6][0];
1048 awb_cfg_v200->sw_rawawb_multiwindow6_v_offs = awb_meas.multiwindow[6][1];
1049 awb_cfg_v200->sw_rawawb_multiwindow6_h_size = awb_meas.multiwindow[6][2];
1050 awb_cfg_v200->sw_rawawb_multiwindow6_v_size = awb_meas.multiwindow[6][3];
1051 awb_cfg_v200->sw_rawawb_multiwindow7_h_offs = awb_meas.multiwindow[7][0];
1052 awb_cfg_v200->sw_rawawb_multiwindow7_v_offs = awb_meas.multiwindow[7][1];
1053 awb_cfg_v200->sw_rawawb_multiwindow7_h_size = awb_meas.multiwindow[7][2];
1054 awb_cfg_v200->sw_rawawb_multiwindow7_v_size = awb_meas.multiwindow[7][3];
1055 //exc range
1056
1057 awb_cfg_v200->sw_rawawb_exc_wp_region0_excen = awb_meas.excludeWpRange[0].excludeEnable;
1058 awb_cfg_v200->sw_rawawb_exc_wp_region0_measen = awb_meas.excludeWpRange[0].measureEnable;
1059 switch(awb_meas.excludeWpRange[0].domain) {
1060 case RK_AIQ_AWB_EXC_RANGE_DOMAIN_UV:
1061 awb_cfg_v200->sw_rawawb_exc_wp_region0_domain = 0;
1062 break;
1063 default:
1064 awb_cfg_v200->sw_rawawb_exc_wp_region0_domain = 1;
1065 }
1066 awb_cfg_v200->sw_rawawb_exc_wp_region0_xu0 = awb_meas.excludeWpRange[0].xu[0];
1067 awb_cfg_v200->sw_rawawb_exc_wp_region0_xu1 = awb_meas.excludeWpRange[0].xu[1];
1068 awb_cfg_v200->sw_rawawb_exc_wp_region0_yv0 = awb_meas.excludeWpRange[0].yv[0];
1069 awb_cfg_v200->sw_rawawb_exc_wp_region0_yv1 = awb_meas.excludeWpRange[0].yv[1];
1070 awb_cfg_v200->sw_rawawb_exc_wp_region1_excen = awb_meas.excludeWpRange[1].excludeEnable;
1071 awb_cfg_v200->sw_rawawb_exc_wp_region1_measen = awb_meas.excludeWpRange[1].measureEnable;
1072 awb_cfg_v200->sw_rawawb_exc_wp_region1_domain = awb_meas.excludeWpRange[1].domain;
1073 switch(awb_meas.excludeWpRange[1].domain) {
1074 case RK_AIQ_AWB_EXC_RANGE_DOMAIN_UV:
1075 awb_cfg_v200->sw_rawawb_exc_wp_region1_domain = 0;
1076 break;
1077 default:
1078 awb_cfg_v200->sw_rawawb_exc_wp_region1_domain = 1;
1079 }
1080 awb_cfg_v200->sw_rawawb_exc_wp_region1_xu0 = awb_meas.excludeWpRange[1].xu[0];
1081 awb_cfg_v200->sw_rawawb_exc_wp_region1_xu1 = awb_meas.excludeWpRange[1].xu[1];
1082 awb_cfg_v200->sw_rawawb_exc_wp_region1_yv0 = awb_meas.excludeWpRange[1].yv[0];
1083 awb_cfg_v200->sw_rawawb_exc_wp_region1_yv1 = awb_meas.excludeWpRange[1].yv[1];
1084 awb_cfg_v200->sw_rawawb_exc_wp_region2_excen = awb_meas.excludeWpRange[2].excludeEnable;
1085 awb_cfg_v200->sw_rawawb_exc_wp_region2_measen = awb_meas.excludeWpRange[2].measureEnable;
1086 switch(awb_meas.excludeWpRange[2].domain) {
1087 case RK_AIQ_AWB_EXC_RANGE_DOMAIN_UV:
1088 awb_cfg_v200->sw_rawawb_exc_wp_region2_domain = 0;
1089 break;
1090 default:
1091 awb_cfg_v200->sw_rawawb_exc_wp_region2_domain = 1;
1092 }
1093 awb_cfg_v200->sw_rawawb_exc_wp_region2_xu0 = awb_meas.excludeWpRange[2].xu[0];
1094 awb_cfg_v200->sw_rawawb_exc_wp_region2_xu1 = awb_meas.excludeWpRange[2].xu[1];
1095 awb_cfg_v200->sw_rawawb_exc_wp_region2_yv0 = awb_meas.excludeWpRange[2].yv[0];
1096 awb_cfg_v200->sw_rawawb_exc_wp_region2_yv1 = awb_meas.excludeWpRange[2].yv[1];
1097 awb_cfg_v200->sw_rawawb_exc_wp_region3_excen = awb_meas.excludeWpRange[3].excludeEnable;
1098 awb_cfg_v200->sw_rawawb_exc_wp_region3_measen = awb_meas.excludeWpRange[3].measureEnable;
1099 awb_cfg_v200->sw_rawawb_exc_wp_region3_domain = awb_meas.excludeWpRange[3].domain;
1100 switch(awb_meas.excludeWpRange[3].domain) {
1101 case RK_AIQ_AWB_EXC_RANGE_DOMAIN_UV:
1102 awb_cfg_v200->sw_rawawb_exc_wp_region3_domain = 0;
1103 break;
1104 default:
1105 awb_cfg_v200->sw_rawawb_exc_wp_region3_domain = 1;
1106 }
1107 awb_cfg_v200->sw_rawawb_exc_wp_region3_xu0 = awb_meas.excludeWpRange[3].xu[0];
1108 awb_cfg_v200->sw_rawawb_exc_wp_region3_xu1 = awb_meas.excludeWpRange[3].xu[1];
1109 awb_cfg_v200->sw_rawawb_exc_wp_region3_yv0 = awb_meas.excludeWpRange[3].yv[0];
1110 awb_cfg_v200->sw_rawawb_exc_wp_region3_yv1 = awb_meas.excludeWpRange[3].yv[1];
1111 awb_cfg_v200->sw_rawawb_exc_wp_region4_excen = awb_meas.excludeWpRange[4].excludeEnable;
1112 awb_cfg_v200->sw_rawawb_exc_wp_region4_measen = awb_meas.excludeWpRange[4].measureEnable;
1113 switch(awb_meas.excludeWpRange[4].domain) {
1114 case RK_AIQ_AWB_EXC_RANGE_DOMAIN_UV:
1115 awb_cfg_v200->sw_rawawb_exc_wp_region4_domain = 0;
1116 break;
1117 default:
1118 awb_cfg_v200->sw_rawawb_exc_wp_region4_domain = 1;
1119 }
1120 awb_cfg_v200->sw_rawawb_exc_wp_region4_xu0 = awb_meas.excludeWpRange[4].xu[0];
1121 awb_cfg_v200->sw_rawawb_exc_wp_region4_xu1 = awb_meas.excludeWpRange[4].xu[1];
1122 awb_cfg_v200->sw_rawawb_exc_wp_region4_yv0 = awb_meas.excludeWpRange[4].yv[0];
1123 awb_cfg_v200->sw_rawawb_exc_wp_region4_yv1 = awb_meas.excludeWpRange[4].yv[1];
1124 awb_cfg_v200->sw_rawawb_exc_wp_region5_excen = awb_meas.excludeWpRange[5].excludeEnable;
1125 awb_cfg_v200->sw_rawawb_exc_wp_region5_measen = awb_meas.excludeWpRange[5].measureEnable;
1126 switch(awb_meas.excludeWpRange[5].domain) {
1127 case RK_AIQ_AWB_EXC_RANGE_DOMAIN_UV:
1128 awb_cfg_v200->sw_rawawb_exc_wp_region5_domain = 0;
1129 break;
1130 default:
1131 awb_cfg_v200->sw_rawawb_exc_wp_region5_domain = 1;
1132 }
1133 awb_cfg_v200->sw_rawawb_exc_wp_region5_xu0 = awb_meas.excludeWpRange[5].xu[0];
1134 awb_cfg_v200->sw_rawawb_exc_wp_region5_xu1 = awb_meas.excludeWpRange[5].xu[1];
1135 awb_cfg_v200->sw_rawawb_exc_wp_region5_yv0 = awb_meas.excludeWpRange[5].yv[0];
1136 awb_cfg_v200->sw_rawawb_exc_wp_region5_yv1 = awb_meas.excludeWpRange[5].yv[1];
1137 awb_cfg_v200->sw_rawawb_exc_wp_region6_excen = awb_meas.excludeWpRange[6].excludeEnable;
1138 awb_cfg_v200->sw_rawawb_exc_wp_region6_measen = awb_meas.excludeWpRange[6].measureEnable;
1139 switch(awb_meas.excludeWpRange[6].domain) {
1140 case RK_AIQ_AWB_EXC_RANGE_DOMAIN_UV:
1141 awb_cfg_v200->sw_rawawb_exc_wp_region6_domain = 0;
1142 break;
1143 default:
1144 awb_cfg_v200->sw_rawawb_exc_wp_region6_domain = 1;
1145 }
1146 awb_cfg_v200->sw_rawawb_exc_wp_region6_xu0 = awb_meas.excludeWpRange[6].xu[0];
1147 awb_cfg_v200->sw_rawawb_exc_wp_region6_xu1 = awb_meas.excludeWpRange[6].xu[1];
1148 awb_cfg_v200->sw_rawawb_exc_wp_region6_yv0 = awb_meas.excludeWpRange[6].yv[0];
1149 awb_cfg_v200->sw_rawawb_exc_wp_region6_yv1 = awb_meas.excludeWpRange[6].yv[1];
1150
1151 awb_cfg_v200->sw_rawawb_store_wp_flag_ls_idx0 = awb_meas.storeWpFlagIllu[0];
1152 awb_cfg_v200->sw_rawawb_store_wp_flag_ls_idx1 = awb_meas.storeWpFlagIllu[1];
1153 awb_cfg_v200->sw_rawawb_store_wp_flag_ls_idx2 = awb_meas.storeWpFlagIllu[2];
1154 }
1155 #endif
1156 #if RKAIQ_HAVE_MERGE_V10
1157 template<class T>
convertAiqMergeToIsp20Params(T & isp_cfg,const rk_aiq_isp_merge_t & amerge_data)1158 void Isp20Params::convertAiqMergeToIsp20Params(T& isp_cfg,
1159 const rk_aiq_isp_merge_t& amerge_data)
1160 {
1161 isp_cfg.module_en_update |= 1LL << RK_ISP2X_HDRMGE_ID;
1162 isp_cfg.module_ens |= 1LL << RK_ISP2X_HDRMGE_ID;
1163 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_HDRMGE_ID;
1164
1165 isp_cfg.others.hdrmge_cfg.mode = amerge_data.Merge_v10.sw_hdrmge_mode;
1166 isp_cfg.others.hdrmge_cfg.gain0_inv = amerge_data.Merge_v10.sw_hdrmge_gain0_inv;
1167 isp_cfg.others.hdrmge_cfg.gain0 = amerge_data.Merge_v10.sw_hdrmge_gain0;
1168 isp_cfg.others.hdrmge_cfg.gain1_inv = amerge_data.Merge_v10.sw_hdrmge_gain1_inv;
1169 isp_cfg.others.hdrmge_cfg.gain1 = amerge_data.Merge_v10.sw_hdrmge_gain1;
1170 isp_cfg.others.hdrmge_cfg.gain2 = amerge_data.Merge_v10.sw_hdrmge_gain2;
1171 isp_cfg.others.hdrmge_cfg.lm_dif_0p15 = amerge_data.Merge_v10.sw_hdrmge_lm_dif_0p15;
1172 isp_cfg.others.hdrmge_cfg.lm_dif_0p9 = amerge_data.Merge_v10.sw_hdrmge_lm_dif_0p9;
1173 isp_cfg.others.hdrmge_cfg.ms_diff_0p15 = amerge_data.Merge_v10.sw_hdrmge_ms_dif_0p15;
1174 isp_cfg.others.hdrmge_cfg.ms_dif_0p8 = amerge_data.Merge_v10.sw_hdrmge_ms_dif_0p8;
1175 for(int i = 0; i < ISP2X_HDRMGE_L_CURVE_NUM; i++) {
1176 isp_cfg.others.hdrmge_cfg.curve.curve_0[i] = amerge_data.Merge_v10.sw_hdrmge_l0_y[i];
1177 isp_cfg.others.hdrmge_cfg.curve.curve_1[i] = amerge_data.Merge_v10.sw_hdrmge_l1_y[i];
1178 }
1179 for(int i = 0; i < ISP2X_HDRMGE_E_CURVE_NUM; i++)
1180 isp_cfg.others.hdrmge_cfg.e_y[i] = amerge_data.Merge_v10.sw_hdrmge_e_y[i];
1181
1182 #if 0
1183 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: gain0_inv %d", __LINE__, isp_cfg.others.hdrmge_cfg.gain0_inv);
1184 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: gain0 %d", __LINE__, isp_cfg.others.hdrmge_cfg.gain0);
1185 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: gain1_inv %d", __LINE__, isp_cfg.others.hdrmge_cfg.gain1_inv);
1186 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: gain1 %d", __LINE__, isp_cfg.others.hdrmge_cfg.gain1);
1187 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: gain2 %d", __LINE__, isp_cfg.others.hdrmge_cfg.gain2);
1188 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: lm_dif_0p15 %d", __LINE__, isp_cfg.others.hdrmge_cfg.lm_dif_0p15);
1189 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: lm_dif_0p9 %d", __LINE__, isp_cfg.others.hdrmge_cfg.lm_dif_0p9);
1190 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: ms_diff_0p15 %d", __LINE__, isp_cfg.others.hdrmge_cfg.ms_diff_0p15);
1191 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: ms_dif_0p8 %d", __LINE__, isp_cfg.others.hdrmge_cfg.ms_dif_0p8);
1192 for(int i = 0 ; i < 17; i++)
1193 {
1194 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: curve_0[%d] %d", __LINE__, i, isp_cfg.others.hdrmge_cfg.curve.curve_0[i]);
1195 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: curve_1[%d] %d", __LINE__, i, isp_cfg.others.hdrmge_cfg.curve.curve_1[i]);
1196 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: e_y[%d] %d", __LINE__, i, isp_cfg.others.hdrmge_cfg.e_y[i]);
1197 }
1198
1199 #endif
1200 }
1201 #endif
1202
1203 template<class T>
convertAiqTmoToIsp20Params(T & isp_cfg,const rk_aiq_isp_tmo_t & atmo_data)1204 void Isp20Params::convertAiqTmoToIsp20Params(T& isp_cfg,
1205 const rk_aiq_isp_tmo_t& atmo_data)
1206 {
1207 if(atmo_data.bTmoEn)
1208 {
1209 isp_cfg.module_en_update |= 1LL << RK_ISP2X_HDRTMO_ID;
1210 isp_cfg.module_ens |= 1LL << RK_ISP2X_HDRTMO_ID;
1211 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_HDRTMO_ID;
1212 }
1213 else
1214 {
1215 isp_cfg.module_en_update |= 1LL << RK_ISP2X_HDRTMO_ID;
1216 isp_cfg.module_ens &= ~(1LL << RK_ISP2X_HDRTMO_ID);
1217 isp_cfg.module_cfg_update &= ~(1LL << RK_ISP2X_HDRTMO_ID);
1218 }
1219
1220 isp_cfg.others.hdrtmo_cfg.cnt_vsize = atmo_data.Res.sw_hdrtmo_cnt_vsize;
1221 isp_cfg.others.hdrtmo_cfg.gain_ld_off2 = atmo_data.Res.sw_hdrtmo_gain_ld_off2;
1222 isp_cfg.others.hdrtmo_cfg.gain_ld_off1 = atmo_data.Res.sw_hdrtmo_gain_ld_off1;
1223 isp_cfg.others.hdrtmo_cfg.big_en = atmo_data.Res.sw_hdrtmo_big_en;
1224 isp_cfg.others.hdrtmo_cfg.nobig_en = atmo_data.Res.sw_hdrtmo_nobig_en;
1225 isp_cfg.others.hdrtmo_cfg.newhst_en = atmo_data.Res.sw_hdrtmo_newhist_en;
1226 isp_cfg.others.hdrtmo_cfg.cnt_mode = atmo_data.Res.sw_hdrtmo_cnt_mode;
1227 isp_cfg.others.hdrtmo_cfg.expl_lgratio = atmo_data.Res.sw_hdrtmo_expl_lgratio;
1228 isp_cfg.others.hdrtmo_cfg.lgscl_ratio = atmo_data.Res.sw_hdrtmo_lgscl_ratio;
1229 isp_cfg.others.hdrtmo_cfg.cfg_alpha = atmo_data.Res.sw_hdrtmo_cfg_alpha;
1230 isp_cfg.others.hdrtmo_cfg.set_gainoff = atmo_data.Res.sw_hdrtmo_set_gainoff;
1231 isp_cfg.others.hdrtmo_cfg.set_palpha = atmo_data.Res.sw_hdrtmo_set_palpha;
1232 isp_cfg.others.hdrtmo_cfg.set_lgmax = atmo_data.Res.sw_hdrtmo_set_lgmax;
1233 isp_cfg.others.hdrtmo_cfg.set_lgmin = atmo_data.Res.sw_hdrtmo_set_lgmin;
1234 isp_cfg.others.hdrtmo_cfg.set_weightkey = atmo_data.Res.sw_hdrtmo_set_weightkey;
1235 isp_cfg.others.hdrtmo_cfg.set_lgmean = atmo_data.Res.sw_hdrtmo_set_lgmean;
1236 isp_cfg.others.hdrtmo_cfg.set_lgrange1 = atmo_data.Res.sw_hdrtmo_set_lgrange1;
1237 isp_cfg.others.hdrtmo_cfg.set_lgrange0 = atmo_data.Res.sw_hdrtmo_set_lgrange0;
1238 isp_cfg.others.hdrtmo_cfg.set_lgavgmax = atmo_data.Res.sw_hdrtmo_set_lgavgmax;
1239 isp_cfg.others.hdrtmo_cfg.clipgap1_i = atmo_data.Res.sw_hdrtmo_clipgap1;
1240 isp_cfg.others.hdrtmo_cfg.clipgap0_i = atmo_data.Res.sw_hdrtmo_clipgap0;
1241 isp_cfg.others.hdrtmo_cfg.clipratio1 = atmo_data.Res.sw_hdrtmo_clipratio1;
1242 isp_cfg.others.hdrtmo_cfg.clipratio0 = atmo_data.Res.sw_hdrtmo_clipratio0;
1243 isp_cfg.others.hdrtmo_cfg.ratiol = atmo_data.Res.sw_hdrtmo_ratiol;
1244 isp_cfg.others.hdrtmo_cfg.lgscl_inv = atmo_data.Res.sw_hdrtmo_lgscl_inv;
1245 isp_cfg.others.hdrtmo_cfg.lgscl = atmo_data.Res.sw_hdrtmo_lgscl;
1246 isp_cfg.others.hdrtmo_cfg.lgmax = atmo_data.Res.sw_hdrtmo_lgmax;
1247 isp_cfg.others.hdrtmo_cfg.hist_low = atmo_data.Res.sw_hdrtmo_hist_low;
1248 isp_cfg.others.hdrtmo_cfg.hist_min = atmo_data.Res.sw_hdrtmo_hist_min;
1249 isp_cfg.others.hdrtmo_cfg.hist_shift = atmo_data.Res.sw_hdrtmo_hist_shift;
1250 isp_cfg.others.hdrtmo_cfg.hist_0p3 = atmo_data.Res.sw_hdrtmo_hist_0p3;
1251 isp_cfg.others.hdrtmo_cfg.hist_high = atmo_data.Res.sw_hdrtmo_hist_high;
1252 isp_cfg.others.hdrtmo_cfg.palpha_lwscl = atmo_data.Res.sw_hdrtmo_palpha_lwscl;
1253 isp_cfg.others.hdrtmo_cfg.palpha_lw0p5 = atmo_data.Res.sw_hdrtmo_palpha_lw0p5;
1254 isp_cfg.others.hdrtmo_cfg.palpha_0p18 = atmo_data.Res.sw_hdrtmo_palpha_0p18;
1255 isp_cfg.others.hdrtmo_cfg.maxgain = atmo_data.Res.sw_hdrtmo_maxgain;
1256 isp_cfg.others.hdrtmo_cfg.maxpalpha = atmo_data.Res.sw_hdrtmo_maxpalpha;
1257
1258 //tmo predict
1259 isp_cfg.others.hdrtmo_cfg.predict.global_tmo = atmo_data.isHdrGlobalTmo;
1260 isp_cfg.others.hdrtmo_cfg.predict.scene_stable = atmo_data.Predict.Scenestable;
1261 isp_cfg.others.hdrtmo_cfg.predict.k_rolgmean = atmo_data.Predict.K_Rolgmean;
1262 isp_cfg.others.hdrtmo_cfg.predict.iir = atmo_data.Predict.iir;
1263 isp_cfg.others.hdrtmo_cfg.predict.iir_max = atmo_data.Predict.iir_max;
1264 isp_cfg.others.hdrtmo_cfg.predict.global_tmo_strength = atmo_data.Predict.global_tmo_strength;
1265 #if 0
1266 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: cnt_vsize %d", __LINE__, isp_cfg.others.hdrtmo_cfg.cnt_vsize);
1267 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: gain_ld_off2 %d", __LINE__, isp_cfg.others.hdrtmo_cfg.gain_ld_off2);
1268 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: gain_ld_off1 %d", __LINE__, isp_cfg.others.hdrtmo_cfg.gain_ld_off1);
1269 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: big_en %d", __LINE__, isp_cfg.others.hdrtmo_cfg.big_en);
1270 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: nobig_en %d", __LINE__, isp_cfg.others.hdrtmo_cfg.nobig_en);
1271 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: newhst_en %d", __LINE__, isp_cfg.others.hdrtmo_cfg.newhst_en);
1272 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: cnt_mode %d", __LINE__, isp_cfg.others.hdrtmo_cfg.cnt_mode);
1273 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: expl_lgratio %d", __LINE__, isp_cfg.others.hdrtmo_cfg.expl_lgratio);
1274 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: lgscl_ratio %d", __LINE__, isp_cfg.others.hdrtmo_cfg.lgscl_ratio);
1275 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: cfg_alpha %d", __LINE__, isp_cfg.others.hdrtmo_cfg.cfg_alpha);
1276 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: set_gainoff %d", __LINE__, isp_cfg.others.hdrtmo_cfg.set_gainoff);
1277 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: set_palpha %d", __LINE__, isp_cfg.others.hdrtmo_cfg.set_palpha);
1278 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: set_lgmax %d", __LINE__, isp_cfg.others.hdrtmo_cfg.set_lgmax);
1279 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: set_lgmin %d", __LINE__, isp_cfg.others.hdrtmo_cfg.set_lgmin);
1280 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: set_weightkey %d", __LINE__, isp_cfg.others.hdrtmo_cfg.set_weightkey);
1281 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: set_lgmean %d", __LINE__, isp_cfg.others.hdrtmo_cfg.set_lgmean);
1282 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: set_lgrange1 %d", __LINE__, isp_cfg.others.hdrtmo_cfg.set_lgrange1);
1283 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: set_lgrange0 %d", __LINE__, isp_cfg.others.hdrtmo_cfg.set_lgrange0);
1284 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: set_lgavgmax %d", __LINE__, isp_cfg.others.hdrtmo_cfg.set_lgavgmax);
1285 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: clipgap1_i %d", __LINE__, isp_cfg.others.hdrtmo_cfg.clipgap1_i);
1286 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: clipgap0_i %d", __LINE__, isp_cfg.others.hdrtmo_cfg.clipgap0_i);
1287 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: clipratio1 %d", __LINE__, isp_cfg.others.hdrtmo_cfg.clipratio1);
1288 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: clipratio0 %d", __LINE__, isp_cfg.others.hdrtmo_cfg.clipratio0);
1289 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: ratiol %d", __LINE__, isp_cfg.others.hdrtmo_cfg.ratiol);
1290 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: lgscl_inv %d", __LINE__, isp_cfg.others.hdrtmo_cfg.lgscl_inv);
1291 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: lgscl %d", __LINE__, isp_cfg.others.hdrtmo_cfg.lgscl);
1292 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: lgmax %d", __LINE__, isp_cfg.others.hdrtmo_cfg.lgmax);
1293 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: hist_low %d", __LINE__, isp_cfg.others.hdrtmo_cfg.hist_low);
1294 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: hist_min %d", __LINE__, isp_cfg.others.hdrtmo_cfg.hist_min);
1295 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: hist_shift %d", __LINE__, isp_cfg.others.hdrtmo_cfg.hist_shift);
1296 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: hist_0p3 %d", __LINE__, isp_cfg.others.hdrtmo_cfg.hist_0p3);
1297 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: hist_high %d", __LINE__, isp_cfg.others.hdrtmo_cfg.hist_high);
1298 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: palpha_lwscl %d", __LINE__, isp_cfg.others.hdrtmo_cfg.palpha_lwscl);
1299 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: palpha_lw0p5 %d", __LINE__, isp_cfg.others.hdrtmo_cfg.palpha_lw0p5);
1300 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: palpha_0p18 %d", __LINE__, isp_cfg.others.hdrtmo_cfg.palpha_0p18);
1301 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: maxgain %d", __LINE__, isp_cfg.others.hdrtmo_cfg.maxgain);
1302 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%d: maxpalpha %d", __LINE__, isp_cfg.others.hdrtmo_cfg.maxpalpha);
1303 #endif
1304 }
1305
1306 #if RKAIQ_HAVE_AF_V20 || RKAIQ_ONLY_AF_STATS_V20
1307 template<class T>
1308 void
convertAiqAfToIsp20Params(T & isp_cfg,const rk_aiq_isp_af_meas_t & af_data,bool af_cfg_udpate)1309 Isp20Params::convertAiqAfToIsp20Params(T& isp_cfg,
1310 const rk_aiq_isp_af_meas_t& af_data, bool af_cfg_udpate)
1311 {
1312 if (!af_cfg_udpate)
1313 return;
1314
1315 if (af_data.contrast_af_en)
1316 isp_cfg.module_ens |= ISP2X_MODULE_RAWAF;
1317 isp_cfg.module_en_update |= ISP2X_MODULE_RAWAF;
1318 isp_cfg.module_cfg_update |= ISP2X_MODULE_RAWAF;
1319 isp_cfg.meas.rawaf.rawaf_sel = af_data.rawaf_sel;
1320 isp_cfg.meas.rawaf.gamma_en = af_data.gamma_flt_en;
1321 isp_cfg.meas.rawaf.gaus_en = af_data.gaus_flt_en;
1322 isp_cfg.meas.rawaf.afm_thres = af_data.afm_thres;
1323 isp_cfg.meas.rawaf.gaus_coe_h0 = af_data.gaus_h0;
1324 isp_cfg.meas.rawaf.gaus_coe_h1 = af_data.gaus_h1;
1325 isp_cfg.meas.rawaf.gaus_coe_h2 = af_data.gaus_h2;
1326 memcpy(isp_cfg.meas.rawaf.lum_var_shift,
1327 af_data.lum_var_shift, ISP2X_RAWAF_WIN_NUM * sizeof(unsigned char));
1328 memcpy(isp_cfg.meas.rawaf.afm_var_shift,
1329 af_data.afm_var_shift, ISP2X_RAWAF_WIN_NUM * sizeof(unsigned char));
1330 memcpy(isp_cfg.meas.rawaf.line_en,
1331 af_data.line_en, ISP2X_RAWAF_LINE_NUM * sizeof(unsigned char));
1332 memcpy(isp_cfg.meas.rawaf.line_num,
1333 af_data.line_num, ISP2X_RAWAF_LINE_NUM * sizeof(unsigned char));
1334 memcpy(isp_cfg.meas.rawaf.gamma_y,
1335 af_data.gamma_y, ISP2X_RAWAF_GAMMA_NUM * sizeof(unsigned short));
1336
1337 isp_cfg.meas.rawaf.num_afm_win = af_data.window_num;
1338 isp_cfg.meas.rawaf.win[0].h_offs = af_data.wina_h_offs;
1339 isp_cfg.meas.rawaf.win[0].v_offs = af_data.wina_v_offs;
1340 isp_cfg.meas.rawaf.win[0].h_size = af_data.wina_h_size;
1341 isp_cfg.meas.rawaf.win[0].v_size = af_data.wina_v_size;
1342 isp_cfg.meas.rawaf.win[1].h_offs = af_data.winb_h_offs;
1343 isp_cfg.meas.rawaf.win[1].v_offs = af_data.winb_v_offs;
1344 isp_cfg.meas.rawaf.win[1].h_size = af_data.winb_h_size;
1345 isp_cfg.meas.rawaf.win[1].v_size = af_data.winb_v_size;
1346 }
1347 #endif
1348
1349 #define ISP2X_WBGAIN_FIXSCALE_BIT 8
1350 #define ISP2X_BLC_BIT_MAX 12
1351
1352 template<class T>
1353 void
convertAiqAwbGainToIsp20Params(T & isp_cfg,const rk_aiq_wb_gain_t & awb_gain,const rk_aiq_isp_blc_t & blc,bool awb_gain_update)1354 Isp20Params::convertAiqAwbGainToIsp20Params(T& isp_cfg,
1355 const rk_aiq_wb_gain_t& awb_gain, const rk_aiq_isp_blc_t &blc, bool awb_gain_update)
1356 {
1357
1358 if(awb_gain_update) {
1359 isp_cfg.module_ens |= 1LL << RK_ISP2X_AWB_GAIN_ID;
1360 isp_cfg.module_cfg_update |= 1LL << RK_ISP2X_AWB_GAIN_ID;
1361 isp_cfg.module_en_update |= 1LL << RK_ISP2X_AWB_GAIN_ID;
1362 } else {
1363 return;
1364 }
1365
1366 struct isp2x_awb_gain_cfg * cfg = &isp_cfg.others.awb_gain_cfg;
1367 uint16_t max_wb_gain = (1 << (ISP2X_WBGAIN_FIXSCALE_BIT + 2)) - 1;
1368 rk_aiq_wb_gain_t awb_gain1 = awb_gain;
1369 if(blc.enable) {
1370 awb_gain1.bgain *= (float)((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - blc.blc_b);
1371 awb_gain1.gbgain *= (float)((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - blc.blc_gb);
1372 awb_gain1.rgain *= (float)((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - blc.blc_r);
1373 awb_gain1.grgain *= (float)((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - blc.blc_gr);
1374 }
1375 // rescale
1376 float max_value = awb_gain1.bgain > awb_gain1.gbgain ? awb_gain1.bgain : awb_gain1.gbgain;
1377 max_value = max_value > awb_gain1.rgain ? max_value : awb_gain1.rgain;
1378 float max_wb_gain_f = (float)max_wb_gain / (1 << (ISP2X_WBGAIN_FIXSCALE_BIT));
1379 if (max_value > max_wb_gain_f ) {
1380 float scale = max_value / max_wb_gain_f;
1381 awb_gain1.bgain /= scale;
1382 awb_gain1.gbgain /= scale;
1383 awb_gain1.grgain /= scale;
1384 awb_gain1.rgain /= scale;
1385 LOGD_CAMHW("%s: scale %f, awbgain(r,g,g,b):[%f,%f,%f,%f]", __FUNCTION__, scale, awb_gain1.rgain, awb_gain1.grgain, awb_gain1.gbgain, awb_gain1.bgain);
1386 }
1387 //fix point
1388 //LOGE_CAMHW_SUBM(ISP20PARAM_SUBM,"max_wb_gain:%d\n",max_wb_gain);
1389 uint16_t R = (uint16_t)(0.5 + awb_gain1.rgain * (1 << ISP2X_WBGAIN_FIXSCALE_BIT));
1390 uint16_t B = (uint16_t)(0.5 + awb_gain1.bgain * (1 << ISP2X_WBGAIN_FIXSCALE_BIT));
1391 uint16_t Gr = (uint16_t)(0.5 + awb_gain1.grgain * (1 << ISP2X_WBGAIN_FIXSCALE_BIT));
1392 uint16_t Gb = (uint16_t)(0.5 + awb_gain1.gbgain * (1 << ISP2X_WBGAIN_FIXSCALE_BIT));
1393 cfg->gain_red = R > max_wb_gain ? max_wb_gain : R;
1394 cfg->gain_blue = B > max_wb_gain ? max_wb_gain : B;
1395 cfg->gain_green_r = Gr > max_wb_gain ? max_wb_gain : Gr ;
1396 cfg->gain_green_b = Gb > max_wb_gain ? max_wb_gain : Gb;
1397 }
1398
1399 #if RKAIQ_HAVE_GAMMA_V10
1400 template<class T>
convertAiqAgammaToIsp20Params(T & isp_cfg,const AgammaProcRes_t & gamma_out_cfg)1401 void Isp20Params::convertAiqAgammaToIsp20Params(T& isp_cfg,
1402 const AgammaProcRes_t& gamma_out_cfg)
1403 {
1404 if (gamma_out_cfg.Gamma_v10.gamma_en) {
1405 isp_cfg.module_ens |= ISP2X_MODULE_GOC;
1406 isp_cfg.module_en_update |= ISP2X_MODULE_GOC;
1407 isp_cfg.module_cfg_update |= ISP2X_MODULE_GOC;
1408 } else {
1409 isp_cfg.module_ens &= ~ISP2X_MODULE_GOC;
1410 isp_cfg.module_en_update |= ISP2X_MODULE_GOC;
1411 return;
1412 }
1413
1414 struct isp2x_gammaout_cfg* cfg = &isp_cfg.others.gammaout_cfg;
1415 cfg->offset = gamma_out_cfg.Gamma_v10.offset;
1416 cfg->equ_segm = gamma_out_cfg.Gamma_v10.equ_segm;
1417 for (int i = 0; i < 45; i++) cfg->gamma_y[i] = gamma_out_cfg.Gamma_v10.gamma_y[i];
1418
1419 #if 0
1420 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) gamma en:%d, offset:%d, equ_segm:%d\n", __FUNCTION__, __LINE__, gamma_out_cfg.Gamma_v10.gamma_en, cfg->offset, cfg->equ_segm);
1421 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "Gamma_Y:%d %d %d %d %d %d %d %d\n", cfg->gamma_y[0], cfg->gamma_y[1],
1422 cfg->gamma_y[2], cfg->gamma_y[3], cfg->gamma_y[4], cfg->gamma_y[5], cfg->gamma_y[6], cfg->gamma_y[7]);
1423 #endif
1424 }
1425 #endif
1426
1427 template<class T>
convertAiqAdegammaToIsp20Params(T & isp_cfg,const AdegammaProcRes_t & degamma_cfg)1428 void Isp20Params::convertAiqAdegammaToIsp20Params(T& isp_cfg,
1429 const AdegammaProcRes_t& degamma_cfg)
1430 {
1431 if(degamma_cfg.degamma_en) {
1432 isp_cfg.module_ens |= ISP2X_MODULE_SDG;
1433 isp_cfg.module_en_update |= ISP2X_MODULE_SDG;
1434 isp_cfg.module_cfg_update |= ISP2X_MODULE_SDG;
1435 } else {
1436 isp_cfg.module_ens &= ~ISP2X_MODULE_SDG;
1437 isp_cfg.module_en_update |= ISP2X_MODULE_SDG;
1438 return;
1439 }
1440
1441 struct isp2x_sdg_cfg* cfg = &isp_cfg.others.sdg_cfg;
1442 cfg->xa_pnts.gamma_dx0 = degamma_cfg.degamma_X_d0;
1443 cfg->xa_pnts.gamma_dx1 = degamma_cfg.degamma_X_d1;
1444 for (int i = 0; i < 17; i++) {
1445 cfg->curve_r.gamma_y[i] = degamma_cfg.degamma_tableR[i];
1446 cfg->curve_g.gamma_y[i] = degamma_cfg.degamma_tableG[i];
1447 cfg->curve_b.gamma_y[i] = degamma_cfg.degamma_tableB[i];
1448 }
1449
1450 #if 0
1451 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) DEGAMMA_DX0:%d DEGAMMA_DX0:%d\n", __FUNCTION__, __LINE__, cfg->xa_pnts.gamma_dx0, cfg->xa_pnts.gamma_dx1);
1452 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "DEGAMMA_R_Y:%d %d %d %d %d %d %d %d\n", cfg->curve_r.gamma_y[0], cfg->curve_r.gamma_y[1],
1453 cfg->curve_r.gamma_y[2], cfg->curve_r.gamma_y[3], cfg->curve_r.gamma_y[4], cfg->curve_r.gamma_y[5], cfg->curve_r.gamma_y[6], cfg->curve_r.gamma_y[7]);
1454 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "DEGAMMA_G_Y:%d %d %d %d %d %d %d %d\n", cfg->curve_g.gamma_y[0], cfg->curve_g.gamma_y[1],
1455 cfg->curve_g.gamma_y[2], cfg->curve_g.gamma_y[3], cfg->curve_g.gamma_y[4], cfg->curve_g.gamma_y[5], cfg->curve_g.gamma_y[6], cfg->curve_g.gamma_y[7]);
1456 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "DEGAMMA_B_Y:%d %d %d %d %d %d %d %d\n", cfg->curve_b.gamma_y[0], cfg->curve_b.gamma_y[1],
1457 cfg->curve_b.gamma_y[2], cfg->curve_b.gamma_y[3], cfg->curve_b.gamma_y[4], cfg->curve_b.gamma_y[5], cfg->curve_b.gamma_y[6], cfg->curve_b.gamma_y[7]);
1458 #endif
1459
1460 }
1461
1462 #if RKAIQ_HAVE_DEHAZE_V10
1463 template<class T>
convertAiqAdehazeToIsp20Params(T & isp_cfg,const rk_aiq_isp_dehaze_t & dhaze)1464 void Isp20Params::convertAiqAdehazeToIsp20Params(T& isp_cfg,
1465 const rk_aiq_isp_dehaze_t& dhaze )
1466 {
1467 int i;
1468
1469 int rawWidth = 1920;
1470 int rawHeight = 1080;
1471
1472 if (dhaze.ProcResV10.enable) {
1473 isp_cfg.module_ens |= ISP2X_MODULE_DHAZ;
1474 isp_cfg.module_en_update |= ISP2X_MODULE_DHAZ;
1475 isp_cfg.module_cfg_update |= ISP2X_MODULE_DHAZ;
1476 }
1477 struct isp2x_dhaz_cfg * cfg = &isp_cfg.others.dhaz_cfg;
1478
1479 cfg->enhance_en = dhaze.ProcResV10.enhance_en;
1480 cfg->hist_chn = dhaze.ProcResV10.hist_chn;
1481 cfg->hpara_en = dhaze.ProcResV10.hpara_en;
1482 cfg->hist_en = dhaze.ProcResV10.hist_en;
1483 cfg->dc_en = dhaze.ProcResV10.dc_en;
1484 cfg->big_en = dhaze.ProcResV10.big_en;
1485 cfg->nobig_en = dhaze.ProcResV10.nobig_en;
1486 cfg->yblk_th = dhaze.ProcResV10.yblk_th;
1487 cfg->yhist_th = dhaze.ProcResV10.yhist_th;
1488 cfg->dc_max_th = dhaze.ProcResV10.dc_max_th;
1489 cfg->dc_min_th = dhaze.ProcResV10.dc_min_th;
1490 cfg->wt_max = dhaze.ProcResV10.wt_max;
1491 cfg->bright_max = dhaze.ProcResV10.bright_max;
1492 cfg->bright_min = dhaze.ProcResV10.bright_min;
1493 cfg->tmax_base = dhaze.ProcResV10.tmax_base;
1494 cfg->dark_th = dhaze.ProcResV10.dark_th;
1495 cfg->air_max = dhaze.ProcResV10.air_max;
1496 cfg->air_min = dhaze.ProcResV10.air_min;
1497 cfg->tmax_max = dhaze.ProcResV10.tmax_max;
1498 cfg->tmax_off = dhaze.ProcResV10.tmax_off;
1499 cfg->hist_k = dhaze.ProcResV10.hist_k;
1500 cfg->hist_th_off = dhaze.ProcResV10.hist_th_off;
1501 cfg->hist_min = dhaze.ProcResV10.hist_min;
1502 cfg->hist_gratio = dhaze.ProcResV10.hist_gratio;
1503 cfg->hist_scale = dhaze.ProcResV10.hist_scale;
1504 cfg->enhance_value = dhaze.ProcResV10.enhance_value;
1505 cfg->iir_wt_sigma = dhaze.ProcResV10.iir_wt_sigma;
1506 cfg->iir_sigma = dhaze.ProcResV10.iir_sigma;
1507 cfg->stab_fnum = dhaze.ProcResV10.stab_fnum;
1508 cfg->iir_tmax_sigma = dhaze.ProcResV10.iir_tmax_sigma;
1509 cfg->iir_air_sigma = dhaze.ProcResV10.iir_air_sigma;
1510 cfg->cfg_wt = dhaze.ProcResV10.cfg_wt;
1511 cfg->cfg_air = dhaze.ProcResV10.cfg_air;
1512 cfg->cfg_alpha = dhaze.ProcResV10.cfg_alpha;
1513 cfg->cfg_gratio = dhaze.ProcResV10.cfg_gratio;
1514 cfg->cfg_tmax = dhaze.ProcResV10.cfg_tmax;
1515 cfg->dc_weitcur = dhaze.ProcResV10.dc_weitcur;
1516 cfg->dc_thed = dhaze.ProcResV10.dc_thed;
1517 cfg->sw_dhaz_dc_bf_h0 = dhaze.ProcResV10.sw_dhaz_dc_bf_h0;
1518 cfg->sw_dhaz_dc_bf_h1 = dhaze.ProcResV10.sw_dhaz_dc_bf_h1;
1519 cfg->sw_dhaz_dc_bf_h2 = dhaze.ProcResV10.sw_dhaz_dc_bf_h2;
1520 cfg->sw_dhaz_dc_bf_h3 = dhaze.ProcResV10.sw_dhaz_dc_bf_h3;
1521 cfg->sw_dhaz_dc_bf_h4 = dhaze.ProcResV10.sw_dhaz_dc_bf_h4;
1522 cfg->sw_dhaz_dc_bf_h5 = dhaze.ProcResV10.sw_dhaz_dc_bf_h5;
1523 cfg->air_weitcur = dhaze.ProcResV10.air_weitcur;
1524 cfg->air_thed = dhaze.ProcResV10.air_thed;
1525 cfg->air_bf_h0 = dhaze.ProcResV10.air_bf_h0;
1526 cfg->air_bf_h1 = dhaze.ProcResV10.air_bf_h1;
1527 cfg->air_bf_h2 = dhaze.ProcResV10.air_bf_h2;
1528 cfg->gaus_h0 = dhaze.ProcResV10.gaus_h0;
1529 cfg->gaus_h1 = dhaze.ProcResV10.gaus_h1;
1530 cfg->gaus_h2 = dhaze.ProcResV10.gaus_h2;
1531
1532 for(int i = 0; i < ISP2X_DHAZ_CONV_COEFF_NUM; i++) {
1533 cfg->conv_t0[i] = dhaze.ProcResV10.conv_t0[i];
1534 cfg->conv_t1[i] = dhaze.ProcResV10.conv_t1[i];
1535 cfg->conv_t2[i] = dhaze.ProcResV10.conv_t2[i];
1536 }
1537
1538 #if 0
1539 // cfg->dehaze_en = int(dhaze.ProcResV10.dehaze_en[0]); //0~1 , (1bit) dehaze_en
1540 cfg->dc_en = int(dhaze.ProcResV10.dehaze_en[1]); //0~1 , (1bit) dc_en
1541 cfg->hist_en = int(dhaze.ProcResV10.dehaze_en[2]); //0~1 , (1bit) hist_en
1542 cfg->hist_chn = int(dhaze.ProcResV10.dehaze_en[3]); //0~1 , (1bit) hist_channel
1543 cfg->big_en = int(dhaze.ProcResV10.dehaze_en[4]); //0~1 , (1bit) gain_en
1544 cfg->dc_min_th = int(dhaze.ProcResV10.dehaze_self_adp[0]); //0~255, (8bit) dc_min_th
1545 cfg->dc_max_th = int(dhaze.ProcResV10.dehaze_self_adp[1] ); //0~255, (8bit) dc_max_th
1546 cfg->yhist_th = int(dhaze.ProcResV10.dehaze_self_adp[2] ); //0~255, (8bit) yhist_th
1547 cfg->yblk_th = int(dhaze.ProcResV10.dehaze_self_adp[3] * ((rawWidth + 15) / 16) * ((rawHeight + 15) / 16)); //default:28,(9bit) yblk_th
1548 cfg->dark_th = int(dhaze.ProcResV10.dehaze_self_adp[4] ); //0~255, (8bit) dark_th
1549 cfg->bright_min = int(dhaze.ProcResV10.dehaze_self_adp[5] ); //0~255, (8bit) bright_min
1550 cfg->bright_max = int(dhaze.ProcResV10.dehaze_self_adp[6] ); //0~255, (8bit) bright_max
1551 cfg->wt_max = int(dhaze.ProcResV10.dehaze_range_adj[0] * 256 ); //0~255, (9bit) wt_max
1552 cfg->air_min = int(dhaze.ProcResV10.dehaze_range_adj[2] ); //0~255, (8bit) air_min
1553 cfg->air_max = int(dhaze.ProcResV10.dehaze_range_adj[1] ); //0~256, (8bit) air_max
1554 cfg->tmax_base = int(dhaze.ProcResV10.dehaze_range_adj[3] ); //0~255, (8bit) tmax_base
1555 cfg->tmax_off = int(dhaze.ProcResV10.dehaze_range_adj[4] * 1024 ); //0~1024,(11bit) tmax_off
1556 cfg->tmax_max = int(dhaze.ProcResV10.dehaze_range_adj[5] * 1024 ); //0~1024,(11bit) tmax_max
1557 cfg->hist_gratio = int(dhaze.ProcResV10.dehaze_hist_para[0] * 8 ); // (8bit) hist_gratio
1558 cfg->hist_th_off = int(dhaze.ProcResV10.dehaze_hist_para[1] ); // (8bit) hist_th_off
1559 cfg->hist_k = int(dhaze.ProcResV10.dehaze_hist_para[2] * 4 + 0.5 ); //0~7 (5bit),3bit+2bit, hist_k
1560 cfg->hist_min = int(dhaze.ProcResV10.dehaze_hist_para[3] * 256 ); // (9bit) hist_min
1561 cfg->enhance_en = int(dhaze.ProcResV10.dehaze_enhance[0] ); //0~1 , (1bit) enhance_en
1562 cfg->enhance_value = int(dhaze.ProcResV10.dehaze_enhance[1] * 1024 + 0.5 ); // (14bit),4bit + 10bit, enhance_value
1563 cfg->hpara_en = int(dhaze.ProcResV10.dehaze_enhance[2] ); //0~1 , (1bit) sw_hist_para_en
1564 cfg->hist_scale = int(dhaze.ProcResV10.dehaze_enhance[3] * 256 + 0.5 ); // (13bit),5bit + 8bit, sw_hist_scale
1565 cfg->stab_fnum = int(dhaze.ProcResV10.dehaze_iir_control[0] ); //1~31, (5bit) stab_fnum
1566 cfg->iir_sigma = int(dhaze.ProcResV10.dehaze_iir_control[1] ); //0~255, (8bit) sigma
1567 cfg->iir_wt_sigma = int(dhaze.ProcResV10.dehaze_iir_control[2] * 8 + 0.5 ); // (11bit),8bit+3bit, wt_sigma
1568 cfg->iir_air_sigma = int(dhaze.ProcResV10.dehaze_iir_control[3] ); // (8bit) air_sigma
1569 cfg->iir_tmax_sigma = int(dhaze.ProcResV10.dehaze_iir_control[4] * 1024 + 0.5); // (11bit) tmax_sigma
1570 cfg->cfg_alpha = int(MIN(dhaze.ProcResV10.dehaze_user_config[0] * 256, 255)); //0~255, (8bit) cfg_alpha
1571 cfg->cfg_wt = int(dhaze.ProcResV10.dehaze_user_config[1] * 256 ); //0~256, (9bit) cfg_wt
1572 cfg->cfg_air = int(dhaze.ProcResV10.dehaze_user_config[2] ); //0~255, (8bit) cfg_air
1573 cfg->cfg_tmax = int(dhaze.ProcResV10.dehaze_user_config[3] * 1024 ); //0~1024,(11bit) cfg_tmax
1574 cfg->cfg_gratio = int(dhaze.ProcResV10.dehaze_user_config[4] * 256 ); // (13bit),5bit+8bit, cfg_gratio
1575 cfg->dc_thed = int(dhaze.ProcResV10.dehaze_bi_para[0] ); //0~255, (8bit) dc_thed
1576 cfg->dc_weitcur = int(dhaze.ProcResV10.dehaze_bi_para[1] * 256 + 0.5 ); //0~256, (9bit) dc_weitcur
1577 cfg->air_thed = int(dhaze.ProcResV10.dehaze_bi_para[2] ); //0~255, (8bit) air_thed
1578 cfg->air_weitcur = int(dhaze.ProcResV10.dehaze_bi_para[3] * 256 + 0.5 ); //0~256, (9bit) air_weitcur
1579
1580
1581 cfg->sw_dhaz_dc_bf_h0 = int(dhaze.ProcResV10.dehaze_dc_bf_h[12]);//h0~h5 从大到小
1582 cfg->sw_dhaz_dc_bf_h1 = int(dhaze.ProcResV10.dehaze_dc_bf_h[7]);
1583 cfg->sw_dhaz_dc_bf_h2 = int(dhaze.ProcResV10.dehaze_dc_bf_h[6]);
1584 cfg->sw_dhaz_dc_bf_h3 = int(dhaze.ProcResV10.dehaze_dc_bf_h[2]);
1585 cfg->sw_dhaz_dc_bf_h4 = int(dhaze.ProcResV10.dehaze_dc_bf_h[1]);
1586 cfg->sw_dhaz_dc_bf_h5 = int(dhaze.ProcResV10.dehaze_dc_bf_h[0]);
1587
1588
1589 cfg->air_bf_h0 = int(dhaze.ProcResV10.dehaze_air_bf_h[4]);//h0~h2 从大到小
1590 cfg->air_bf_h1 = int(dhaze.ProcResV10.dehaze_air_bf_h[1]);
1591 cfg->air_bf_h2 = int(dhaze.ProcResV10.dehaze_air_bf_h[0]);
1592
1593 cfg->gaus_h0 = int(dhaze.ProcResV10.dehaze_gaus_h[4]);//h0~h2 从大到小
1594 cfg->gaus_h1 = int(dhaze.ProcResV10.dehaze_gaus_h[1]);
1595 cfg->gaus_h2 = int(dhaze.ProcResV10.dehaze_gaus_h[0]);
1596
1597 for (int i = 0; i < ISP2X_DHAZ_CONV_COEFF_NUM; i++)
1598 {
1599 cfg->conv_t0[i] = int(dhaze.ProcResV10.dehaze_hist_t0[i]);
1600 cfg->conv_t1[i] = int(dhaze.ProcResV10.dehaze_hist_t1[i]);
1601 cfg->conv_t2[i] = int(dhaze.ProcResV10.dehaze_hist_t2[i]);
1602 }
1603 #endif
1604 }
1605 #endif
1606
1607 template<class T>
1608 void
convertAiqBlcToIsp20Params(T & isp_cfg,rk_aiq_isp_blc_t & blc)1609 Isp20Params::convertAiqBlcToIsp20Params(T& isp_cfg, rk_aiq_isp_blc_t &blc)
1610 {
1611 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) enter \n", __FUNCTION__, __LINE__);
1612
1613 if(blc.enable) {
1614 isp_cfg.module_ens |= ISP2X_MODULE_BLS;
1615 }
1616 isp_cfg.module_en_update |= ISP2X_MODULE_BLS;
1617 isp_cfg.module_cfg_update |= ISP2X_MODULE_BLS;
1618
1619 isp_cfg.others.bls_cfg.enable_auto = 0;
1620 isp_cfg.others.bls_cfg.en_windows = 0;
1621
1622 isp_cfg.others.bls_cfg.bls_window1.h_offs = 0;
1623 isp_cfg.others.bls_cfg.bls_window1.v_offs = 0;
1624 isp_cfg.others.bls_cfg.bls_window1.h_size = 0;
1625 isp_cfg.others.bls_cfg.bls_window1.v_size = 0;
1626
1627 isp_cfg.others.bls_cfg.bls_window2.h_offs = 0;
1628 isp_cfg.others.bls_cfg.bls_window2.v_offs = 0;
1629 isp_cfg.others.bls_cfg.bls_window2.h_size = 0;
1630 isp_cfg.others.bls_cfg.bls_window2.v_size = 0;
1631
1632 isp_cfg.others.bls_cfg.bls_samples = 0;
1633
1634 isp_cfg.others.bls_cfg.fixed_val.r = blc.blc_gr;
1635 isp_cfg.others.bls_cfg.fixed_val.gr = blc.blc_gr;
1636 isp_cfg.others.bls_cfg.fixed_val.gb = blc.blc_gr;
1637 isp_cfg.others.bls_cfg.fixed_val.b = blc.blc_gr;
1638
1639 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) exit \n", __FUNCTION__, __LINE__);
1640 }
1641
1642
1643 template<class T>
1644 void
convertAiqDpccToIsp20Params(T & isp_cfg,rk_aiq_isp_dpcc_t & dpcc)1645 Isp20Params::convertAiqDpccToIsp20Params(T& isp_cfg, rk_aiq_isp_dpcc_t &dpcc)
1646 {
1647 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) enter \n", __FUNCTION__, __LINE__);
1648
1649 struct isp2x_dpcc_cfg * pDpccCfg = &isp_cfg.others.dpcc_cfg;
1650 rk_aiq_isp_dpcc_t *pDpccRst = &dpcc;
1651
1652 if(pDpccRst->stBasic.enable) {
1653 isp_cfg.module_ens |= ISP2X_MODULE_DPCC;
1654 }
1655 isp_cfg.module_en_update |= ISP2X_MODULE_DPCC;
1656 isp_cfg.module_cfg_update |= ISP2X_MODULE_DPCC;
1657
1658 //mode 0x0000
1659 pDpccCfg->stage1_enable = pDpccRst->stBasic.stage1_enable;
1660 pDpccCfg->grayscale_mode = pDpccRst->stBasic.grayscale_mode;
1661 //pDpccCfg->enable = pDpccRst->stBasic.enable;
1662
1663 //output_mode 0x0004
1664 pDpccCfg->sw_rk_out_sel = pDpccRst->stBasic.sw_rk_out_sel;
1665 pDpccCfg->sw_dpcc_output_sel = pDpccRst->stBasic.sw_dpcc_output_sel;
1666 pDpccCfg->stage1_rb_3x3 = pDpccRst->stBasic.stage1_rb_3x3;
1667 pDpccCfg->stage1_g_3x3 = pDpccRst->stBasic.stage1_g_3x3;
1668 pDpccCfg->stage1_incl_rb_center = pDpccRst->stBasic.stage1_incl_rb_center;
1669 pDpccCfg->stage1_incl_green_center = pDpccRst->stBasic.stage1_incl_green_center;
1670
1671 //set_use 0x0008
1672 pDpccCfg->stage1_use_fix_set = pDpccRst->stBasic.stage1_use_fix_set;
1673 pDpccCfg->stage1_use_set_3 = pDpccRst->stBasic.stage1_use_set_3;
1674 pDpccCfg->stage1_use_set_2 = pDpccRst->stBasic.stage1_use_set_2;
1675 pDpccCfg->stage1_use_set_1 = pDpccRst->stBasic.stage1_use_set_1;
1676
1677 //methods_set_1 0x000c
1678 pDpccCfg->sw_rk_red_blue1_en = pDpccRst->stBasic.sw_rk_red_blue1_en;
1679 pDpccCfg->rg_red_blue1_enable = pDpccRst->stBasic.rg_red_blue1_enable;
1680 pDpccCfg->rnd_red_blue1_enable = pDpccRst->stBasic.rnd_red_blue1_enable;
1681 pDpccCfg->ro_red_blue1_enable = pDpccRst->stBasic.ro_red_blue1_enable;
1682 pDpccCfg->lc_red_blue1_enable = pDpccRst->stBasic.lc_red_blue1_enable;
1683 pDpccCfg->pg_red_blue1_enable = pDpccRst->stBasic.pg_red_blue1_enable;
1684 pDpccCfg->sw_rk_green1_en = pDpccRst->stBasic.sw_rk_green1_en;
1685 pDpccCfg->rg_green1_enable = pDpccRst->stBasic.rg_green1_enable;
1686 pDpccCfg->rnd_green1_enable = pDpccRst->stBasic.rnd_green1_enable;
1687 pDpccCfg->ro_green1_enable = pDpccRst->stBasic.ro_green1_enable;
1688 pDpccCfg->lc_green1_enable = pDpccRst->stBasic.lc_green1_enable;
1689 pDpccCfg->pg_green1_enable = pDpccRst->stBasic.pg_green1_enable;
1690
1691 //methods_set_2 0x0010
1692 pDpccCfg->sw_rk_red_blue2_en = pDpccRst->stBasic.sw_rk_red_blue2_en;
1693 pDpccCfg->rg_red_blue2_enable = pDpccRst->stBasic.rg_red_blue2_enable;
1694 pDpccCfg->rnd_red_blue2_enable = pDpccRst->stBasic.rnd_red_blue2_enable;
1695 pDpccCfg->ro_red_blue2_enable = pDpccRst->stBasic.ro_red_blue2_enable;
1696 pDpccCfg->lc_red_blue2_enable = pDpccRst->stBasic.lc_red_blue2_enable;
1697 pDpccCfg->pg_red_blue2_enable = pDpccRst->stBasic.pg_red_blue2_enable;
1698 pDpccCfg->sw_rk_green2_en = pDpccRst->stBasic.sw_rk_green2_en;
1699 pDpccCfg->rg_green2_enable = pDpccRst->stBasic.rg_green2_enable;
1700 pDpccCfg->rnd_green2_enable = pDpccRst->stBasic.rnd_green2_enable;
1701 pDpccCfg->ro_green2_enable = pDpccRst->stBasic.ro_green2_enable;
1702 pDpccCfg->lc_green2_enable = pDpccRst->stBasic.lc_green2_enable;
1703 pDpccCfg->pg_green2_enable = pDpccRst->stBasic.pg_green2_enable;
1704
1705 //methods_set_3 0x0014
1706 pDpccCfg->sw_rk_red_blue3_en = pDpccRst->stBasic.sw_rk_red_blue3_en;
1707 pDpccCfg->rg_red_blue3_enable = pDpccRst->stBasic.rg_red_blue3_enable;
1708 pDpccCfg->rnd_red_blue3_enable = pDpccRst->stBasic.rnd_red_blue3_enable;
1709 pDpccCfg->ro_red_blue3_enable = pDpccRst->stBasic.ro_red_blue3_enable;
1710 pDpccCfg->lc_red_blue3_enable = pDpccRst->stBasic.lc_red_blue3_enable;
1711 pDpccCfg->pg_red_blue3_enable = pDpccRst->stBasic.pg_red_blue3_enable;
1712 pDpccCfg->sw_rk_green3_en = pDpccRst->stBasic.sw_rk_green3_en;
1713 pDpccCfg->rg_green3_enable = pDpccRst->stBasic.rg_green3_enable;
1714 pDpccCfg->rnd_green3_enable = pDpccRst->stBasic.rnd_green3_enable;
1715 pDpccCfg->ro_green3_enable = pDpccRst->stBasic.ro_green3_enable;
1716 pDpccCfg->lc_green3_enable = pDpccRst->stBasic.lc_green3_enable;
1717 pDpccCfg->pg_green3_enable = pDpccRst->stBasic.pg_green3_enable;
1718
1719 //line_thresh_1 0x0018
1720 pDpccCfg->sw_mindis1_rb = pDpccRst->stBasic.sw_mindis1_rb;
1721 pDpccCfg->sw_mindis1_g = pDpccRst->stBasic.sw_mindis1_g;
1722 pDpccCfg->line_thr_1_rb = pDpccRst->stBasic.line_thr_1_rb;
1723 pDpccCfg->line_thr_1_g = pDpccRst->stBasic.line_thr_1_g;
1724
1725 //line_mad_fac_1 0x001c
1726 pDpccCfg->sw_dis_scale_min1 = pDpccRst->stBasic.sw_dis_scale_min1;
1727 pDpccCfg->sw_dis_scale_max1 = pDpccRst->stBasic.sw_dis_scale_max1;
1728 pDpccCfg->line_mad_fac_1_rb = pDpccRst->stBasic.line_mad_fac_1_rb;
1729 pDpccCfg->line_mad_fac_1_g = pDpccRst->stBasic.line_mad_fac_1_g;
1730
1731 //pg_fac_1 0x0020
1732 pDpccCfg->pg_fac_1_rb = pDpccRst->stBasic.pg_fac_1_rb;
1733 pDpccCfg->pg_fac_1_g = pDpccRst->stBasic.pg_fac_1_g;
1734
1735 //rnd_thresh_1 0x0024
1736 pDpccCfg->rnd_thr_1_rb = pDpccRst->stBasic.rnd_thr_1_rb;
1737 pDpccCfg->rnd_thr_1_g = pDpccRst->stBasic.rnd_thr_1_g;
1738
1739 //rg_fac_1 0x0028
1740 pDpccCfg->rg_fac_1_rb = pDpccRst->stBasic.rg_fac_1_rb;
1741 pDpccCfg->rg_fac_1_g = pDpccRst->stBasic.rg_fac_1_g;
1742
1743
1744 //line_thresh_2 0x002c
1745 pDpccCfg->sw_mindis2_rb = pDpccRst->stBasic.sw_mindis2_rb;
1746 pDpccCfg->sw_mindis2_g = pDpccRst->stBasic.sw_mindis2_g;
1747 pDpccCfg->line_thr_2_rb = pDpccRst->stBasic.line_thr_2_rb;
1748 pDpccCfg->line_thr_2_g = pDpccRst->stBasic.line_thr_2_g;
1749
1750 //line_mad_fac_2 0x0030
1751 pDpccCfg->sw_dis_scale_min2 = pDpccRst->stBasic.sw_dis_scale_min2;
1752 pDpccCfg->sw_dis_scale_max2 = pDpccRst->stBasic.sw_dis_scale_max2;
1753 pDpccCfg->line_mad_fac_2_rb = pDpccRst->stBasic.line_mad_fac_2_rb;
1754 pDpccCfg->line_mad_fac_2_g = pDpccRst->stBasic.line_mad_fac_2_g;
1755
1756 //pg_fac_2 0x0034
1757 pDpccCfg->pg_fac_2_rb = pDpccRst->stBasic.pg_fac_2_rb;
1758 pDpccCfg->pg_fac_2_g = pDpccRst->stBasic.pg_fac_2_g;
1759
1760 //rnd_thresh_2 0x0038
1761 pDpccCfg->rnd_thr_2_rb = pDpccRst->stBasic.rnd_thr_2_rb;
1762 pDpccCfg->rnd_thr_2_g = pDpccRst->stBasic.rnd_thr_2_g;
1763
1764 //rg_fac_2 0x003c
1765 pDpccCfg->rg_fac_2_rb = pDpccRst->stBasic.rg_fac_2_rb;
1766 pDpccCfg->rg_fac_2_g = pDpccRst->stBasic.rg_fac_2_g;
1767
1768
1769 //line_thresh_3 0x0040
1770 pDpccCfg->sw_mindis3_rb = pDpccRst->stBasic.sw_mindis3_rb;
1771 pDpccCfg->sw_mindis3_g = pDpccRst->stBasic.sw_mindis3_g;
1772 pDpccCfg->line_thr_3_rb = pDpccRst->stBasic.line_thr_3_rb;
1773 pDpccCfg->line_thr_3_g = pDpccRst->stBasic.line_thr_3_g;
1774
1775 //line_mad_fac_3 0x0044
1776 pDpccCfg->sw_dis_scale_min3 = pDpccRst->stBasic.sw_dis_scale_min3;
1777 pDpccCfg->sw_dis_scale_max3 = pDpccRst->stBasic.sw_dis_scale_max3;
1778 pDpccCfg->line_mad_fac_3_rb = pDpccRst->stBasic.line_mad_fac_3_rb;
1779 pDpccCfg->line_mad_fac_3_g = pDpccRst->stBasic.line_mad_fac_3_g;
1780
1781 //pg_fac_3 0x0048
1782 pDpccCfg->pg_fac_3_rb = pDpccRst->stBasic.pg_fac_3_rb;
1783 pDpccCfg->pg_fac_3_g = pDpccRst->stBasic.pg_fac_3_g;
1784
1785 //rnd_thresh_3 0x004c
1786 pDpccCfg->rnd_thr_3_rb = pDpccRst->stBasic.rnd_thr_3_rb;
1787 pDpccCfg->rnd_thr_3_g = pDpccRst->stBasic.rnd_thr_3_g;
1788
1789 //rg_fac_3 0x0050
1790 pDpccCfg->rg_fac_3_rb = pDpccRst->stBasic.rg_fac_3_rb;
1791 pDpccCfg->rg_fac_3_g = pDpccRst->stBasic.rg_fac_3_g;
1792
1793 //ro_limits 0x0054
1794 pDpccCfg->ro_lim_3_rb = pDpccRst->stBasic.ro_lim_3_rb;
1795 pDpccCfg->ro_lim_3_g = pDpccRst->stBasic.ro_lim_3_g;
1796 pDpccCfg->ro_lim_2_rb = pDpccRst->stBasic.ro_lim_2_rb;
1797 pDpccCfg->ro_lim_2_g = pDpccRst->stBasic.ro_lim_2_g;
1798 pDpccCfg->ro_lim_1_rb = pDpccRst->stBasic.ro_lim_1_rb;
1799 pDpccCfg->ro_lim_1_g = pDpccRst->stBasic.ro_lim_1_g;
1800
1801 //rnd_offs 0x0058
1802 pDpccCfg->rnd_offs_3_rb = pDpccRst->stBasic.rnd_offs_3_rb;
1803 pDpccCfg->rnd_offs_3_g = pDpccRst->stBasic.rnd_offs_3_g;
1804 pDpccCfg->rnd_offs_2_rb = pDpccRst->stBasic.rnd_offs_2_rb;
1805 pDpccCfg->rnd_offs_2_g = pDpccRst->stBasic.rnd_offs_2_g;
1806 pDpccCfg->rnd_offs_1_rb = pDpccRst->stBasic.rnd_offs_1_rb;
1807 pDpccCfg->rnd_offs_1_g = pDpccRst->stBasic.rnd_offs_1_g;
1808
1809 //bpt_ctrl 0x005c
1810 pDpccCfg->bpt_rb_3x3 = pDpccRst->stBpt.bpt_rb_3x3;
1811 pDpccCfg->bpt_g_3x3 = pDpccRst->stBpt.bpt_g_3x3;
1812 pDpccCfg->bpt_incl_rb_center = pDpccRst->stBpt.bpt_incl_rb_center;
1813 pDpccCfg->bpt_incl_green_center = pDpccRst->stBpt.bpt_incl_green_center;
1814 pDpccCfg->bpt_use_fix_set = pDpccRst->stBpt.bpt_use_fix_set;
1815 pDpccCfg->bpt_use_set_3 = pDpccRst->stBpt.bpt_use_set_3;
1816 pDpccCfg->bpt_use_set_2 = pDpccRst->stBpt.bpt_use_set_2;
1817 pDpccCfg->bpt_use_set_1 = pDpccRst->stBpt.bpt_use_set_1;
1818 pDpccCfg->bpt_cor_en = pDpccRst->stBpt.bpt_cor_en;
1819 pDpccCfg->bpt_det_en = pDpccRst->stBpt.bpt_det_en;
1820
1821 //bpt_number 0x0060
1822 pDpccCfg->bp_number = pDpccRst->stBpt.bp_number;
1823
1824 //bpt_addr 0x0064
1825 pDpccCfg->bp_table_addr = pDpccRst->stBpt.bp_table_addr;
1826
1827 //bpt_data 0x0068
1828 pDpccCfg->bpt_v_addr = pDpccRst->stBpt.bpt_v_addr;
1829 pDpccCfg->bpt_h_addr = pDpccRst->stBpt.bpt_h_addr;
1830
1831 //bp_cnt 0x006c
1832 pDpccCfg->bp_cnt = pDpccRst->stBpt.bp_cnt;
1833
1834 //pdaf_en 0x0070
1835 pDpccCfg->sw_pdaf_en = pDpccRst->stPdaf.sw_pdaf_en;
1836
1837 //pdaf_point_en 0x0074
1838 for(int i = 0; i < ISP2X_DPCC_PDAF_POINT_NUM; i++) {
1839 pDpccCfg->pdaf_point_en[i] = pDpccRst->stPdaf.pdaf_point_en[i];
1840 }
1841
1842 //pdaf_offset 0x0078
1843 pDpccCfg->pdaf_offsety = pDpccRst->stPdaf.pdaf_offsety;
1844 pDpccCfg->pdaf_offsetx = pDpccRst->stPdaf.pdaf_offsetx;
1845
1846 //pdaf_wrap 0x007c
1847 pDpccCfg->pdaf_wrapy = pDpccRst->stPdaf.pdaf_wrapy;
1848 pDpccCfg->pdaf_wrapx = pDpccRst->stPdaf.pdaf_wrapx;
1849
1850 //pdaf_scope 0x0080
1851 pDpccCfg->pdaf_wrapy_num = pDpccRst->stPdaf.pdaf_wrapy_num;
1852 pDpccCfg->pdaf_wrapx_num = pDpccRst->stPdaf.pdaf_wrapx_num;
1853
1854 //pdaf_point_0 0x0084
1855 for(int i = 0; i < ISP2X_DPCC_PDAF_POINT_NUM; i++) {
1856 pDpccCfg->point[i].x = pDpccRst->stPdaf.point[i].x;
1857 pDpccCfg->point[i].y = pDpccRst->stPdaf.point[i].y;
1858 }
1859
1860 //pdaf_forward_med 0x00a4
1861 pDpccCfg->pdaf_forward_med = pDpccRst->stPdaf.pdaf_forward_med;
1862
1863
1864 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) exit \n", __FUNCTION__, __LINE__);
1865 }
1866
1867
1868 template<class T>
1869 void
convertAiqLscToIsp20Params(T & isp_cfg,const rk_aiq_lsc_cfg_t & lsc)1870 Isp20Params::convertAiqLscToIsp20Params(T& isp_cfg,
1871 const rk_aiq_lsc_cfg_t& lsc)
1872 {
1873
1874 if(lsc.lsc_en) {
1875 isp_cfg.module_ens |= ISP2X_MODULE_LSC;
1876 isp_cfg.module_en_update |= ISP2X_MODULE_LSC;
1877 isp_cfg.module_cfg_update |= ISP2X_MODULE_LSC;
1878 _lsc_en = true;
1879 } else {
1880 isp_cfg.module_ens &= ~ISP2X_MODULE_LSC;
1881 isp_cfg.module_en_update |= ISP2X_MODULE_LSC;
1882 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_LSC;
1883 _lsc_en = false;
1884 }
1885
1886 #if defined (RKAIQ_HAVE_LSC_V2) || defined (RKAIQ_HAVE_LSC_V3)
1887 struct isp3x_lsc_cfg * cfg = &isp_cfg.others.lsc_cfg;
1888 cfg->sector_16x16 = true;
1889 #else
1890 struct isp2x_lsc_cfg * cfg = &isp_cfg.others.lsc_cfg;
1891 #endif
1892 memcpy(cfg->x_size_tbl, lsc.x_size_tbl, sizeof(cfg->x_size_tbl));
1893 memcpy(cfg->y_size_tbl, lsc.y_size_tbl, sizeof(cfg->y_size_tbl));
1894 memcpy(cfg->x_grad_tbl, lsc.x_grad_tbl, sizeof(cfg->x_grad_tbl));
1895 memcpy(cfg->y_grad_tbl, lsc.y_grad_tbl, sizeof(cfg->y_grad_tbl));
1896
1897 memcpy(cfg->r_data_tbl, lsc.r_data_tbl, sizeof(lsc.r_data_tbl));
1898 memcpy(cfg->gr_data_tbl, lsc.gr_data_tbl, sizeof(lsc.gr_data_tbl));
1899 memcpy(cfg->gb_data_tbl, lsc.gb_data_tbl, sizeof(lsc.gb_data_tbl));
1900 memcpy(cfg->b_data_tbl, lsc.b_data_tbl, sizeof(lsc.b_data_tbl));
1901 #if 0//def ISP_HW_V30 // will be done Isp21Params::convertAiqExpIspDgainToIspParams
1902 #define MAX_LSC_VALUE 8191
1903 struct isp21_bls_cfg &bls_cfg = isp_cfg.others.bls_cfg;
1904 if(bls_cfg.bls1_en && bls_cfg.bls1_val.b > 0 && bls_cfg.bls1_val.r > 0
1905 && bls_cfg.bls1_val.gb > 0 && bls_cfg.bls1_val.gr > 0 ) {
1906 if(lsc.lsc_en) {
1907 for(int i = 0; i < ISP3X_LSC_DATA_TBL_SIZE; i++) {
1908 cfg->b_data_tbl[i] = cfg->b_data_tbl[i] * ((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - bls_cfg.bls1_val.b);
1909 cfg->b_data_tbl[i] = MIN(cfg->b_data_tbl[i], MAX_LSC_VALUE);
1910 cfg->gb_data_tbl[i] = cfg->gb_data_tbl[i] * ((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - bls_cfg.bls1_val.gb);
1911 cfg->gb_data_tbl[i] = MIN(cfg->gb_data_tbl[i], MAX_LSC_VALUE);
1912 cfg->r_data_tbl[i] = cfg->r_data_tbl[i] * ((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - bls_cfg.bls1_val.r);
1913 cfg->r_data_tbl[i] = MIN(cfg->r_data_tbl[i], MAX_LSC_VALUE);
1914 cfg->gr_data_tbl[i] = cfg->gr_data_tbl[i] * ((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - bls_cfg.bls1_val.gr);
1915 cfg->gr_data_tbl[i] = MIN(cfg->gr_data_tbl[i], MAX_LSC_VALUE);
1916 }
1917 } else {
1918 isp_cfg.module_ens |= ISP2X_MODULE_LSC; //force open lsc
1919 for(int i = 0; i < ISP3X_LSC_DATA_TBL_SIZE; i++) {
1920 cfg->b_data_tbl[i] = 1024 * ((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - bls_cfg.bls1_val.b);
1921 cfg->b_data_tbl[i] = MIN(cfg->b_data_tbl[i], MAX_LSC_VALUE);
1922 cfg->gb_data_tbl[i] = 1024 * ((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - bls_cfg.bls1_val.gb);
1923 cfg->gb_data_tbl[i] = MIN(cfg->gb_data_tbl[i], MAX_LSC_VALUE);
1924 cfg->r_data_tbl[i] = 1024 * ((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - bls_cfg.bls1_val.r);
1925 cfg->r_data_tbl[i] = MIN(cfg->r_data_tbl[i], MAX_LSC_VALUE);
1926 cfg->gr_data_tbl[i] = 1024 * ((1 << ISP2X_BLC_BIT_MAX) - 1) / ((1 << ISP2X_BLC_BIT_MAX) - 1 - bls_cfg.bls1_val.gr);
1927 cfg->gr_data_tbl[i] = MIN(cfg->gr_data_tbl[i], MAX_LSC_VALUE);
1928 }
1929 }
1930 }
1931 #endif
1932 }
1933
1934 #if RKAIQ_HAVE_CCM_V1
1935 template<class T>
convertAiqCcmToIsp20Params(T & isp_cfg,const rk_aiq_ccm_cfg_t & ccm)1936 void Isp20Params::convertAiqCcmToIsp20Params(T& isp_cfg,
1937 const rk_aiq_ccm_cfg_t& ccm)
1938 {
1939 if(ccm.ccmEnable) {
1940 isp_cfg.module_ens |= ISP2X_MODULE_CCM;
1941 }
1942 isp_cfg.module_en_update |= ISP2X_MODULE_CCM;
1943 isp_cfg.module_cfg_update |= ISP2X_MODULE_CCM;
1944
1945 struct isp2x_ccm_cfg * cfg = &isp_cfg.others.ccm_cfg;
1946 const float *coeff = ccm.matrix;
1947 const float *offset = ccm.offs;
1948
1949 cfg->coeff0_r = (coeff[0] - 1) > 0 ? (short)((coeff[0] - 1) * 128 + 0.5) : (short)((coeff[0] - 1) * 128 - 0.5); //check -128?
1950 cfg->coeff1_r = coeff[1] > 0 ? (short)(coeff[1] * 128 + 0.5) : (short)(coeff[1] * 128 - 0.5);
1951 cfg->coeff2_r = coeff[2] > 0 ? (short)(coeff[2] * 128 + 0.5) : (short)(coeff[2] * 128 - 0.5);
1952 cfg->coeff0_g = coeff[3] > 0 ? (short)(coeff[3] * 128 + 0.5) : (short)(coeff[3] * 128 - 0.5);
1953 cfg->coeff1_g = (coeff[4] - 1) > 0 ? (short)((coeff[4] - 1) * 128 + 0.5) : (short)((coeff[4] - 1) * 128 - 0.5);
1954 cfg->coeff2_g = coeff[5] > 0 ? (short)(coeff[5] * 128 + 0.5) : (short)(coeff[5] * 128 - 0.5);
1955 cfg->coeff0_b = coeff[6] > 0 ? (short)(coeff[6] * 128 + 0.5) : (short)(coeff[6] * 128 - 0.5);
1956 cfg->coeff1_b = coeff[7] > 0 ? (short)(coeff[7] * 128 + 0.5) : (short)(coeff[7] * 128 - 0.5);
1957 cfg->coeff2_b = (coeff[8] - 1) > 0 ? (short)((coeff[8] - 1) * 128 + 0.5) : (short)((coeff[8] - 1) * 128 - 0.5);
1958
1959 cfg->offset_r = offset[0] > 0 ? (short)(offset[0] + 0.5) : (short)(offset[0] - 0.5);// for 12bit
1960 cfg->offset_g = offset[1] > 0 ? (short)(offset[1] + 0.5) : (int)(offset[1] - 0.5);
1961 cfg->offset_b = offset[2] > 0 ? (short)(offset[2] + 0.5) : (short)(offset[2] - 0.5);
1962
1963 cfg->coeff0_y = (u16 )ccm.rgb2y_para[0];
1964 cfg->coeff1_y = (u16 )ccm.rgb2y_para[1];
1965 cfg->coeff2_y = (u16 )ccm.rgb2y_para[2];
1966 cfg->bound_bit = (u8)ccm.bound_bit;//check
1967
1968 for( int i = 0; i < 17; i++)
1969 {
1970 cfg->alp_y[i] = (u16)(ccm.alp_y[i]);
1971 }
1972 }
1973 #endif
1974 #if RKAIQ_HAVE_3DLUT_V1
1975 template<class T>
convertAiqA3dlutToIsp20Params(T & isp_cfg,const rk_aiq_lut3d_cfg_t & lut3d_cfg)1976 void Isp20Params::convertAiqA3dlutToIsp20Params(T& isp_cfg,
1977 const rk_aiq_lut3d_cfg_t& lut3d_cfg)
1978 {
1979 if(lut3d_cfg.enable) {
1980 isp_cfg.module_ens |= ISP2X_MODULE_3DLUT;
1981 }
1982 isp_cfg.module_en_update |= ISP2X_MODULE_3DLUT;
1983 isp_cfg.module_cfg_update |= ISP2X_MODULE_3DLUT;
1984
1985 struct isp2x_3dlut_cfg* cfg = &isp_cfg.others.isp3dlut_cfg;
1986 #ifndef ISP_HW_V30 // isp3x has no bypass_en
1987 cfg->bypass_en = lut3d_cfg.bypass_en;
1988 #endif
1989 cfg->actual_size = lut3d_cfg.lut3d_lut_wsize;
1990 if (lut3d_cfg.enable || !lut3d_cfg.bypass_en) {
1991 memcpy(cfg->lut_r, lut3d_cfg.tbl.look_up_table_r, sizeof(cfg->lut_r));
1992 memcpy(cfg->lut_g, lut3d_cfg.tbl.look_up_table_g, sizeof(cfg->lut_g));
1993 memcpy(cfg->lut_b, lut3d_cfg.tbl.look_up_table_b, sizeof(cfg->lut_b));
1994 } else {
1995 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_3DLUT;
1996 }
1997 }
1998 #endif
1999
2000
2001 #if RKAIQ_HAVE_ANR_V1
2002 template<class T>
convertAiqRawnrToIsp20Params(T & isp_cfg,rk_aiq_isp_rawnr_t & rawnr)2003 void Isp20Params::convertAiqRawnrToIsp20Params(T& isp_cfg,
2004 rk_aiq_isp_rawnr_t& rawnr)
2005 {
2006
2007 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) enter \n", __FUNCTION__, __LINE__);
2008
2009 struct isp2x_rawnr_cfg * pRawnrCfg = &isp_cfg.others.rawnr_cfg;
2010 if(rawnr.rawnr_en) {
2011
2012 isp_cfg.module_ens |= ISP2X_MODULE_RAWNR;
2013 } else {
2014 isp_cfg.module_ens &= ~ISP2X_MODULE_RAWNR;
2015 }
2016 isp_cfg.module_en_update |= ISP2X_MODULE_RAWNR;
2017 isp_cfg.module_cfg_update |= ISP2X_MODULE_RAWNR;
2018
2019 int rawbit = 12;//rawBit;
2020 float tmp;
2021
2022 //(0x0004)
2023 pRawnrCfg->gauss_en = rawnr.gauss_en;
2024 pRawnrCfg->log_bypass = rawnr.log_bypass;
2025
2026 //(0x0008 - 0x0010)
2027 pRawnrCfg->filtpar0 = rawnr.filtpar0;
2028 pRawnrCfg->filtpar1 = rawnr.filtpar1;
2029 pRawnrCfg->filtpar2 = rawnr.filtpar2;
2030
2031 //(0x0014 - 0x0001c)
2032 pRawnrCfg->dgain0 = rawnr.dgain0;
2033 pRawnrCfg->dgain1 = rawnr.dgain1;
2034 pRawnrCfg->dgain2 = rawnr.dgain2;
2035
2036 //(0x0020 - 0x0002c)
2037 for(int i = 0; i < ISP2X_RAWNR_LUMA_RATION_NUM; i++) {
2038 pRawnrCfg->luration[i] = rawnr.luration[i];
2039 }
2040
2041 //(0x0030 - 0x0003c)
2042 for(int i = 0; i < ISP2X_RAWNR_LUMA_RATION_NUM; i++) {
2043 pRawnrCfg->lulevel[i] = rawnr.lulevel[i];
2044 }
2045
2046 //(0x0040)
2047 pRawnrCfg->gauss = rawnr.gauss;
2048
2049 //(0x0044)
2050 pRawnrCfg->sigma = rawnr.sigma;
2051
2052 //(0x0048)
2053 pRawnrCfg->pix_diff = rawnr.pix_diff;
2054
2055 //(0x004c)
2056 pRawnrCfg->thld_diff = rawnr.thld_diff;
2057
2058 //(0x0050)
2059 pRawnrCfg->gas_weig_scl1 = rawnr.gas_weig_scl1;
2060 pRawnrCfg->gas_weig_scl2 = rawnr.gas_weig_scl2;
2061 pRawnrCfg->thld_chanelw = rawnr.thld_chanelw;
2062
2063 //(0x0054)
2064 pRawnrCfg->lamda = rawnr.lamda;
2065
2066 //(0x0058 - 0x0005c)
2067 pRawnrCfg->fixw0 = rawnr.fixw0;
2068 pRawnrCfg->fixw1 = rawnr.fixw1;
2069 pRawnrCfg->fixw2 = rawnr.fixw2;
2070 pRawnrCfg->fixw3 = rawnr.fixw3;
2071
2072 //(0x0060 - 0x00068)
2073 pRawnrCfg->wlamda0 = rawnr.wlamda0;
2074 pRawnrCfg->wlamda1 = rawnr.wlamda1;
2075 pRawnrCfg->wlamda2 = rawnr.wlamda2;
2076
2077 //(0x006c)
2078 pRawnrCfg->rgain_filp = rawnr.rgain_filp;
2079 pRawnrCfg->bgain_filp = rawnr.bgain_filp;
2080
2081 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) exit \n", __FUNCTION__, __LINE__);
2082 }
2083
2084 template<typename T>
convertAiqTnrToIsp20Params(T & pp_cfg,rk_aiq_isp_tnr_t & tnr)2085 void Isp20Params::convertAiqTnrToIsp20Params(T &pp_cfg,
2086 rk_aiq_isp_tnr_t& tnr)
2087 {
2088 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) enter \n", __FUNCTION__, __LINE__);
2089 int i = 0;
2090
2091 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "tnr_en %d", tnr.tnr_en);
2092
2093 if(tnr.tnr_en) {
2094 pp_cfg.head.module_ens |= ISPP_MODULE_TNR;
2095 } else {
2096 //pp_cfg.head.module_init_ens &= ~ISPP_MODULE_TNR_3TO1;
2097 pp_cfg.head.module_ens &= ~ISPP_MODULE_TNR;
2098 }
2099
2100 pp_cfg.head.module_en_update |= ISPP_MODULE_TNR;
2101 pp_cfg.head.module_cfg_update |= ISPP_MODULE_TNR;
2102
2103 struct rkispp_tnr_config * pTnrCfg = &pp_cfg.tnr_cfg;
2104
2105 //0x0080
2106 if (tnr.mode > 0) {
2107 pp_cfg.head.module_ens |= ISPP_MODULE_TNR_3TO1;
2108 } else {
2109 pp_cfg.head.module_ens |= ISPP_MODULE_TNR;
2110 }
2111
2112 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "mode:%d pp_cfg:0x%x\n", tnr.mode, pp_cfg.head.module_ens);
2113
2114 /* pTnrCfg->mode = tnr.mode; */
2115 pTnrCfg->opty_en = tnr.opty_en;
2116 pTnrCfg->optc_en = tnr.optc_en;
2117 pTnrCfg->gain_en = tnr.gain_en;
2118
2119 //0x0088
2120 pTnrCfg->pk0_y = tnr.pk0_y;
2121 pTnrCfg->pk1_y = tnr.pk1_y;
2122 pTnrCfg->pk0_c = tnr.pk0_c;
2123 pTnrCfg->pk1_c = tnr.pk1_c;
2124
2125 //0x008c
2126 pTnrCfg->glb_gain_cur = tnr.glb_gain_cur;
2127 pTnrCfg->glb_gain_nxt = tnr.glb_gain_nxt;
2128
2129 //0x0090
2130 pTnrCfg->glb_gain_cur_div = tnr.glb_gain_cur_div;
2131 pTnrCfg->glb_gain_cur_sqrt = tnr.glb_gain_cur_sqrt;
2132
2133 //0x0094 - 0x0098
2134 for(i = 0; i < TNR_SIGMA_CURVE_SIZE - 1; i++) {
2135 pTnrCfg->sigma_x[i] = tnr.sigma_x[i];
2136 }
2137
2138
2139
2140 //0x009c - 0x00bc
2141 for(i = 0; i < TNR_SIGMA_CURVE_SIZE; i++) {
2142 pTnrCfg->sigma_y[i] = tnr.sigma_y[i];
2143 }
2144
2145 //0x00c4 - 0x00cc
2146 for(i = 0; i < TNR_LUMA_CURVE_SIZE; i++) {
2147 pTnrCfg->luma_curve[i] = tnr.luma_curve[i];
2148 }
2149
2150 //0x00d0
2151 pTnrCfg->txt_th0_y = tnr.txt_th0_y;
2152 pTnrCfg->txt_th1_y = tnr.txt_th1_y;
2153
2154 //0x00d4
2155 pTnrCfg->txt_th0_c = tnr.txt_th0_c;
2156 pTnrCfg->txt_th1_c = tnr.txt_th1_c;
2157
2158 //0x00d8
2159 pTnrCfg->txt_thy_dlt = tnr.txt_thy_dlt;
2160 pTnrCfg->txt_thc_dlt = tnr.txt_thc_dlt;
2161
2162 //0x00dc - 0x00ec
2163 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
2164 pTnrCfg->gfcoef_y0[i] = tnr.gfcoef_y0[i];
2165 }
2166 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2167 pTnrCfg->gfcoef_y1[i] = tnr.gfcoef_y1[i];
2168 }
2169 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2170 pTnrCfg->gfcoef_y2[i] = tnr.gfcoef_y2[i];
2171 }
2172 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2173 pTnrCfg->gfcoef_y3[i] = tnr.gfcoef_y3[i];
2174 }
2175
2176 //0x00f0 - 0x0100
2177 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
2178 pTnrCfg->gfcoef_yg0[i] = tnr.gfcoef_yg0[i];
2179 }
2180 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2181 pTnrCfg->gfcoef_yg1[i] = tnr.gfcoef_yg1[i];
2182 }
2183 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2184 pTnrCfg->gfcoef_yg2[i] = tnr.gfcoef_yg2[i];
2185 }
2186 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2187 pTnrCfg->gfcoef_yg3[i] = tnr.gfcoef_yg3[i];
2188 }
2189
2190 //0x0104 - 0x0110
2191 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
2192 pTnrCfg->gfcoef_yl0[i] = tnr.gfcoef_yl0[i];
2193 }
2194 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2195 pTnrCfg->gfcoef_yl1[i] = tnr.gfcoef_yl1[i];
2196 }
2197 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2198 pTnrCfg->gfcoef_yl2[i] = tnr.gfcoef_yl2[i];
2199 }
2200
2201 //0x0114 - 0x0120
2202 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
2203 pTnrCfg->gfcoef_cg0[i] = tnr.gfcoef_cg0[i];
2204 }
2205 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2206 pTnrCfg->gfcoef_cg1[i] = tnr.gfcoef_cg1[i];
2207 }
2208 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2209 pTnrCfg->gfcoef_cg2[i] = tnr.gfcoef_cg2[i];
2210 }
2211
2212 //0x0124 - 0x012c
2213 for(i = 0; i < TNR_GFCOEF6_SIZE; i++) {
2214 pTnrCfg->gfcoef_cl0[i] = tnr.gfcoef_cl0[i];
2215 }
2216 for(i = 0; i < TNR_GFCOEF3_SIZE; i++) {
2217 pTnrCfg->gfcoef_cl1[i] = tnr.gfcoef_cl1[i];
2218 }
2219
2220 //0x0130 - 0x0134
2221 for(i = 0; i < TNR_SCALE_YG_SIZE; i++) {
2222 pTnrCfg->scale_yg[i] = tnr.scale_yg[i];
2223 }
2224
2225 //0x0138 - 0x013c
2226 for(i = 0; i < TNR_SCALE_YL_SIZE; i++) {
2227 pTnrCfg->scale_yl[i] = tnr.scale_yl[i];
2228 }
2229
2230 //0x0140 - 0x0148
2231 for(i = 0; i < TNR_SCALE_CG_SIZE; i++) {
2232 pTnrCfg->scale_cg[i] = tnr.scale_cg[i];
2233 pTnrCfg->scale_y2cg[i] = tnr.scale_y2cg[i];
2234 }
2235
2236 //0x014c - 0x0154
2237 for(i = 0; i < TNR_SCALE_CL_SIZE; i++) {
2238 pTnrCfg->scale_cl[i] = tnr.scale_cl[i];
2239 }
2240 for(i = 0; i < TNR_SCALE_Y2CL_SIZE; i++) {
2241 pTnrCfg->scale_y2cl[i] = tnr.scale_y2cl[i];
2242 }
2243 //0x0158
2244 for(i = 0; i < TNR_WEIGHT_Y_SIZE; i++) {
2245 pTnrCfg->weight_y[i] = tnr.weight_y[i];
2246 }
2247
2248 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) exit \n", __FUNCTION__, __LINE__);
2249 }
2250
2251 template<typename T>
convertAiqUvnrToIsp20Params(T & pp_cfg,rk_aiq_isp_uvnr_t & uvnr)2252 void Isp20Params::convertAiqUvnrToIsp20Params(T &pp_cfg,
2253 rk_aiq_isp_uvnr_t& uvnr)
2254 {
2255 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) enter \n", __FUNCTION__, __LINE__);
2256
2257 int i = 0;
2258 struct rkispp_nr_config * pNrCfg = &pp_cfg.nr_cfg;
2259
2260 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "uvnr_en %d", uvnr.uvnr_en);
2261 if(uvnr.uvnr_en) {
2262 pp_cfg.head.module_ens |= ISPP_MODULE_NR;
2263 //pp_cfg.head.module_init_ens |= ISPP_MODULE_NR;
2264 } else {
2265 // NR bit used by ynr and uvnr together, so couldn't be
2266 // disabled if it was enabled
2267 if (!(pp_cfg.head.module_ens & ISPP_MODULE_NR))
2268 pp_cfg.head.module_ens &= ~ISPP_MODULE_NR;
2269 }
2270
2271 pp_cfg.head.module_en_update |= ISPP_MODULE_NR;
2272 pp_cfg.head.module_cfg_update |= ISPP_MODULE_NR;
2273
2274 //0x0080
2275 pNrCfg->uvnr_step1_en = uvnr.uvnr_step1_en;
2276 pNrCfg->uvnr_step2_en = uvnr.uvnr_step2_en;
2277 pNrCfg->nr_gain_en = uvnr.nr_gain_en;
2278 pNrCfg->uvnr_nobig_en = uvnr.uvnr_nobig_en;
2279 pNrCfg->uvnr_big_en = uvnr.uvnr_big_en;
2280
2281
2282 //0x0084
2283 pNrCfg->uvnr_gain_1sigma = uvnr.uvnr_gain_1sigma;
2284
2285 //0x0088
2286 pNrCfg->uvnr_gain_offset = uvnr.uvnr_gain_offset;
2287
2288 //0x008c
2289 pNrCfg->uvnr_gain_uvgain[0] = uvnr.uvnr_gain_uvgain[0];
2290 pNrCfg->uvnr_gain_uvgain[1] = uvnr.uvnr_gain_uvgain[1];
2291 pNrCfg->uvnr_gain_t2gen = uvnr.uvnr_gain_t2gen;
2292 // no need set
2293 pNrCfg->uvnr_gain_iso = uvnr.uvnr_gain_iso;
2294
2295 //0x0090
2296 pNrCfg->uvnr_t1gen_m3alpha = uvnr.uvnr_t1gen_m3alpha;
2297
2298 //0x0094
2299 pNrCfg->uvnr_t1flt_mode = uvnr.uvnr_t1flt_mode;
2300
2301 //0x0098
2302 pNrCfg->uvnr_t1flt_msigma = uvnr.uvnr_t1flt_msigma;
2303
2304 //0x009c
2305 pNrCfg->uvnr_t1flt_wtp = uvnr.uvnr_t1flt_wtp;
2306
2307 //0x00a0-0x00a4
2308 for(i = 0; i < NR_UVNR_T1FLT_WTQ_SIZE; i++) {
2309 pNrCfg->uvnr_t1flt_wtq[i] = uvnr.uvnr_t1flt_wtq[i];
2310 }
2311
2312 //0x00a8
2313 pNrCfg->uvnr_t2gen_m3alpha = uvnr.uvnr_t2gen_m3alpha;
2314
2315 //0x00ac
2316 pNrCfg->uvnr_t2gen_msigma = uvnr.uvnr_t2gen_msigma;
2317
2318 //0x00b0
2319 pNrCfg->uvnr_t2gen_wtp = uvnr.uvnr_t2gen_wtp;
2320
2321 //0x00b4
2322 for(i = 0; i < NR_UVNR_T2GEN_WTQ_SIZE; i++) {
2323 pNrCfg->uvnr_t2gen_wtq[i] = uvnr.uvnr_t2gen_wtq[i];
2324 }
2325
2326 //0x00b8
2327 pNrCfg->uvnr_t2flt_msigma = uvnr.uvnr_t2flt_msigma;
2328
2329 //0x00bc
2330 pNrCfg->uvnr_t2flt_wtp = uvnr.uvnr_t2flt_wtp;
2331 for(i = 0; i < NR_UVNR_T2FLT_WT_SIZE; i++) {
2332 pNrCfg->uvnr_t2flt_wt[i] = uvnr.uvnr_t2flt_wt[i];
2333 }
2334
2335
2336 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) exit \n", __FUNCTION__, __LINE__);
2337 }
2338
2339
2340 template<typename T>
convertAiqYnrToIsp20Params(T & pp_cfg,rk_aiq_isp_ynr_t & ynr)2341 void Isp20Params::convertAiqYnrToIsp20Params(T &pp_cfg,
2342 rk_aiq_isp_ynr_t& ynr)
2343 {
2344 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) enter \n", __FUNCTION__, __LINE__);
2345
2346 int i = 0;
2347 struct rkispp_nr_config * pNrCfg = &pp_cfg.nr_cfg;
2348
2349 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "ynr_en %d", ynr.ynr_en);
2350 if(ynr.ynr_en) {
2351 pp_cfg.head.module_ens |= ISPP_MODULE_NR;
2352 //pp_cfg.head.module_init_ens |= ISPP_MODULE_NR;
2353 } else {
2354 // NR bit used by ynr and uvnr together, so couldn't be
2355 // disabled if it was enabled
2356 if (!(pp_cfg.head.module_ens & ISPP_MODULE_NR))
2357 pp_cfg.head.module_ens &= ~ISPP_MODULE_NR;
2358 }
2359
2360 pp_cfg.head.module_en_update |= ISPP_MODULE_NR;
2361 pp_cfg.head.module_cfg_update |= ISPP_MODULE_NR;
2362
2363 //0x0104 - 0x0108
2364 for(i = 0; i < NR_YNR_SGM_DX_SIZE; i++) {
2365 pNrCfg->ynr_sgm_dx[i] = ynr.ynr_sgm_dx[i];
2366 }
2367
2368 //0x010c - 0x012c
2369 for(i = 0; i < NR_YNR_SGM_Y_SIZE; i++) {
2370 pNrCfg->ynr_lsgm_y[i] = ynr.ynr_lsgm_y[i];
2371 }
2372
2373
2374 //0x0130
2375 for(i = 0; i < NR_YNR_CI_SIZE; i++) {
2376 pNrCfg->ynr_lci[i] = ynr.ynr_lci[i];
2377 }
2378
2379 //0x0134
2380 for(i = 0; i < NR_YNR_LGAIN_MIN_SIZE; i++) {
2381 pNrCfg->ynr_lgain_min[i] = ynr.ynr_lgain_min[i];
2382 }
2383
2384 //0x0138
2385 pNrCfg->ynr_lgain_max = ynr.ynr_lgain_max;
2386
2387
2388 //0x013c
2389 pNrCfg->ynr_lmerge_bound = ynr.ynr_lmerge_bound;
2390 pNrCfg->ynr_lmerge_ratio = ynr.ynr_lmerge_ratio;
2391
2392 //0x0140
2393 for(i = 0; i < NR_YNR_LWEIT_FLT_SIZE; i++) {
2394 pNrCfg->ynr_lweit_flt[i] = ynr.ynr_lweit_flt[i];
2395 }
2396
2397 //0x0144 - 0x0164
2398 for(i = 0; i < NR_YNR_SGM_Y_SIZE; i++) {
2399 pNrCfg->ynr_hsgm_y[i] = ynr.ynr_hsgm_y[i];
2400 }
2401
2402 //0x0168
2403 for(i = 0; i < NR_YNR_CI_SIZE; i++) {
2404 pNrCfg->ynr_hlci[i] = ynr.ynr_hlci[i];
2405 }
2406
2407 //0x016c
2408 for(i = 0; i < NR_YNR_CI_SIZE; i++) {
2409 pNrCfg->ynr_lhci[i] = ynr.ynr_lhci[i];
2410 }
2411
2412 //0x0170
2413 for(i = 0; i < NR_YNR_CI_SIZE; i++) {
2414 pNrCfg->ynr_hhci[i] = ynr.ynr_hhci[i];
2415 }
2416
2417 //0x0174
2418 for(i = 0; i < NR_YNR_HGAIN_SGM_SIZE; i++) {
2419 pNrCfg->ynr_hgain_sgm[i] = ynr.ynr_hgain_sgm[i];
2420 }
2421
2422 //0x0178 - 0x0188
2423 for(i = 0; i < NR_YNR_HWEIT_D_SIZE; i++) {
2424 pNrCfg->ynr_hweit_d[i] = ynr.ynr_hweit_d[i];
2425 }
2426
2427
2428 //0x018c - 0x01a0
2429 for(i = 0; i < NR_YNR_HGRAD_Y_SIZE; i++) {
2430 pNrCfg->ynr_hgrad_y[i] = ynr.ynr_hgrad_y[i];
2431 }
2432
2433 //0x01a4 -0x01a8
2434 for(i = 0; i < NR_YNR_HWEIT_SIZE; i++) {
2435 pNrCfg->ynr_hweit[i] = ynr.ynr_hweit[i];
2436 }
2437
2438 //0x01b0
2439 pNrCfg->ynr_hmax_adjust = ynr.ynr_hmax_adjust;
2440
2441 //0x01b4
2442 pNrCfg->ynr_hstrength = ynr.ynr_hstrength;
2443
2444 //0x01b8
2445 pNrCfg->ynr_lweit_cmp[0] = ynr.ynr_lweit_cmp[0];
2446 pNrCfg->ynr_lweit_cmp[1] = ynr.ynr_lweit_cmp[1];
2447
2448
2449 //0x01bc
2450 pNrCfg->ynr_lmaxgain_lv4 = ynr.ynr_lmaxgain_lv4;
2451
2452 //0x01c0 - 0x01e0
2453 for(i = 0; i < NR_YNR_HSTV_Y_SIZE; i++) {
2454 pNrCfg->ynr_hstv_y[i] = ynr.ynr_hstv_y[i];
2455 }
2456
2457 //0x01e4 - 0x01e8
2458 for(i = 0; i < NR_YNR_ST_SCALE_SIZE; i++) {
2459 pNrCfg->ynr_st_scale[i] = ynr.ynr_st_scale[i];
2460 }
2461
2462 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) exit \n", __FUNCTION__, __LINE__);
2463
2464 }
2465
2466 template<typename T>
convertAiqSharpenToIsp20Params(T & pp_cfg,rk_aiq_isp_sharpen_t & sharp,rk_aiq_isp_edgeflt_t & edgeflt)2467 void Isp20Params::convertAiqSharpenToIsp20Params(T &pp_cfg,
2468 rk_aiq_isp_sharpen_t& sharp, rk_aiq_isp_edgeflt_t& edgeflt)
2469 {
2470 int i = 0;
2471 struct rkispp_sharp_config * pSharpCfg = &pp_cfg.shp_cfg;
2472 RKAsharp_Sharp_HW_Fix_t *pSharpV1 = &sharp.stSharpFixV1;
2473
2474 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "sharp_en %d edgeflt_en %d", pSharpV1->sharp_en, edgeflt.edgeflt_en);
2475
2476 if(pSharpV1->sharp_en && edgeflt.edgeflt_en) {
2477 pp_cfg.head.module_ens |= ISPP_MODULE_SHP;
2478 //pp_cfg.head.module_init_ens |= ISPP_MODULE_SHP;
2479 } else {
2480 pp_cfg.head.module_ens &= ~ISPP_MODULE_SHP;
2481 }
2482
2483 pp_cfg.head.module_en_update |= ISPP_MODULE_SHP;
2484 pp_cfg.head.module_cfg_update |= ISPP_MODULE_SHP;
2485 #if 1
2486 //0x0080
2487 pSharpCfg->alpha_adp_en = edgeflt.alpha_adp_en;
2488 pSharpCfg->yin_flt_en = pSharpV1->yin_flt_en;
2489 pSharpCfg->edge_avg_en = pSharpV1->edge_avg_en;
2490
2491 //0x0084
2492 pSharpCfg->hbf_ratio = pSharpV1->hbf_ratio;
2493 pSharpCfg->ehf_th = pSharpV1->ehf_th;
2494 pSharpCfg->pbf_ratio = pSharpV1->pbf_ratio;
2495
2496 //0x0088
2497 pSharpCfg->edge_thed = edgeflt.edge_thed;
2498 pSharpCfg->dir_min = edgeflt.dir_min;
2499 pSharpCfg->smoth_th4 = edgeflt.smoth_th4;
2500
2501 //0x008c
2502 pSharpCfg->l_alpha = edgeflt.l_alpha;
2503 pSharpCfg->g_alpha = edgeflt.g_alpha;
2504
2505
2506 //0x0090
2507 for(i = 0; i < SHP_PBF_KERNEL_SIZE; i++) {
2508 pSharpCfg->pbf_k[i] = pSharpV1->pbf_k[i];
2509 }
2510
2511 //0x0094 - 0x0098
2512 for(i = 0; i < SHP_MRF_KERNEL_SIZE; i++) {
2513 pSharpCfg->mrf_k[i] = pSharpV1->mrf_k[i];
2514 }
2515
2516 //0x009c -0x00a4
2517 for(i = 0; i < SHP_MBF_KERNEL_SIZE; i++) {
2518 pSharpCfg->mbf_k[i] = pSharpV1->mbf_k[i];
2519 }
2520
2521 //0x00a8 -0x00ac
2522 for(i = 0; i < SHP_HRF_KERNEL_SIZE; i++) {
2523 pSharpCfg->hrf_k[i] = pSharpV1->hrf_k[i];
2524 }
2525
2526 //0x00b0
2527 for(i = 0; i < SHP_HBF_KERNEL_SIZE; i++) {
2528 pSharpCfg->hbf_k[i] = pSharpV1->hbf_k[i];
2529 }
2530
2531 //0x00b4
2532 for(i = 0; i < SHP_EDGE_COEF_SIZE; i++) {
2533 pSharpCfg->eg_coef[i] = edgeflt.eg_coef[i];
2534 }
2535
2536 //0x00b8
2537 for(i = 0; i < SHP_EDGE_SMOTH_SIZE; i++) {
2538 pSharpCfg->eg_smoth[i] = edgeflt.eg_smoth[i];
2539 }
2540
2541 //0x00bc - 0x00c0
2542 for(i = 0; i < SHP_EDGE_GAUS_SIZE; i++) {
2543 pSharpCfg->eg_gaus[i] = edgeflt.eg_gaus[i];
2544 }
2545
2546 //0x00c4 - 0x00c8
2547 for(i = 0; i < SHP_DOG_KERNEL_SIZE; i++) {
2548 pSharpCfg->dog_k[i] = edgeflt.dog_k[i];
2549 }
2550
2551 //0x00cc - 0x00d0
2552 for(i = 0; i < 6; i++) {
2553 pSharpCfg->lum_point[i] = pSharpV1->lum_point[i];
2554 }
2555
2556 //0x00d4
2557 pSharpCfg->pbf_shf_bits = pSharpV1->pbf_shf_bits;
2558 pSharpCfg->mbf_shf_bits = pSharpV1->mbf_shf_bits;
2559 pSharpCfg->hbf_shf_bits = pSharpV1->hbf_shf_bits;
2560
2561
2562 //0x00d8 - 0x00dc
2563 for(i = 0; i < 8; i++) {
2564 pSharpCfg->pbf_sigma[i] = pSharpV1->pbf_sigma[i];
2565 }
2566
2567 //0x00e0 - 0x00e4
2568 for(i = 0; i < 8; i++) {
2569 pSharpCfg->lum_clp_m[i] = pSharpV1->lum_clp_m[i];
2570 }
2571
2572 //0x00e8 - 0x00ec
2573 for(i = 0; i < 8; i++) {
2574 pSharpCfg->lum_min_m[i] = pSharpV1->lum_min_m[i];
2575 }
2576
2577 //0x00f0 - 0x00f4
2578 for(i = 0; i < 8; i++) {
2579 pSharpCfg->mbf_sigma[i] = pSharpV1->mbf_sigma[i];
2580 }
2581
2582 //0x00f8 - 0x00fc
2583 for(i = 0; i < 8; i++) {
2584 pSharpCfg->lum_clp_h[i] = pSharpV1->lum_clp_h[i];
2585 }
2586
2587 //0x0100 - 0x0104
2588 for(i = 0; i < 8; i++) {
2589 pSharpCfg->hbf_sigma[i] = pSharpV1->hbf_sigma[i];
2590 }
2591
2592 //0x0108 - 0x010c
2593 for(i = 0; i < 8; i++) {
2594 pSharpCfg->edge_lum_thed[i] = edgeflt.edge_lum_thed[i];
2595 }
2596
2597 //0x0110 - 0x0114
2598 for(i = 0; i < 8; i++) {
2599 pSharpCfg->clamp_pos[i] = edgeflt.clamp_pos[i];
2600 }
2601
2602 //0x0118 - 0x011c
2603 for(i = 0; i < 8; i++) {
2604 pSharpCfg->clamp_neg[i] = edgeflt.clamp_neg[i];
2605 }
2606
2607 //0x0120 - 0x0124
2608 for(i = 0; i < 8; i++) {
2609 pSharpCfg->detail_alpha[i] = edgeflt.detail_alpha[i];
2610 }
2611
2612 //0x0128
2613 pSharpCfg->rfl_ratio = pSharpV1->rfl_ratio;
2614 pSharpCfg->rfh_ratio = pSharpV1->rfh_ratio;
2615 //0x012C
2616 pSharpCfg->m_ratio = pSharpV1->m_ratio;
2617 pSharpCfg->h_ratio = pSharpV1->h_ratio;
2618 #endif
2619 }
2620 #endif
2621
2622 template<class T>
2623 void
convertAiqGainToIsp20Params(T & isp_cfg,rk_aiq_isp_gain_t & gain)2624 Isp20Params::convertAiqGainToIsp20Params(T& isp_cfg,
2625 rk_aiq_isp_gain_t& gain)
2626 {
2627 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) enter \n", __FUNCTION__, __LINE__);
2628
2629 int i = 0;
2630 struct isp2x_gain_cfg * pGainCfg = &isp_cfg.others.gain_cfg;
2631
2632 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "gain table en %d \n", gain.gain_table_en);
2633 if(gain.gain_table_en) {
2634 isp_cfg.module_ens |= ISP2X_MODULE_GAIN;
2635 isp_cfg.module_en_update |= ISP2X_MODULE_GAIN;
2636 isp_cfg.module_cfg_update |= ISP2X_MODULE_GAIN;
2637 }
2638
2639 #if 0
2640 pGainCfg->dhaz_en = 0;
2641 pGainCfg->wdr_en = 0;
2642 pGainCfg->tmo_en = 0;
2643 pGainCfg->lsc_en = 0;
2644 pGainCfg->mge_en = 0;
2645
2646 if(isp_cfg.module_ens & ISP2X_MODULE_DHAZ) {
2647 pGainCfg->dhaz_en = 1;
2648 }
2649
2650 if(isp_cfg.module_ens & ISP2X_MODULE_WDR) {
2651 pGainCfg->wdr_en = 1;
2652 }
2653
2654 if(isp_cfg.others.hdrmge_cfg.mode) {
2655 pGainCfg->tmo_en = 1;
2656 pGainCfg->mge_en = 1;
2657 }
2658
2659 if(isp_cfg.module_ens & ISP2X_MODULE_LSC) {
2660 pGainCfg->lsc_en = 1;
2661 }
2662
2663
2664 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:%d gain en: %d %d %d %d %d\n",
2665 __FUNCTION__, __LINE__,
2666 pGainCfg->dhaz_en, pGainCfg->wdr_en,
2667 pGainCfg->tmo_en, pGainCfg->lsc_en,
2668 pGainCfg->mge_en);
2669 #endif
2670
2671 for(i = 0; i < ISP2X_GAIN_HDRMGE_GAIN_NUM; i++) {
2672 pGainCfg->mge_gain[i] = gain.mge_gain[i];
2673 }
2674
2675 for(i = 0; i < ISP2X_GAIN_IDX_NUM; i++) {
2676 pGainCfg->idx[i] = gain.idx[i];
2677 }
2678
2679 for(i = 0; i < ISP2X_GAIN_LUT_NUM; i++) {
2680 pGainCfg->lut[i] = gain.lut[i];
2681 }
2682
2683 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "%s:(%d) exit \n", __FUNCTION__, __LINE__);
2684 }
2685
2686
2687 template<typename T>
convertAiqFecToIsp20Params(T & pp_cfg,rk_aiq_isp_fec_t & fec)2688 void Isp20Params::convertAiqFecToIsp20Params(T &pp_cfg,
2689 rk_aiq_isp_fec_t& fec)
2690 {
2691 /* FEC module can't be enable/disable dynamically, the mode should
2692 * be decided in init params. we'll check if the module_init_ens
2693 * changed in CamIsp20Hw.cpp
2694 */
2695
2696 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "fec update params, enable %d usage %d", fec.sw_fec_en, fec.usage);
2697 if(fec.sw_fec_en) {
2698 if (fec.usage == ISPP_MODULE_FEC_ST) {
2699 pp_cfg.head.module_ens |= ISPP_MODULE_FEC_ST;
2700 pp_cfg.head.module_en_update |= ISPP_MODULE_FEC_ST;
2701 } else if (fec.usage == ISPP_MODULE_FEC) {
2702 pp_cfg.head.module_ens |= ISPP_MODULE_FEC;
2703 pp_cfg.head.module_en_update |= ISPP_MODULE_FEC;
2704 }
2705
2706 if (/*!fec.config*/0) {
2707 pp_cfg.head.module_cfg_update &= ~ISPP_MODULE_FEC;
2708 } else {
2709 struct rkispp_fec_config *pFecCfg = &pp_cfg.fec_cfg;
2710
2711 pFecCfg->crop_en = fec.crop_en;
2712 pFecCfg->crop_width = fec.crop_width;
2713 pFecCfg->crop_height = fec.crop_height;
2714 pFecCfg->mesh_density = fec.mesh_density;
2715 pFecCfg->mesh_size = fec.mesh_size;
2716 pFecCfg->buf_fd = fec.mesh_buf_fd;
2717 //pp_cfg.fec_output_buf_index = fec.img_buf_index;
2718 //pp_cfg.fec_output_buf_size = fec.img_buf_size;
2719
2720 pp_cfg.head.module_cfg_update |= ISPP_MODULE_FEC;
2721 }
2722 } else {
2723 pp_cfg.head.module_ens &= ~(ISPP_MODULE_FEC_ST | ISPP_MODULE_FEC);
2724 pp_cfg.head.module_en_update |= (ISPP_MODULE_FEC_ST | ISPP_MODULE_FEC);
2725 }
2726 }
2727
2728 XCamReturn
checkIsp20Params(struct isp2x_isp_params_cfg & isp_cfg)2729 Isp20Params::checkIsp20Params(struct isp2x_isp_params_cfg& isp_cfg)
2730 {
2731 //TODO
2732 return XCAM_RETURN_NO_ERROR;
2733 }
2734
2735 template<class T>
2736 void
convertAiqAdemosaicToIsp20Params(T & isp_cfg,rk_aiq_isp_debayer_t & demosaic)2737 Isp20Params::convertAiqAdemosaicToIsp20Params(T& isp_cfg, rk_aiq_isp_debayer_t &demosaic)
2738 {
2739 if (demosaic.updatecfg) {
2740 if (demosaic.enable) {
2741 isp_cfg.module_ens |= ISP2X_MODULE_DEBAYER;
2742 isp_cfg.module_en_update |= ISP2X_MODULE_DEBAYER;
2743 isp_cfg.module_cfg_update |= ISP2X_MODULE_DEBAYER;
2744 } else {
2745 isp_cfg.module_ens &= ~ISP2X_MODULE_DEBAYER;
2746 isp_cfg.module_en_update |= ISP2X_MODULE_DEBAYER;
2747 }
2748 } else {
2749 return;
2750 }
2751
2752 isp_cfg.others.debayer_cfg.clip_en = demosaic.clip_en;
2753 isp_cfg.others.debayer_cfg.filter_c_en = demosaic.filter_c_en;
2754 isp_cfg.others.debayer_cfg.filter_g_en = demosaic.filter_g_en;
2755 isp_cfg.others.debayer_cfg.gain_offset = demosaic.gain_offset;
2756 isp_cfg.others.debayer_cfg.offset = demosaic.offset;
2757 isp_cfg.others.debayer_cfg.hf_offset = demosaic.hf_offset;
2758 isp_cfg.others.debayer_cfg.thed0 = demosaic.thed0;
2759 isp_cfg.others.debayer_cfg.thed1 = demosaic.thed1;
2760 isp_cfg.others.debayer_cfg.dist_scale = demosaic.dist_scale;
2761 isp_cfg.others.debayer_cfg.shift_num = demosaic.shift_num;
2762 isp_cfg.others.debayer_cfg.filter1_coe1 = demosaic.filter1_coe[0];
2763 isp_cfg.others.debayer_cfg.filter1_coe2 = demosaic.filter1_coe[1];
2764 isp_cfg.others.debayer_cfg.filter1_coe3 = demosaic.filter1_coe[2];
2765 isp_cfg.others.debayer_cfg.filter1_coe4 = demosaic.filter1_coe[3];
2766 isp_cfg.others.debayer_cfg.filter1_coe5 = demosaic.filter1_coe[4];
2767 isp_cfg.others.debayer_cfg.filter2_coe1 = demosaic.filter2_coe[0];
2768 isp_cfg.others.debayer_cfg.filter2_coe2 = demosaic.filter2_coe[1];
2769 isp_cfg.others.debayer_cfg.filter2_coe3 = demosaic.filter2_coe[2];
2770 isp_cfg.others.debayer_cfg.filter2_coe4 = demosaic.filter2_coe[3];
2771 isp_cfg.others.debayer_cfg.filter2_coe5 = demosaic.filter2_coe[4];
2772 isp_cfg.others.debayer_cfg.max_ratio = demosaic.max_ratio;
2773 isp_cfg.others.debayer_cfg.order_max = demosaic.order_max;
2774 isp_cfg.others.debayer_cfg.order_min = demosaic.order_min;
2775 }
2776 #if RKAIQ_HAVE_ACP_V10
2777 template<class T>
2778 void
convertAiqCpToIsp20Params(T & isp_cfg,const rk_aiq_acp_params_t & cp_cfg)2779 Isp20Params::convertAiqCpToIsp20Params(T& isp_cfg,
2780 const rk_aiq_acp_params_t& cp_cfg)
2781 {
2782 struct isp2x_cproc_cfg* cproc_cfg = &isp_cfg.others.cproc_cfg;
2783
2784 // TODO: set range
2785 /* cproc_cfg->y_in_range = 1; */
2786 /* cproc_cfg->y_out_range = 1; */
2787 /* cproc_cfg->c_out_range = 1; */
2788
2789 if (cp_cfg.enable) {
2790 isp_cfg.module_ens |= ISP2X_MODULE_CPROC;
2791 isp_cfg.module_en_update |= ISP2X_MODULE_CPROC;
2792 isp_cfg.module_cfg_update |= ISP2X_MODULE_CPROC;
2793 } else {
2794 isp_cfg.module_ens &= ~ISP2X_MODULE_CPROC;
2795 isp_cfg.module_en_update |= ISP2X_MODULE_CPROC;
2796 }
2797
2798 cproc_cfg->contrast = (uint8_t)(cp_cfg.contrast);
2799 cproc_cfg->sat = (uint8_t)(cp_cfg.saturation);
2800 cproc_cfg->brightness = (uint8_t)(cp_cfg.brightness - 128);
2801 cproc_cfg->hue = (uint8_t)(cp_cfg.hue - 128);
2802 }
2803 #endif
2804 #if RKAIQ_HAVE_AIE_V10
2805 template<class T>
2806 void
convertAiqIeToIsp20Params(T & isp_cfg,const rk_aiq_isp_ie_t & ie_cfg)2807 Isp20Params::convertAiqIeToIsp20Params(T& isp_cfg,
2808 const rk_aiq_isp_ie_t& ie_cfg)
2809 {
2810 struct isp2x_ie_cfg* ie_config = &isp_cfg.others.ie_cfg;
2811
2812 isp_cfg.module_ens |= ISP2X_MODULE_IE;
2813 isp_cfg.module_en_update |= ISP2X_MODULE_IE;
2814 isp_cfg.module_cfg_update |= ISP2X_MODULE_IE;
2815
2816 switch (ie_cfg.base.mode) {
2817 case RK_AIQ_IE_EFFECT_BW:
2818 ie_config->effect = V4L2_COLORFX_BW;
2819 break;
2820 case RK_AIQ_IE_EFFECT_NEGATIVE:
2821 ie_config->effect = V4L2_COLORFX_NEGATIVE;
2822 break;
2823 case RK_AIQ_IE_EFFECT_SEPIA:
2824 ie_config->effect = V4L2_COLORFX_SEPIA;
2825 break;
2826 case RK_AIQ_IE_EFFECT_EMBOSS:
2827 {
2828 ie_config->effect = V4L2_COLORFX_EMBOSS;
2829 ie_config->eff_mat_1 = (uint16_t)(ie_cfg.extra.mode_coeffs[0])
2830 | ((uint16_t)(ie_cfg.extra.mode_coeffs[1]) << 0x4)
2831 | ((uint16_t)(ie_cfg.extra.mode_coeffs[2]) << 0x8)
2832 | ((uint16_t)(ie_cfg.extra.mode_coeffs[3]) << 0xc);
2833 ie_config->eff_mat_2 = (uint16_t)(ie_cfg.extra.mode_coeffs[4])
2834 | ((uint16_t)(ie_cfg.extra.mode_coeffs[5]) << 0x4)
2835 | ((uint16_t)(ie_cfg.extra.mode_coeffs[6]) << 0x8)
2836 | ((uint16_t)(ie_cfg.extra.mode_coeffs[7]) << 0xc);
2837 ie_config->eff_mat_3 = (ie_cfg.extra.mode_coeffs[8]);
2838 /*not used for this effect*/
2839 ie_config->eff_mat_4 = 0;
2840 ie_config->eff_mat_5 = 0;
2841 ie_config->color_sel = 0;
2842 ie_config->eff_tint = 0;
2843 }
2844 break;
2845 case RK_AIQ_IE_EFFECT_SKETCH:
2846 {
2847 ie_config->effect = V4L2_COLORFX_SKETCH;
2848 ie_config->eff_mat_3 = ((uint16_t)(ie_cfg.extra.mode_coeffs[0]) << 0x4)
2849 | ((uint16_t)(ie_cfg.extra.mode_coeffs[1]) << 0x8)
2850 | ((uint16_t)(ie_cfg.extra.mode_coeffs[2]) << 0xc);
2851 /*not used for this effect*/
2852 ie_config->eff_mat_4 = (uint16_t)(ie_cfg.extra.mode_coeffs[3])
2853 | ((uint16_t)(ie_cfg.extra.mode_coeffs[4]) << 0x4)
2854 | ((uint16_t)(ie_cfg.extra.mode_coeffs[5]) << 0x8)
2855 | ((uint16_t)(ie_cfg.extra.mode_coeffs[6]) << 0xc);
2856 ie_config->eff_mat_5 = (uint16_t)(ie_cfg.extra.mode_coeffs[7])
2857 | ((uint16_t)(ie_cfg.extra.mode_coeffs[8]) << 0x4);
2858
2859 /*not used for this effect*/
2860 ie_config->eff_mat_1 = 0;
2861 ie_config->eff_mat_2 = 0;
2862 ie_config->color_sel = 0;
2863 ie_config->eff_tint = 0;
2864 }
2865 break;
2866 case RK_AIQ_IE_EFFECT_SHARPEN:
2867 {
2868 /* TODO: can't find related mode in v4l2_colorfx*/
2869 //ie_config->effect =
2870 // V4L2_COLORFX_EMBOSS;
2871 ie_config->eff_mat_1 = (uint16_t)(ie_cfg.extra.mode_coeffs[0])
2872 | ((uint16_t)(ie_cfg.extra.mode_coeffs[1]) << 0x4)
2873 | ((uint16_t)(ie_cfg.extra.mode_coeffs[2]) << 0x8)
2874 | ((uint16_t)(ie_cfg.extra.mode_coeffs[3]) << 0xc);
2875 ie_config->eff_mat_2 = (uint16_t)(ie_cfg.extra.mode_coeffs[4])
2876 | ((uint16_t)(ie_cfg.extra.mode_coeffs[5]) << 0x4)
2877 | ((uint16_t)(ie_cfg.extra.mode_coeffs[6]) << 0x8)
2878 | ((uint16_t)(ie_cfg.extra.mode_coeffs[7]) << 0xc);
2879 ie_config->eff_mat_3 = (ie_cfg.extra.mode_coeffs[8]);
2880 /*not used for this effect*/
2881 ie_config->eff_mat_4 = 0;
2882 ie_config->eff_mat_5 = 0;
2883 ie_config->color_sel = 0;
2884 ie_config->eff_tint = 0;
2885 }
2886 break;
2887 case RK_AIQ_IE_EFFECT_NONE:
2888 {
2889 isp_cfg.module_ens &= ~ISP2X_MODULE_IE;
2890 isp_cfg.module_en_update |= ISP2X_MODULE_IE;
2891 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_IE;
2892 }
2893 break;
2894 default:
2895 break;
2896 }
2897 }
2898 #endif
2899 template<class T>
2900 void
convertAiqAldchToIsp20Params(T & isp_cfg,const rk_aiq_isp_ldch_t & ldch_cfg)2901 Isp20Params::convertAiqAldchToIsp20Params(T& isp_cfg,
2902 const rk_aiq_isp_ldch_t& ldch_cfg)
2903 {
2904 struct isp2x_ldch_cfg *pLdchCfg = &isp_cfg.others.ldch_cfg;
2905
2906 // TODO: add update flag for ldch
2907 if (ldch_cfg.sw_ldch_en) {
2908 isp_cfg.module_ens |= ISP2X_MODULE_LDCH;
2909 isp_cfg.module_en_update |= ISP2X_MODULE_LDCH;
2910 isp_cfg.module_cfg_update |= ISP2X_MODULE_LDCH;
2911
2912 pLdchCfg->hsize = ldch_cfg.lut_h_size;
2913 pLdchCfg->vsize = ldch_cfg.lut_v_size;
2914 pLdchCfg->buf_fd = ldch_cfg.lut_mapxy_buf_fd;
2915 } else {
2916 isp_cfg.module_ens &= ~ISP2X_MODULE_LDCH;
2917 isp_cfg.module_en_update |= ISP2X_MODULE_LDCH;
2918 }
2919 }
2920
2921 template<class T>
2922 void
convertAiqGicToIsp20Params(T & isp_cfg,const rk_aiq_isp_gic_t & gic_cfg)2923 Isp20Params::convertAiqGicToIsp20Params(T& isp_cfg,
2924 const rk_aiq_isp_gic_t& gic_cfg)
2925 {
2926 struct isp2x_gic_cfg *isp_gic_cfg = &isp_cfg.others.gic_cfg;
2927
2928 if (gic_cfg.gic_en) {
2929 isp_cfg.module_ens |= ISP2X_MODULE_GIC;
2930 isp_cfg.module_en_update |= ISP2X_MODULE_GIC;
2931 isp_cfg.module_cfg_update |= ISP2X_MODULE_GIC;
2932 } else {
2933 isp_cfg.module_ens &= ~ISP2X_MODULE_GIC;
2934 isp_cfg.module_en_update |= ISP2X_MODULE_GIC;
2935 }
2936
2937 isp_gic_cfg->edge_open = gic_cfg.ProcResV20.edge_open;
2938 isp_gic_cfg->regmingradthrdark2 = gic_cfg.ProcResV20.regmingradthrdark2;
2939 isp_gic_cfg->regmingradthrdark1 = gic_cfg.ProcResV20.regmingradthrdark1;
2940 isp_gic_cfg->regminbusythre = gic_cfg.ProcResV20.regminbusythre;
2941 isp_gic_cfg->regdarkthre = gic_cfg.ProcResV20.regdarkthre;
2942 isp_gic_cfg->regmaxcorvboth = gic_cfg.ProcResV20.regmaxcorvboth;
2943 isp_gic_cfg->regdarktthrehi = gic_cfg.ProcResV20.regdarktthrehi;
2944 isp_gic_cfg->regkgrad2dark = gic_cfg.ProcResV20.regkgrad2dark;
2945 isp_gic_cfg->regkgrad1dark = gic_cfg.ProcResV20.regkgrad1dark;
2946 isp_gic_cfg->regstrengthglobal_fix = gic_cfg.ProcResV20.regstrengthglobal_fix;
2947 isp_gic_cfg->regdarkthrestep = gic_cfg.ProcResV20.regdarkthrestep;
2948 isp_gic_cfg->regkgrad2 = gic_cfg.ProcResV20.regkgrad2;
2949 isp_gic_cfg->regkgrad1 = gic_cfg.ProcResV20.regkgrad1;
2950 isp_gic_cfg->reggbthre = gic_cfg.ProcResV20.reggbthre;
2951 isp_gic_cfg->regmaxcorv = gic_cfg.ProcResV20.regmaxcorv;
2952 isp_gic_cfg->regmingradthr2 = gic_cfg.ProcResV20.regmingradthr2;
2953 isp_gic_cfg->regmingradthr1 = gic_cfg.ProcResV20.regmingradthr1;
2954 isp_gic_cfg->gr_ratio = gic_cfg.ProcResV20.gr_ratio;
2955 isp_gic_cfg->dnhiscale = gic_cfg.ProcResV20.dnhiscale;
2956 isp_gic_cfg->dnloscale = gic_cfg.ProcResV20.dnloscale;
2957 isp_gic_cfg->reglumapointsstep = gic_cfg.ProcResV20.reglumapointsstep;
2958 isp_gic_cfg->gvaluelimithi = gic_cfg.ProcResV20.gvaluelimithi;
2959 isp_gic_cfg->gvaluelimitlo = gic_cfg.ProcResV20.gvaluelimitlo;
2960 isp_gic_cfg->fusionratiohilimt1 = gic_cfg.ProcResV20.fusionratiohilimt1;
2961 isp_gic_cfg->regstrength_fix = gic_cfg.ProcResV20.regstrength_fix;
2962 isp_gic_cfg->noise_cut_en = gic_cfg.ProcResV20.noise_cut_en;
2963 isp_gic_cfg->noise_coe_a = gic_cfg.ProcResV20.noise_coe_a;
2964 isp_gic_cfg->noise_coe_b = gic_cfg.ProcResV20.noise_coe_b;
2965 isp_gic_cfg->diff_clip = gic_cfg.ProcResV20.diff_clip;
2966 for(int i = 0; i < 15; i++)
2967 isp_gic_cfg->sigma_y[i] = gic_cfg.ProcResV20.sigma_y[i];
2968 }
2969
2970 void
set_working_mode(int mode)2971 Isp20Params::set_working_mode(int mode)
2972 {
2973 _working_mode = mode;
2974 }
2975
2976 template<typename T>
convertAiqOrbToIsp20Params(T & pp_cfg,rk_aiq_isp_orb_t & orb)2977 void Isp20Params::convertAiqOrbToIsp20Params(T &pp_cfg,
2978 rk_aiq_isp_orb_t& orb)
2979 {
2980 if(orb.orb_en) {
2981 pp_cfg.head.module_ens |= ISPP_MODULE_ORB;
2982 pp_cfg.head.module_en_update |= ISPP_MODULE_ORB;
2983 pp_cfg.head.module_cfg_update |= ISPP_MODULE_ORB;
2984 //pp_cfg.head.module_init_ens |= ISPP_MODULE_ORB;
2985
2986 struct rkispp_orb_config *pOrbCfg = &pp_cfg.orb_cfg;
2987
2988 pOrbCfg->limit_value = orb.limit_value;
2989 pOrbCfg->max_feature = orb.max_feature;
2990 } else {
2991 pp_cfg.head.module_ens &= ~ISPP_MODULE_ORB;
2992 }
2993 }
2994
setModuleStatus(rk_aiq_module_id_t mId,bool en)2995 void Isp20Params::setModuleStatus(rk_aiq_module_id_t mId, bool en)
2996 {
2997 #define _ISP_MODULE_CFG_(id) \
2998 {\
2999 _force_module_flags |= 1LL << id;\
3000 if(en)\
3001 _force_isp_module_ens |= 1LL << id;\
3002 else\
3003 _force_isp_module_ens &= ~(1LL << id);\
3004 }
3005
3006 #define _ISPP_MODULE_CFG_(id, mod_en) \
3007 {\
3008 _force_module_flags |= 1LL << id;\
3009 if(en)\
3010 _force_ispp_module_ens |= mod_en;\
3011 else\
3012 _force_ispp_module_ens &= ~(mod_en);\
3013 }
3014
3015 SmartLock locker (_mutex);
3016 switch (mId) {
3017 case RK_MODULE_INVAL:
3018 break;
3019 case RK_MODULE_MAX:
3020 break;
3021 case RK_MODULE_FEC:
3022 break;
3023 case RK_MODULE_TNR:
3024 _ISPP_MODULE_CFG_(RK_ISP2X_PP_TNR_ID, ISPP_MODULE_TNR);
3025 break;
3026 case RK_MODULE_NR:
3027 _ISPP_MODULE_CFG_(RK_ISP2X_PP_NR_ID, ISPP_MODULE_NR);
3028 break;
3029 case RK_MODULE_RAWNR:
3030 _ISP_MODULE_CFG_(RK_ISP2X_RAWNR_ID);
3031 break;
3032 case RK_MODULE_DPCC:
3033 _ISP_MODULE_CFG_(RK_ISP2X_DPCC_ID);
3034 break;
3035 case RK_MODULE_BLS:
3036 _ISP_MODULE_CFG_(RK_ISP2X_BLS_ID);
3037 break;
3038 case RK_MODULE_LSC:
3039 _ISP_MODULE_CFG_(RK_ISP2X_LSC_ID);
3040 break;
3041 case RK_MODULE_CTK:
3042 _ISP_MODULE_CFG_(RK_ISP2X_CTK_ID);
3043 break;
3044 case RK_MODULE_AWB:
3045 _ISP_MODULE_CFG_(RK_ISP2X_RAWAWB_ID);
3046 break;
3047 case RK_MODULE_GOC:
3048 _ISP_MODULE_CFG_(RK_ISP2X_GOC_ID);
3049 break;
3050 case RK_MODULE_3DLUT:
3051 _ISP_MODULE_CFG_(RK_ISP2X_3DLUT_ID);
3052 break;
3053 case RK_MODULE_LDCH:
3054 _ISP_MODULE_CFG_(RK_ISP2X_LDCH_ID);
3055 break;
3056 case RK_MODULE_GIC:
3057 _ISP_MODULE_CFG_(RK_ISP2X_GIC_ID);
3058 break;
3059 case RK_MODULE_AWB_GAIN:
3060 _ISP_MODULE_CFG_(RK_ISP2X_GAIN_ID);
3061 break;
3062 case RK_MODULE_SHARP:
3063 _ISPP_MODULE_CFG_(RK_ISP2X_PP_TSHP_ID, ISPP_MODULE_SHP);
3064 break;
3065 case RK_MODULE_AE:
3066 break;
3067 //case RK_MODULE_DHAZ:
3068 // _ISP_MODULE_CFG_(RK_ISP2X_DHAZ_ID);
3069 //break;
3070 }
3071 }
3072
getModuleStatus(rk_aiq_module_id_t mId,bool & en)3073 void Isp20Params::getModuleStatus(rk_aiq_module_id_t mId, bool& en)
3074 {
3075 int mod_id = -1;
3076 switch (mId) {
3077 case RK_MODULE_INVAL:
3078 break;
3079 case RK_MODULE_MAX:
3080 break;
3081 case RK_MODULE_TNR:
3082 mod_id = RK_ISP2X_PP_TNR_ID;
3083 break;
3084 case RK_MODULE_RAWNR:
3085 mod_id = RK_ISP2X_RAWNR_ID;
3086 break;
3087 case RK_MODULE_DPCC:
3088 mod_id = RK_ISP2X_DPCC_ID;
3089 break;
3090 case RK_MODULE_BLS:
3091 mod_id = RK_ISP2X_BLS_ID;
3092 break;
3093 case RK_MODULE_LSC:
3094 mod_id = RK_ISP2X_LSC_ID;
3095 break;
3096 case RK_MODULE_CTK:
3097 mod_id = RK_ISP2X_CTK_ID;
3098 break;
3099 case RK_MODULE_AWB:
3100 mod_id = RK_ISP2X_RAWAWB_ID;
3101 break;
3102 case RK_MODULE_GOC:
3103 mod_id = RK_ISP2X_GOC_ID;
3104 break;
3105 case RK_MODULE_NR:
3106 mod_id = RK_ISP2X_PP_NR_ID;
3107 break;
3108 case RK_MODULE_3DLUT:
3109 mod_id = RK_ISP2X_3DLUT_ID;
3110 break;
3111 case RK_MODULE_LDCH:
3112 mod_id = RK_ISP2X_LDCH_ID;
3113 break;
3114 case RK_MODULE_GIC:
3115 mod_id = RK_ISP2X_GIC_ID;
3116 break;
3117 case RK_MODULE_AWB_GAIN:
3118 mod_id = RK_ISP2X_GAIN_ID;
3119 break;
3120 case RK_MODULE_SHARP:
3121 mod_id = RK_ISP2X_PP_TSHP_ID;
3122 break;
3123 case RK_MODULE_AE:
3124 mod_id = RK_ISP2X_RAWAE0_ID;
3125 break;
3126 case RK_MODULE_FEC:
3127 mod_id = RK_ISP2X_PP_TFEC_ID;
3128 break;
3129 //case RK_MODULE_DHAZ:
3130 // mod_id = RK_ISP2X_DHAZ_ID;
3131 break;
3132 }
3133
3134 if (mod_id < 0)
3135 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "input param: module ID is wrong!");
3136 else
3137 en = getModuleForceEn(mod_id);
3138 }
3139
getModuleForceFlag(int module_id)3140 bool Isp20Params::getModuleForceFlag(int module_id)
3141 {
3142 SmartLock locker (_mutex);
3143 return ((_force_module_flags & (1LL << module_id)) >> module_id);
3144 }
3145
setModuleForceFlagInverse(int module_id)3146 void Isp20Params::setModuleForceFlagInverse(int module_id)
3147 {
3148 SmartLock locker (_mutex);
3149 _force_module_flags &= (~(1LL << module_id));
3150 }
3151
getModuleForceEn(int module_id)3152 bool Isp20Params::getModuleForceEn(int module_id)
3153 {
3154 SmartLock locker (_mutex);
3155 if(module_id == RK_ISP2X_PP_TNR_ID)
3156 return (_force_ispp_module_ens & ISPP_MODULE_TNR) >> 0;
3157 else if(module_id == RK_ISP2X_PP_NR_ID)
3158 return (_force_ispp_module_ens & ISPP_MODULE_NR) >> 1;
3159 else if(module_id == RK_ISP2X_PP_TSHP_ID)
3160 return (_force_ispp_module_ens & ISPP_MODULE_SHP) >> 2;
3161 else if(module_id == RK_ISP2X_PP_TFEC_ID)
3162 return (_force_ispp_module_ens & ISPP_MODULE_FEC) >> 3;
3163 else
3164 return ((_force_isp_module_ens & (1LL << module_id)) >> module_id);
3165 }
3166
updateIspModuleForceEns(u64 module_ens)3167 void Isp20Params::updateIspModuleForceEns(u64 module_ens)
3168 {
3169 SmartLock locker (_mutex);
3170 _force_isp_module_ens = module_ens;
3171 }
3172
updateIsppModuleForceEns(u32 module_ens)3173 void Isp20Params::updateIsppModuleForceEns(u32 module_ens)
3174 {
3175 SmartLock locker (_mutex);
3176 _force_ispp_module_ens = module_ens;
3177 }
3178
3179 #if 0
3180 void
3181 Isp20Params::forceOverwriteAiqIsppCfg(struct rkispp_params_cfg& pp_cfg,
3182 SmartPtr<RkAiqIspParamsProxy> aiq_meas_results,
3183 SmartPtr<RkAiqIspParamsProxy> aiq_other_results)
3184 {
3185 rk_aiq_ispp_meas_params_t* ispp_meas_param =
3186 static_cast<rk_aiq_ispp_meas_params_t*>(aiq_meas_results->data().ptr());
3187 rk_aiq_ispp_other_params_t* ispp_other_param =
3188 static_cast<rk_aiq_ispp_other_params_t*>(aiq_other_results->data().ptr());
3189
3190 for (int i = RK_ISP2X_PP_TNR_ID; i <= RK_ISP2X_PP_MAX_ID; i++) {
3191 if (getModuleForceFlag(i)) {
3192 switch (i) {
3193 case RK_ISP2X_PP_TNR_ID:
3194 if (!ispp_other_param)
3195 break;
3196 if (getModuleForceEn(RK_ISP2X_PP_TNR_ID)) {
3197 if(ispp_other_param->tnr.tnr_en) {
3198 pp_cfg.module_ens |= ISPP_MODULE_TNR;
3199 pp_cfg.module_en_update |= ISPP_MODULE_TNR;
3200 pp_cfg.module_cfg_update |= ISPP_MODULE_TNR;
3201 } else {
3202 setModuleForceFlagInverse(RK_ISP2X_PP_TNR_ID);
3203 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "algo isn't enabled, so enable module failed!");
3204 }
3205 } else {
3206 pp_cfg.module_ens &= ~ISPP_MODULE_TNR;
3207 pp_cfg.module_en_update |= ISPP_MODULE_TNR;
3208 pp_cfg.module_cfg_update &= ~ISPP_MODULE_TNR;
3209 }
3210 break;
3211 case RK_ISP2X_PP_NR_ID:
3212 if (!ispp_other_param)
3213 break;
3214 if (getModuleForceEn(RK_ISP2X_PP_NR_ID)) {
3215 if( ispp_other_param->tnr.tnr_en) {
3216 pp_cfg.module_ens |= ISPP_MODULE_NR;
3217 pp_cfg.module_en_update |= ISPP_MODULE_NR;
3218 pp_cfg.module_cfg_update |= ISPP_MODULE_NR;
3219 } else {
3220 setModuleForceFlagInverse(RK_ISP2X_PP_NR_ID);
3221 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "algo isn't enabled, so enable module failed!");
3222 }
3223 } else {
3224 pp_cfg.module_ens &= ~ISPP_MODULE_NR;
3225 pp_cfg.module_en_update |= ISPP_MODULE_NR;
3226 pp_cfg.module_cfg_update &= ~ISPP_MODULE_NR;
3227 }
3228 break;
3229 case RK_ISP2X_PP_TSHP_ID:
3230 if (!ispp_other_param)
3231 break;
3232 if (getModuleForceEn(RK_ISP2X_PP_TSHP_ID)) {
3233 if(ispp_other_param->sharpen.stSharpFixV1.sharp_en ||
3234 ispp_other_param->edgeflt.edgeflt_en) {
3235 pp_cfg.module_ens |= ISPP_MODULE_SHP;
3236 pp_cfg.module_en_update |= ISPP_MODULE_SHP;
3237 pp_cfg.module_cfg_update |= ISPP_MODULE_SHP;
3238 } else {
3239 setModuleForceFlagInverse(RK_ISP2X_PP_TSHP_ID);
3240 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "algo isn't enabled, so enable module failed!");
3241 }
3242 } else {
3243 pp_cfg.module_ens &= ~ISPP_MODULE_SHP;
3244 pp_cfg.module_en_update |= ISPP_MODULE_SHP;
3245 pp_cfg.module_cfg_update &= ~ISPP_MODULE_SHP;
3246 }
3247 break;
3248 }
3249 }
3250 }
3251 updateIsppModuleForceEns(pp_cfg.module_ens);
3252 }
3253
3254 void
3255 Isp20Params::forceOverwriteAiqIspCfg(struct isp2x_isp_params_cfg& isp_cfg,
3256 SmartPtr<RkAiqIspParamsProxy> aiq_results,
3257 SmartPtr<RkAiqIspParamsProxy> aiq_other_results)
3258 {
3259 rk_aiq_isp_meas_params_v20_t* isp20_meas_result =
3260 static_cast<rk_aiq_isp_meas_params_v20_t*>(aiq_results->data().ptr());
3261 rk_aiq_isp_other_params_v20_t* isp20_other_result =
3262 static_cast<rk_aiq_isp_other_params_v20_t*>(aiq_other_results->data().ptr());
3263 for (int i = 0; i <= RK_ISP2X_MAX_ID; i++) {
3264 if (getModuleForceFlag(i)) {
3265 switch (i) {
3266 case RK_ISP2X_DPCC_ID:
3267 if (getModuleForceEn(RK_ISP2X_DPCC_ID)) {
3268 if(isp20_meas_result->dpcc.stBasic.enable) {
3269 isp_cfg.module_ens |= ISP2X_MODULE_DPCC;
3270 isp_cfg.module_en_update |= ISP2X_MODULE_DPCC;
3271 isp_cfg.module_cfg_update |= ISP2X_MODULE_DPCC;
3272 } else {
3273 setModuleForceFlagInverse(RK_ISP2X_DPCC_ID);
3274 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "dpcc algo isn't enabled, so enable module failed!");
3275 }
3276 } else {
3277 isp_cfg.module_ens &= ~ISP2X_MODULE_DPCC;
3278 isp_cfg.module_en_update |= ISP2X_MODULE_DPCC;
3279 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_DPCC;
3280 }
3281 break;
3282 case RK_ISP2X_BLS_ID:
3283 if (getModuleForceEn(RK_ISP2X_BLS_ID)) {
3284 if(isp20_other_result->blc.enable) {
3285 isp_cfg.module_ens |= ISP2X_MODULE_BLS;
3286 isp_cfg.module_en_update |= ISP2X_MODULE_BLS;
3287 isp_cfg.module_cfg_update |= ISP2X_MODULE_BLS;
3288 } else {
3289 setModuleForceFlagInverse(RK_ISP2X_BLS_ID);
3290 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "bls algo isn't enabled, so enable module failed!");
3291 }
3292 } else {
3293 isp_cfg.module_ens &= ~ISP2X_MODULE_BLS;
3294 isp_cfg.module_en_update |= ISP2X_MODULE_BLS;
3295 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_BLS;
3296 }
3297 break;
3298 case RK_ISP2X_LSC_ID:
3299 if (getModuleForceEn(RK_ISP2X_LSC_ID)) {
3300 if(isp20_meas_result->lsc.lsc_en) {
3301 isp_cfg.module_ens |= ISP2X_MODULE_LSC;
3302 isp_cfg.module_en_update |= ISP2X_MODULE_LSC;
3303 isp_cfg.module_cfg_update |= ISP2X_MODULE_LSC;
3304 } else {
3305 setModuleForceFlagInverse(RK_ISP2X_LSC_ID);
3306 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "lsc algo isn't enabled, so enable module failed!");
3307 }
3308 } else {
3309 isp_cfg.module_ens &= ~ISP2X_MODULE_LSC;
3310 isp_cfg.module_en_update |= ISP2X_MODULE_LSC;
3311 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_LSC;
3312 }
3313 break;
3314 case RK_ISP2X_CTK_ID:
3315 if (getModuleForceEn(RK_ISP2X_CTK_ID)) {
3316 if(isp20_meas_result->lsc.lsc_en) {
3317 isp_cfg.module_ens |= ISP2X_MODULE_CCM;
3318 isp_cfg.module_en_update |= ISP2X_MODULE_CCM;
3319 isp_cfg.module_cfg_update |= ISP2X_MODULE_CCM;
3320 } else {
3321 setModuleForceFlagInverse(RK_ISP2X_CTK_ID);
3322 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "ccm algo isn't enabled, so enable module failed!");
3323 }
3324 } else {
3325 isp_cfg.module_ens &= ~ISP2X_MODULE_CCM;
3326 isp_cfg.module_en_update |= ISP2X_MODULE_CCM;
3327 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_CCM;
3328 }
3329 break;
3330 case RK_ISP2X_RAWAWB_ID:
3331 if (getModuleForceEn(RK_ISP2X_RAWAWB_ID)) {
3332 if(isp20_meas_result->awb_cfg.awbEnable) {
3333 isp_cfg.module_ens |= ISP2X_MODULE_RAWAWB;
3334 isp_cfg.module_en_update |= ISP2X_MODULE_RAWAWB;
3335 isp_cfg.module_cfg_update |= ISP2X_MODULE_RAWAWB;
3336 } else {
3337 setModuleForceFlagInverse(RK_ISP2X_RAWAWB_ID);
3338 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "awb algo isn't enabled, so enable module failed!");
3339 }
3340 } else {
3341 isp_cfg.module_ens &= ~ISP2X_MODULE_RAWAWB;
3342 isp_cfg.module_en_update |= ISP2X_MODULE_RAWAWB;
3343 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_RAWAWB;
3344 }
3345 break;
3346 case RK_ISP2X_GOC_ID:
3347 if (getModuleForceEn(RK_ISP2X_GOC_ID)) {
3348 if(isp20_other_result->agamma.gamma_en) {
3349 isp_cfg.module_ens |= ISP2X_MODULE_GOC;
3350 isp_cfg.module_en_update |= ISP2X_MODULE_GOC;
3351 isp_cfg.module_cfg_update |= ISP2X_MODULE_GOC;
3352 } else {
3353 setModuleForceFlagInverse(RK_ISP2X_GOC_ID);
3354 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "goc algo isn't enabled, so enable module failed!");
3355 }
3356 } else {
3357 isp_cfg.module_ens &= ~ISP2X_MODULE_GOC;
3358 isp_cfg.module_en_update |= ISP2X_MODULE_GOC;
3359 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_GOC;
3360 }
3361 break;
3362 case RK_ISP2X_RAWNR_ID:
3363 if (getModuleForceEn(RK_ISP2X_RAWNR_ID)) {
3364 if(isp20_other_result->rawnr.rawnr_en) {
3365 isp_cfg.module_ens |= ISP2X_MODULE_RAWNR;
3366 isp_cfg.module_en_update |= ISP2X_MODULE_RAWNR;
3367 isp_cfg.module_cfg_update |= ISP2X_MODULE_RAWNR;
3368 } else {
3369 setModuleForceFlagInverse(RK_ISP2X_RAWNR_ID);
3370 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "rawnr algo isn't enabled, so enable module failed!");
3371 }
3372 } else {
3373 isp_cfg.module_ens &= ~ISP2X_MODULE_RAWNR;
3374 isp_cfg.module_en_update |= ISP2X_MODULE_RAWNR;
3375 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_RAWNR;
3376 }
3377 break;
3378 case RK_ISP2X_3DLUT_ID:
3379 if (getModuleForceEn(RK_ISP2X_3DLUT_ID)) {
3380 if(isp20_other_result->rawnr.rawnr_en) {
3381 isp_cfg.module_ens |= ISP2X_MODULE_3DLUT;
3382 isp_cfg.module_en_update |= ISP2X_MODULE_3DLUT;
3383 isp_cfg.module_cfg_update |= ISP2X_MODULE_3DLUT;
3384 } else {
3385 setModuleForceFlagInverse(RK_ISP2X_3DLUT_ID);
3386 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "3dlut algo isn't enabled, so enable module failed!");
3387 }
3388 } else {
3389 isp_cfg.module_ens &= ~ISP2X_MODULE_3DLUT;
3390 isp_cfg.module_en_update |= ISP2X_MODULE_3DLUT;
3391 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_3DLUT;
3392 }
3393 break;
3394 case RK_ISP2X_LDCH_ID:
3395 if (getModuleForceEn(RK_ISP2X_LDCH_ID)) {
3396 if(isp20_other_result->ldch.ldch_en) {
3397 isp_cfg.module_ens |= ISP2X_MODULE_LDCH;
3398 isp_cfg.module_en_update |= ISP2X_MODULE_LDCH;
3399 isp_cfg.module_cfg_update |= ISP2X_MODULE_LDCH;
3400 } else {
3401 setModuleForceFlagInverse(RK_ISP2X_LDCH_ID);
3402 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "ldch algo isn't enabled, so enable module failed!");
3403 }
3404 } else {
3405 isp_cfg.module_ens &= ~ISP2X_MODULE_LDCH;
3406 isp_cfg.module_en_update |= ISP2X_MODULE_LDCH;
3407 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_LDCH;
3408 }
3409 break;
3410 case RK_ISP2X_GIC_ID:
3411 if (getModuleForceEn(RK_ISP2X_GIC_ID)) {
3412 if(isp20_other_result->gic.gic_en) {
3413 isp_cfg.module_ens |= ISP2X_MODULE_GIC;
3414 isp_cfg.module_en_update |= ISP2X_MODULE_GIC;
3415 isp_cfg.module_cfg_update |= ISP2X_MODULE_GIC;
3416 } else {
3417 setModuleForceFlagInverse(RK_ISP2X_GIC_ID);
3418 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "gic algo isn't enabled, so enable module failed!");
3419 }
3420 } else {
3421 isp_cfg.module_ens &= ~ISP2X_MODULE_GIC;
3422 isp_cfg.module_en_update |= ISP2X_MODULE_GIC;
3423 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_GIC;
3424 }
3425 break;
3426 case RK_ISP2X_GAIN_ID:
3427 if (getModuleForceEn(RK_ISP2X_GAIN_ID)) {
3428 if(isp20_other_result->gain_config.gain_table_en) {
3429 isp_cfg.module_ens |= ISP2X_MODULE_GAIN;
3430 isp_cfg.module_en_update |= ISP2X_MODULE_GAIN;
3431 isp_cfg.module_cfg_update |= ISP2X_MODULE_GAIN;
3432 } else {
3433 setModuleForceFlagInverse(RK_ISP2X_GAIN_ID);
3434 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "gain algo isn't enabled, so enable module failed!");
3435 }
3436 } else {
3437 isp_cfg.module_ens &= ~ISP2X_MODULE_GAIN;
3438 isp_cfg.module_en_update |= ISP2X_MODULE_GAIN;
3439 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_GAIN;
3440 }
3441 break;
3442 case RK_ISP2X_DHAZ_ID:
3443 if (getModuleForceEn(RK_ISP2X_DHAZ_ID)) {
3444 if(isp20_other_result->adhaz.enable) {
3445 isp_cfg.module_ens |= ISP2X_MODULE_DHAZ;
3446 isp_cfg.module_en_update |= ISP2X_MODULE_DHAZ;
3447 isp_cfg.module_cfg_update |= ISP2X_MODULE_DHAZ;
3448 } else {
3449 setModuleForceFlagInverse(RK_ISP2X_DHAZ_ID);
3450 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "dehaze algo isn't enabled, so enable module failed!");
3451 }
3452 } else {
3453 isp_cfg.module_ens &= ~ISP2X_MODULE_DHAZ;
3454 isp_cfg.module_en_update |= ISP2X_MODULE_DHAZ;
3455 isp_cfg.module_cfg_update &= ~ISP2X_MODULE_DHAZ;
3456 }
3457 break;
3458 }
3459 }
3460 }
3461 updateIspModuleForceEns(isp_cfg.module_ens);
3462 }
3463 #endif
3464
3465 void
hdrtmoGetLumaInfo(rk_aiq_luma_params_t * Next,rk_aiq_luma_params_t * Cur,s32 frameNum,int PixelNumBlock,float blc,float * luma)3466 Isp20Params::hdrtmoGetLumaInfo(rk_aiq_luma_params_t * Next, rk_aiq_luma_params_t *Cur,
3467 s32 frameNum, int PixelNumBlock, float blc, float *luma)
3468 {
3469 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "PixelNumBlock:%d blc:%f\n", PixelNumBlock, blc);
3470
3471 float nextSLuma[16] ;
3472 float curSLuma[16] ;
3473 float nextMLuma[16] ;
3474 float curMLuma[16] ;
3475 float nextLLuma[16];
3476 float curLLuma[16];
3477
3478 if (frameNum == 1)
3479 {
3480 for(int i = 0; i < ISP2X_MIPI_LUMA_MEAN_MAX; i++) {
3481 nextLLuma[i] = 0;
3482 curLLuma[i] = 0;
3483 nextMLuma[i] = 0;
3484 curMLuma[i] = 0;
3485 nextSLuma[i] = (float)Next->luma[0][i];
3486 nextSLuma[i] /= (float)PixelNumBlock;
3487 nextSLuma[i] -= blc;
3488 curSLuma[i] = (float)Cur->luma[0][i];
3489 curSLuma[i] /= (float)PixelNumBlock;
3490 curSLuma[i] -= blc;
3491 }
3492 } else if (frameNum == 2) {
3493 for(int i = 0; i < ISP2X_MIPI_LUMA_MEAN_MAX; i++) {
3494 nextSLuma[i] = (float)Next->luma[1][i];
3495 nextSLuma[i] /= (float)PixelNumBlock;
3496 nextSLuma[i] -= blc;
3497 curSLuma[i] = (float)Cur->luma[1][i];
3498 curSLuma[i] /= (float)PixelNumBlock;
3499 curSLuma[i] -= blc;
3500 nextMLuma[i] = 0;
3501 curMLuma[i] = 0;
3502 nextLLuma[i] = (float)Next->luma[0][i];
3503 nextLLuma[i] /= (float)PixelNumBlock;
3504 nextLLuma[i] -= blc;
3505 curLLuma[i] = (float)Cur->luma[0][i];
3506 curLLuma[i] /= (float)PixelNumBlock;
3507 curLLuma[i] -= blc;
3508 }
3509 } else if (frameNum == 3) {
3510
3511 for(int i = 0; i < ISP2X_MIPI_LUMA_MEAN_MAX; i++) {
3512 nextSLuma[i] = (float)Next->luma[2][i];
3513 nextSLuma[i] /= (float)PixelNumBlock;
3514 nextSLuma[i] -= blc;
3515 curSLuma[i] = (float)Cur->luma[2][i];
3516 curSLuma[i] /= (float)PixelNumBlock;
3517 curSLuma[i] -= blc;
3518 nextMLuma[i] = (float)Next->luma[1][i];
3519 nextMLuma[i] /= (float)PixelNumBlock;
3520 nextMLuma[i] -= blc;
3521 curMLuma[i] = (float)Cur->luma[1][i];
3522 curMLuma[i] /= (float)PixelNumBlock;
3523 curMLuma[i] -= blc;
3524 nextLLuma[i] = (float)Next->luma[0][i];
3525 nextLLuma[i] /= (float)PixelNumBlock;
3526 nextLLuma[i] -= blc;
3527 curLLuma[i] = (float)Cur->luma[0][i];
3528 curLLuma[i] /= (float)PixelNumBlock;
3529 curLLuma[i] -= blc;
3530 }
3531 }
3532
3533 for(int i = 0; i < ISP2X_MIPI_LUMA_MEAN_MAX; i++) {
3534 luma[i] = curSLuma[i];
3535 luma[i + 16] = curMLuma[i];
3536 luma[i + 32] = curLLuma[i];
3537 luma[i + 48] = nextSLuma[i];
3538 luma[i + 64] = nextMLuma[i];
3539 luma[i + 80] = nextLLuma[i];
3540 }
3541 }
3542
3543 void
hdrtmoGetAeInfo(RKAiqAecExpInfo_t * Next,RKAiqAecExpInfo_t * Cur,s32 frameNum,float * expo)3544 Isp20Params::hdrtmoGetAeInfo(RKAiqAecExpInfo_t* Next, RKAiqAecExpInfo_t* Cur, s32 frameNum, float* expo)
3545 {
3546 float nextLExpo = 0;
3547 float curLExpo = 0;
3548 float nextMExpo = 0;
3549 float curMExpo = 0;
3550 float nextSExpo = 0;
3551 float curSExpo = 0;
3552
3553 if (frameNum == 1)
3554 {
3555 nextLExpo = 0;
3556 curLExpo = 0;
3557 nextMExpo = 0;
3558 curMExpo = 0;
3559 nextSExpo = Next->LinearExp.exp_real_params.analog_gain * \
3560 Next->LinearExp.exp_real_params.integration_time;
3561 curSExpo = Cur->LinearExp.exp_real_params.analog_gain * \
3562 Cur->LinearExp.exp_real_params.integration_time;
3563 } else if (frameNum == 2) {
3564 nextLExpo = Next->HdrExp[1].exp_real_params.analog_gain * \
3565 Next->HdrExp[1].exp_real_params.integration_time;
3566 curLExpo = Cur->HdrExp[1].exp_real_params.analog_gain * \
3567 Cur->HdrExp[1].exp_real_params.integration_time;
3568 nextMExpo = nextLExpo;
3569 curMExpo = curLExpo;
3570 nextSExpo = Next->HdrExp[0].exp_real_params.analog_gain * \
3571 Next->HdrExp[0].exp_real_params.integration_time;
3572 curSExpo = Cur->HdrExp[0].exp_real_params.analog_gain * \
3573 Cur->HdrExp[0].exp_real_params.integration_time;
3574 } else if (frameNum == 3) {
3575 nextLExpo = Next->HdrExp[2].exp_real_params.analog_gain * \
3576 Next->HdrExp[2].exp_real_params.integration_time;
3577 curLExpo = Cur->HdrExp[2].exp_real_params.analog_gain * \
3578 Cur->HdrExp[2].exp_real_params.integration_time;
3579 nextMExpo = Next->HdrExp[1].exp_real_params.analog_gain * \
3580 Next->HdrExp[1].exp_real_params.integration_time;
3581 curMExpo = Cur->HdrExp[1].exp_real_params.analog_gain * \
3582 Cur->HdrExp[1].exp_real_params.integration_time;
3583 nextSExpo = Next->HdrExp[0].exp_real_params.analog_gain * \
3584 Next->HdrExp[0].exp_real_params.integration_time;
3585 curSExpo = Cur->HdrExp[0].exp_real_params.analog_gain * \
3586 Cur->HdrExp[0].exp_real_params.integration_time;
3587 }
3588
3589 expo[0] = curSExpo;
3590 expo[1] = curMExpo;
3591 expo[2] = curLExpo;
3592 expo[3] = nextSExpo;
3593 expo[4] = nextMExpo;
3594 expo[5] = nextLExpo;
3595
3596 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "Cur Expo: S:%f M:%f L:%f\n", curSExpo, curMExpo, curLExpo);
3597 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "Next Expo: S:%f M:%f L:%f\n", nextSExpo, nextMExpo, nextLExpo);
3598
3599 }
3600
3601 bool
hdrtmoSceneStable(uint32_t frameId,int IIRMAX,int IIR,int SetWeight,s32 frameNum,float * LumaDeviation,float StableThr)3602 Isp20Params::hdrtmoSceneStable(uint32_t frameId, int IIRMAX, int IIR, int SetWeight, s32 frameNum, float *LumaDeviation, float StableThr)
3603 {
3604 bool SceneStable = true;
3605 float LumaDeviationL = 0;
3606 float LumaDeviationM = 0;
3607 float LumaDeviationS = 0;
3608 float LumaDeviationLinear = 0;
3609 float LumaDeviationFinnal = 0;
3610
3611 //set default value when secne change or flow restart
3612 if(AntiTmoFlicker.preFrameNum != frameNum || frameId == 0) {
3613 AntiTmoFlicker.preFrameNum = 0;
3614 AntiTmoFlicker.FirstChange = false;
3615 AntiTmoFlicker.FirstChangeNum = 0;
3616 AntiTmoFlicker.FirstChangeDone = false;
3617 AntiTmoFlicker.FirstChangeDoneNum = 0;
3618 }
3619
3620 //get LumaDeviationFinnal value
3621 if(frameNum == 1) {
3622 LumaDeviationLinear = LumaDeviation[0];
3623 LumaDeviationFinnal = LumaDeviationLinear;
3624 }
3625 else if(frameNum == 2) {
3626 LumaDeviationS = LumaDeviation[0];
3627 LumaDeviationL = LumaDeviation[1];
3628
3629 if(LumaDeviationL > 0)
3630 LumaDeviationFinnal = LumaDeviationL;
3631 else if(LumaDeviationL == 0 && LumaDeviationS > 0)
3632 LumaDeviationFinnal = LumaDeviationS;
3633
3634 }
3635 else if(frameNum == 3) {
3636 LumaDeviationS = LumaDeviation[0];
3637 LumaDeviationM = LumaDeviation[1];
3638 LumaDeviationL = LumaDeviation[2];
3639
3640 if(LumaDeviationM > 0)
3641 LumaDeviationFinnal = LumaDeviationM;
3642 else if(LumaDeviationM == 0 && LumaDeviationL > 0)
3643 LumaDeviationFinnal = LumaDeviationL;
3644 else if(LumaDeviationM == 0 && LumaDeviationL == 0 && LumaDeviationS == 0)
3645 LumaDeviationFinnal = LumaDeviationS;
3646
3647 }
3648 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "frameId:%ld LumaDeviationLinear:%f LumaDeviationS:%f LumaDeviationM:%f LumaDeviationL:%f\n",
3649 frameId, LumaDeviationLinear, LumaDeviationS, LumaDeviationM, LumaDeviationL);
3650
3651 //skip first N frame for starting
3652 if(AntiTmoFlicker.FirstChange == false) {
3653 if(LumaDeviationFinnal) {
3654 AntiTmoFlicker.FirstChange = true;
3655 AntiTmoFlicker.FirstChangeNum = frameId;
3656 }
3657 }
3658
3659 if(AntiTmoFlicker.FirstChangeDone == false && AntiTmoFlicker.FirstChange == true) {
3660 if(LumaDeviationFinnal == 0) {
3661 AntiTmoFlicker.FirstChangeDone = true;
3662 AntiTmoFlicker.FirstChangeDoneNum = frameId;
3663 }
3664 }
3665
3666 //detect stable
3667 if(AntiTmoFlicker.FirstChangeDoneNum && AntiTmoFlicker.FirstChangeNum) {
3668 if(LumaDeviationFinnal <= StableThr)
3669 SceneStable = true;
3670 else
3671 SceneStable = false;
3672 }
3673 else
3674 SceneStable = true;
3675
3676 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "preFrameNum:%d frameNum:%d FirstChange:%d FirstChangeNum:%d FirstChangeDone:%d FirstChangeDoneNum:%d\n",
3677 AntiTmoFlicker.preFrameNum, frameNum, AntiTmoFlicker.FirstChange, AntiTmoFlicker.FirstChangeNum,
3678 AntiTmoFlicker.FirstChangeDone, AntiTmoFlicker.FirstChangeDoneNum);
3679 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "LumaDeviationFinnal:%f StableThr:%f SceneStable:%d \n", LumaDeviationFinnal, StableThr, SceneStable);
3680
3681 //store framrnum
3682 AntiTmoFlicker.preFrameNum = frameNum;
3683
3684 return SceneStable;
3685 }
3686
3687 s32
hdrtmoPredictK(float * luma,float * expo,s32 frameNum,PredictKPara_t * TmoPara)3688 Isp20Params::hdrtmoPredictK(float* luma, float* expo, s32 frameNum, PredictKPara_t *TmoPara)
3689 {
3690 int PredictK = 0;
3691 float PredictKfloat = 0;
3692
3693 float curSExpo = expo[0];
3694 float curMExpo = expo[1];
3695 float curLExpo = expo[2];
3696 float nextSExpo = expo[3];
3697 float nextMExpo = expo[4];
3698 float nextLExpo = expo[5];
3699
3700 float nextLLuma[16];
3701 float curLLuma[16];
3702 float nextSLuma[16];
3703 float curSLuma[16];
3704 float nextMLuma[16];
3705 float curMLuma[16];
3706
3707 for(int i = 0; i < ISP2X_MIPI_LUMA_MEAN_MAX; i++)
3708 {
3709 curSLuma[i] = luma[i];
3710 curMLuma[i] = luma[i + 16];
3711 curLLuma[i] = luma[i + 32];
3712 nextSLuma[i] = luma[i + 48];
3713 nextMLuma[i] = luma[i + 64];
3714 nextLLuma[i] = luma[i + 80];
3715 }
3716
3717 float correction_factor = TmoPara->correction_factor;
3718 float ratio = 1;
3719 float offset = TmoPara->correction_offset;
3720 float LongExpoRatio = 1;
3721 float ShortExpoRatio = 1;
3722 float MiddleExpoRatio = 1;
3723 float MiddleLumaChange = 1;
3724 float LongLumaChange = 1;
3725 float ShortLumaChange = 1;
3726 float EnvLvChange = 0;
3727
3728 //get expo change
3729 if(frameNum == 3 || frameNum == 2) {
3730 if(nextLExpo != 0 && curLExpo != 0)
3731 LongExpoRatio = nextLExpo / curLExpo;
3732 else
3733 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "Wrong Long frame expo!!!");
3734 }
3735
3736 if(frameNum == 3) {
3737 if(nextMExpo != 0 && curMExpo != 0)
3738 ShortExpoRatio = nextMExpo / curMExpo;
3739 else
3740 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "Wrong Short frame expo!!!");
3741 }
3742
3743 if(nextSExpo != 0 && curSExpo != 0)
3744 ShortExpoRatio = nextSExpo / curSExpo;
3745 else
3746 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "Wrong Short frame expo!!!");
3747
3748 float nextLMeanLuma = 0;
3749 float curLMeanLuma = 0;
3750 float curMMeanLuma = 0;
3751 float nextMMeanLuma = 0;
3752 float nextSMeanLuma = 0;
3753 float curSMeanLuma = 0;
3754 for(int i = 0; i < ISP2X_MIPI_LUMA_MEAN_MAX; i++)
3755 {
3756 nextLMeanLuma += nextLLuma[i];
3757 curLMeanLuma += curLLuma[i];
3758 nextMMeanLuma += nextMLuma[i];
3759 curMMeanLuma += curMLuma[i];
3760 nextSMeanLuma += nextSLuma[i];
3761 curSMeanLuma += curSLuma[i];
3762 }
3763 nextLMeanLuma /= ISP2X_MIPI_LUMA_MEAN_MAX;
3764 curLMeanLuma /= ISP2X_MIPI_LUMA_MEAN_MAX;
3765 nextMMeanLuma /= ISP2X_MIPI_LUMA_MEAN_MAX;
3766 curMMeanLuma /= ISP2X_MIPI_LUMA_MEAN_MAX;
3767 nextSMeanLuma /= ISP2X_MIPI_LUMA_MEAN_MAX;
3768 curSMeanLuma /= ISP2X_MIPI_LUMA_MEAN_MAX;
3769
3770 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextLLuma:%f curLLuma:%f\n", nextLMeanLuma, curLMeanLuma);
3771 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextSLuma:%f curSLuma:%f\n", nextSMeanLuma, curSMeanLuma);
3772
3773 //get luma change
3774 if(frameNum == 3 || frameNum == 2) {
3775 if(nextLMeanLuma > 0 && curLMeanLuma > 0)
3776 LongLumaChange = nextLMeanLuma / curLMeanLuma;
3777 else if(nextLMeanLuma <= 0 && curLMeanLuma > 0)
3778 {
3779 nextLMeanLuma = 1;
3780 LongLumaChange = nextLMeanLuma / curLMeanLuma;
3781 }
3782 else if(nextLMeanLuma > 0 && curLMeanLuma <= 0)
3783 {
3784 curLMeanLuma = 1;
3785 LongLumaChange = nextLMeanLuma / curLMeanLuma;
3786 }
3787 else {
3788 curLMeanLuma = 1;
3789 nextLMeanLuma = 1;
3790 LongLumaChange = nextLMeanLuma / curLMeanLuma;
3791 }
3792 }
3793
3794 if(frameNum == 3) {
3795 if(nextMMeanLuma > 0 && curMMeanLuma > 0)
3796 MiddleLumaChange = nextMMeanLuma / curMMeanLuma;
3797 else if(nextMMeanLuma <= 0 && curMMeanLuma > 0)
3798 {
3799 nextMMeanLuma = 1;
3800 MiddleLumaChange = nextMMeanLuma / curMMeanLuma;
3801 }
3802 else if(nextMMeanLuma > 0 && curMMeanLuma <= 0)
3803 {
3804 curMMeanLuma = 1;
3805 MiddleLumaChange = nextMMeanLuma / curMMeanLuma;
3806 }
3807 else {
3808 curMMeanLuma = 1;
3809 nextMMeanLuma = 1;
3810 MiddleLumaChange = nextMMeanLuma / curMMeanLuma;
3811 }
3812 }
3813
3814 if(nextSMeanLuma > 0 && curSMeanLuma > 0)
3815 ShortLumaChange = nextSMeanLuma / curSMeanLuma;
3816 else if(nextSMeanLuma <= 0 && curSMeanLuma > 0)
3817 {
3818 nextSMeanLuma = 1;
3819 ShortLumaChange = nextSMeanLuma / curSMeanLuma;
3820 }
3821 else if(nextSMeanLuma > 0 && curSMeanLuma <= 0)
3822 {
3823 curSMeanLuma = 1;
3824 ShortLumaChange = nextSMeanLuma / curSMeanLuma;
3825 }
3826 else {
3827 curSMeanLuma = 1;
3828 nextSMeanLuma = 1;
3829 ShortLumaChange = nextSMeanLuma / curSMeanLuma;
3830 }
3831
3832 //cal predictK
3833 if (frameNum == 1)
3834 {
3835 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextLuma:%f curLuma:%f LumaChange:%f\n", nextSMeanLuma, curSMeanLuma, ShortLumaChange);
3836 ratio = ShortLumaChange;
3837
3838 EnvLvChange = nextSMeanLuma / nextSExpo - curSMeanLuma / curSExpo;
3839 EnvLvChange = EnvLvChange >= 0 ? EnvLvChange : (-EnvLvChange);
3840 EnvLvChange /= curSMeanLuma / curSExpo;
3841 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextEnvLv:%f curEnvLv:%f EnvLvChange:%f\n", nextSMeanLuma / nextSExpo,
3842 curSMeanLuma / curSExpo, EnvLvChange);
3843 }
3844 else if (frameNum == 2)
3845 {
3846 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextLLuma:%f curLLuma:%f LongLumaChange:%f\n", nextLMeanLuma, curLMeanLuma, LongLumaChange);
3847 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextSLuma:%f curSLuma:%f ShortLumaChange:%f\n", nextSMeanLuma, curSMeanLuma, ShortLumaChange);
3848 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "LongPercent:%f UseLongLowTh:%f UseLongUpTh:%f\n", 1, TmoPara->UseLongLowTh, TmoPara->UseLongUpTh);
3849
3850 if(LongLumaChange > TmoPara->UseLongLowTh || LongLumaChange < TmoPara->UseLongUpTh)
3851 ratio = LongLumaChange;
3852 else
3853 ratio = ShortLumaChange;
3854
3855 EnvLvChange = nextLMeanLuma / nextLExpo - curLMeanLuma / curLExpo;
3856 EnvLvChange = EnvLvChange >= 0 ? EnvLvChange : (-EnvLvChange);
3857 EnvLvChange /= curLMeanLuma / curLExpo;
3858 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextEnvLv:%f curEnvLv:%f EnvLvChange:%f\n", nextLMeanLuma / nextLExpo,
3859 curLMeanLuma / curLExpo, EnvLvChange);
3860
3861 }
3862 else if (frameNum == 3)
3863 {
3864 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextLLuma:%f curLLuma:%f LongLumaChange:%f\n", nextLMeanLuma, curLMeanLuma, LongLumaChange);
3865 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextMLuma:%f curMLuma:%f MiddleLumaChange:%f\n", nextMMeanLuma, curMMeanLuma, MiddleLumaChange);
3866 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextSLuma:%f curSLuma:%f ShortLumaChange:%f\n", nextSMeanLuma, curSMeanLuma, ShortLumaChange);
3867 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "LongPercent:%f UseLongLowTh:%f UseLongUpTh:%f\n", TmoPara->Hdr3xLongPercent,
3868 TmoPara->UseLongLowTh, TmoPara->UseLongUpTh);
3869
3870 float LongLumaChangeNew = TmoPara->Hdr3xLongPercent * LongLumaChange + (1 - TmoPara->Hdr3xLongPercent) * MiddleLumaChange;
3871 if(LongLumaChangeNew > TmoPara->UseLongLowTh || LongLumaChangeNew < TmoPara->UseLongUpTh)
3872 ratio = LongLumaChangeNew;
3873 else
3874 ratio = ShortLumaChange;
3875
3876 EnvLvChange = nextMMeanLuma / nextMExpo - curMMeanLuma / curMExpo;
3877 EnvLvChange = EnvLvChange >= 0 ? EnvLvChange : (-EnvLvChange);
3878 EnvLvChange /= curMMeanLuma / curMExpo;
3879 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "nextEnvLv:%f curEnvLv:%f EnvLvChange:%f\n", nextMMeanLuma / nextMExpo,
3880 curMMeanLuma / curMExpo, EnvLvChange);
3881 }
3882
3883 if(ratio >= 1)
3884 PredictKfloat = log(correction_factor * ratio + offset) / log(2);
3885 else if(ratio < 1 && ratio > 0)
3886 {
3887 float tmp = ratio / correction_factor - offset;
3888 tmp = tmp >= 1 ? 1 : tmp <= 0 ? 0.00001 : tmp;
3889 PredictKfloat = log(tmp) / log(2);
3890 }
3891 else
3892 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "Wrong luma change!!!");
3893
3894 //add EnvLv judge
3895 if(EnvLvChange > 0.005) {
3896 float tmp = curLMeanLuma - nextLMeanLuma;
3897 tmp = tmp >= 0 ? tmp : (-tmp);
3898 if(tmp < 1)
3899 PredictKfloat = 0;
3900 }
3901 else
3902 PredictKfloat = 0;
3903
3904 PredictKfloat *= 2048;
3905 PredictK = (int)PredictKfloat;
3906
3907 LOGD_CAMHW_SUBM(ISP20PARAM_SUBM, "ratio:%f EnvLvChange:%f PredictKfloat:%f PredictK:%d\n",
3908 ratio, EnvLvChange, PredictKfloat, PredictK);
3909 return PredictK;
3910 }
3911
convert3aResultsToIspCfg(SmartPtr<cam3aResult> & result,void * isp_cfg_p,bool is_multi_isp)3912 bool Isp20Params::convert3aResultsToIspCfg(SmartPtr<cam3aResult> &result,
3913 void* isp_cfg_p, bool is_multi_isp)
3914 {
3915 struct isp2x_isp_params_cfg& isp_cfg = *(struct isp2x_isp_params_cfg*)isp_cfg_p;
3916
3917 if (result.ptr() == NULL) {
3918 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "3A result empty");
3919 return false;
3920 }
3921
3922 int32_t type = result->getType();
3923 // LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s, module (0x%x) convert params!\n", __FUNCTION__, type);
3924 switch (type)
3925 {
3926 case RESULT_TYPE_AEC_PARAM:
3927 {
3928 RkAiqIspAecParamsProxy* params = result.get_cast_ptr<RkAiqIspAecParamsProxy>();
3929 if (params) {
3930 convertAiqAeToIsp20Params(isp_cfg, params->data()->result);
3931 }
3932 }
3933 break;
3934 case RESULT_TYPE_HIST_PARAM:
3935 {
3936
3937 RkAiqIspHistParamsProxy* params = result.get_cast_ptr<RkAiqIspHistParamsProxy>();
3938 if (params)
3939 convertAiqHistToIsp20Params(isp_cfg, params->data()->result);
3940 }
3941 case RESULT_TYPE_EXPOSURE_PARAM:
3942 {
3943 // TODO
3944 }
3945 break;
3946 case RESULT_TYPE_AWB_PARAM:
3947 {
3948 #if RKAIQ_HAVE_AWB_V20
3949 RkAiqIspAwbParamsProxy* params = result.get_cast_ptr<RkAiqIspAwbParamsProxy>();
3950 if (params)
3951 convertAiqAwbToIsp20Params(isp_cfg, params->data()->result, true);
3952 #endif
3953 }
3954 break;
3955 case RESULT_TYPE_AWBGAIN_PARAM:
3956 {
3957 RkAiqIspAwbGainParamsProxy* awb_gain = result.get_cast_ptr<RkAiqIspAwbGainParamsProxy>();
3958 if (awb_gain && mBlcResult) {
3959 RkAiqIspBlcParamsProxy* blc = dynamic_cast<RkAiqIspBlcParamsProxy*>(mBlcResult);
3960 convertAiqAwbGainToIsp20Params(isp_cfg,
3961 awb_gain->data()->result, blc->data()->result, true);
3962
3963 } else
3964 LOGE("don't get %s params, convert awbgain params failed!",
3965 awb_gain ? "blc" : "awb_gain");
3966 }
3967 break;
3968 case RESULT_TYPE_AF_PARAM:
3969 {
3970 #if RKAIQ_HAVE_AF_V20 || RKAIQ_ONLY_AF_STATS_V20
3971 RkAiqIspAfParamsProxy* params = result.get_cast_ptr<RkAiqIspAfParamsProxy>();
3972 if (params)
3973 convertAiqAfToIsp20Params(isp_cfg, params->data()->result, true);
3974 #endif
3975 }
3976 break;
3977 case RESULT_TYPE_DPCC_PARAM:
3978 {
3979 RkAiqIspDpccParamsProxy* params = result.get_cast_ptr<RkAiqIspDpccParamsProxy>();
3980 if (params)
3981 convertAiqDpccToIsp20Params(isp_cfg, params->data()->result);
3982 }
3983 break;
3984 case RESULT_TYPE_MERGE_PARAM:
3985 {
3986 #if RKAIQ_HAVE_MERGE_V10
3987 RkAiqIspMergeParamsProxy* params = result.get_cast_ptr<RkAiqIspMergeParamsProxy>();
3988 if (params) {
3989 convertAiqMergeToIsp20Params(isp_cfg, params->data()->result);
3990 }
3991 #endif
3992 }
3993 break;
3994 case RESULT_TYPE_TMO_PARAM:
3995 {
3996 RkAiqIspTmoParamsProxy* params = result.get_cast_ptr<RkAiqIspTmoParamsProxy>();
3997 if (params) {
3998 convertAiqTmoToIsp20Params(isp_cfg, params->data()->result);
3999 }
4000 }
4001 break;
4002 case RESULT_TYPE_CCM_PARAM:
4003 {
4004 #if RKAIQ_HAVE_CCM_V1
4005 RkAiqIspCcmParamsProxy* params = result.get_cast_ptr<RkAiqIspCcmParamsProxy>();
4006 if (params)
4007 convertAiqCcmToIsp20Params(isp_cfg, params->data()->result);
4008 #endif
4009 }
4010 break;
4011 case RESULT_TYPE_LSC_PARAM:
4012 {
4013 #ifdef RKAIQ_HAVE_LSC_V1
4014 RkAiqIspLscParamsProxy* params = result.get_cast_ptr<RkAiqIspLscParamsProxy>();
4015 if (params)
4016 convertAiqLscToIsp20Params(isp_cfg, params->data()->result);
4017 #endif
4018 }
4019 break;
4020 case RESULT_TYPE_BLC_PARAM:
4021 {
4022 RkAiqIspBlcParamsProxy* params = result.get_cast_ptr<RkAiqIspBlcParamsProxy>();
4023 if (params)
4024 convertAiqBlcToIsp20Params(isp_cfg, params->data()->result);
4025 }
4026 break;
4027 case RESULT_TYPE_RAWNR_PARAM:
4028 {
4029 #if RKAIQ_HAVE_ANR_V1
4030 RkAiqIspRawnrParamsProxy* params = result.get_cast_ptr<RkAiqIspRawnrParamsProxy>();
4031 if (params)
4032 convertAiqRawnrToIsp20Params(isp_cfg, params->data()->result);
4033 #endif
4034 }
4035 break;
4036 case RESULT_TYPE_GIC_PARAM:
4037 {
4038 RkAiqIspGicParamsProxy* params = result.get_cast_ptr<RkAiqIspGicParamsProxy>();
4039 if (params)
4040 convertAiqGicToIsp20Params(isp_cfg, params->data()->result);
4041 }
4042 break;
4043 case RESULT_TYPE_DEBAYER_PARAM:
4044 {
4045 RkAiqIspDebayerParamsProxy* params = result.get_cast_ptr<RkAiqIspDebayerParamsProxy>();
4046 if (params)
4047 convertAiqAdemosaicToIsp20Params(isp_cfg, params->data()->result);
4048 }
4049 break;
4050 case RESULT_TYPE_LDCH_PARAM:
4051 {
4052 RkAiqIspLdchParamsProxy* params = result.get_cast_ptr<RkAiqIspLdchParamsProxy>();
4053 if (params)
4054 convertAiqAldchToIsp20Params(isp_cfg, params->data()->result);
4055 }
4056 break;
4057 case RESULT_TYPE_LUT3D_PARAM:
4058 {
4059 #if RKAIQ_HAVE_3DLUT_V1
4060 RkAiqIspLut3dParamsProxy* params = result.get_cast_ptr<RkAiqIspLut3dParamsProxy>();
4061 if (params)
4062 convertAiqA3dlutToIsp20Params(isp_cfg, params->data()->result);
4063 #endif
4064 }
4065 break;
4066 case RESULT_TYPE_DEHAZE_PARAM:
4067 {
4068 #if RKAIQ_HAVE_DEHAZE_V10
4069 RkAiqIspDehazeParamsProxy* params = result.get_cast_ptr<RkAiqIspDehazeParamsProxy>();
4070 if (params)
4071 convertAiqAdehazeToIsp20Params(isp_cfg, params->data()->result);
4072 #endif
4073 }
4074 break;
4075 case RESULT_TYPE_AGAMMA_PARAM:
4076 {
4077 #if RKAIQ_HAVE_GAMMA_V10
4078 RkAiqIspAgammaParamsProxy* params = result.get_cast_ptr<RkAiqIspAgammaParamsProxy>();
4079 if (params)
4080 convertAiqAgammaToIsp20Params(isp_cfg, params->data()->result);
4081 #endif
4082 }
4083 break;
4084 case RESULT_TYPE_ADEGAMMA_PARAM:
4085 {
4086 RkAiqIspAdegammaParamsProxy* params = result.get_cast_ptr<RkAiqIspAdegammaParamsProxy>();
4087 if (params)
4088 convertAiqAdegammaToIsp20Params(isp_cfg, params->data()->result);
4089 }
4090 break;
4091 case RESULT_TYPE_WDR_PARAM:
4092 #if 0
4093 {
4094 SmartPtr<RkAiqIspWdrParamsProxy> params = result.dynamic_cast_ptr<RkAiqIspWdrParamsProxy>();
4095 if (params.ptr())
4096 convertAiqWdrToIsp20Params(isp_cfg, params->data()->result);
4097 }
4098 #endif
4099 break;
4100 case RESULT_TYPE_CSM_PARAM:
4101 #if 0
4102 {
4103 SmartPtr<RkAiqIspCsmParamsProxy> params = result.dynamic_cast_ptr<RkAiqIspCsmParamsProxy>();
4104 if (params.ptr())
4105 convertAiqToIsp20Params(isp_cfg, params->data()->result);
4106 }
4107 #endif
4108 break;
4109 case RESULT_TYPE_CGC_PARAM:
4110 break;
4111 case RESULT_TYPE_CONV422_PARAM:
4112 break;
4113 case RESULT_TYPE_YUVCONV_PARAM:
4114 break;
4115 case RESULT_TYPE_GAIN_PARAM:
4116 {
4117 RkAiqIspGainParamsProxy* params = result.get_cast_ptr<RkAiqIspGainParamsProxy>();
4118 if (params)
4119 convertAiqGainToIsp20Params(isp_cfg, params->data()->result);
4120 }
4121 break;
4122 case RESULT_TYPE_CP_PARAM:
4123 {
4124 #if RKAIQ_HAVE_ACP_V10
4125 RkAiqIspCpParamsProxy* params = result.get_cast_ptr<RkAiqIspCpParamsProxy>();
4126 if (params)
4127 convertAiqCpToIsp20Params(isp_cfg, params->data()->result);
4128 #endif
4129 }
4130 break;
4131 case RESULT_TYPE_IE_PARAM:
4132 {
4133 #if RKAIQ_HAVE_AIE_V10
4134 RkAiqIspIeParamsProxy* params = result.get_cast_ptr<RkAiqIspIeParamsProxy>();
4135 if (params)
4136 convertAiqIeToIsp20Params(isp_cfg, params->data()->result);
4137 #endif
4138 }
4139 break;
4140 default:
4141 LOGE("unknown param type: 0x%x!", type);
4142 return false;
4143 }
4144
4145 /*
4146 * cam3aResultList &list = _cam3aConfig[result->getFrameId()];
4147 * list.push_back(result);
4148 */
4149
4150 return true;
4151 }
4152
merge_isp_results(cam3aResultList & results,void * isp_cfg,bool is_multi_isp)4153 XCamReturn Isp20Params::merge_isp_results(cam3aResultList &results, void* isp_cfg, bool is_multi_isp)
4154 {
4155 if (results.empty())
4156 return XCAM_RETURN_ERROR_PARAM;
4157
4158 mBlcResult = get_3a_result(results, RESULT_TYPE_BLC_PARAM).ptr();
4159
4160 LOG1_CAMHW_SUBM(ISP20PARAM_SUBM, "%s, isp cam3a results size: %d\n", __FUNCTION__, results.size());
4161 for (cam3aResultList::iterator iter = results.begin ();
4162 iter != results.end (); iter++)
4163 {
4164 SmartPtr<cam3aResult> &cam3a_result = *iter;
4165
4166 convert3aResultsToIspCfg(cam3a_result, isp_cfg, is_multi_isp);
4167 }
4168 results.clear();
4169 return XCAM_RETURN_NO_ERROR;
4170 }
4171
4172 template<>
merge_results(cam3aResultList & results,struct rkispp_params_nrcfg & pp_cfg)4173 XCamReturn Isp20Params::merge_results<struct rkispp_params_nrcfg>(cam3aResultList &results, struct rkispp_params_nrcfg &pp_cfg)
4174 {
4175 if (results.empty())
4176 return XCAM_RETURN_ERROR_PARAM;
4177
4178 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s, pp cam3a results size: %d\n", __FUNCTION__, results.size());
4179
4180 RkAiqIspSharpenParamsProxy* sharpen = nullptr;
4181 RkAiqIspEdgefltParamsProxy* edgeflt = nullptr;
4182
4183 for (cam3aResultList::iterator iter = results.begin ();
4184 iter != results.end ();)
4185 {
4186 SmartPtr<cam3aResult> &cam3a_result = *iter;
4187
4188 if (cam3a_result->getType() == RESULT_TYPE_SHARPEN_PARAM || \
4189 cam3a_result->getType() == RESULT_TYPE_EDGEFLT_PARAM) {
4190 if (cam3a_result->getType() == RESULT_TYPE_SHARPEN_PARAM)
4191 sharpen = cam3a_result.get_cast_ptr<RkAiqIspSharpenParamsProxy>();
4192 else if (cam3a_result->getType() == RESULT_TYPE_EDGEFLT_PARAM)
4193 edgeflt = cam3a_result.get_cast_ptr<RkAiqIspEdgefltParamsProxy>();
4194 #if RKAIQ_HAVE_ANR_V1
4195 if (sharpen && edgeflt)
4196 convertAiqSharpenToIsp20Params(pp_cfg, sharpen->data()->result, edgeflt->data()->result);
4197
4198 iter = results.erase (iter);
4199 #endif
4200 continue;
4201 }
4202 if (cam3a_result->getType() == RESULT_TYPE_UVNR_PARAM) {
4203 RkAiqIspUvnrParamsProxy* uvnr = cam3a_result.get_cast_ptr<RkAiqIspUvnrParamsProxy>();
4204 #if RKAIQ_HAVE_ANR_V1
4205 convertAiqUvnrToIsp20Params(pp_cfg, uvnr->data()->result);
4206 iter = results.erase (iter);
4207 #endif
4208 continue;
4209 }
4210 if (cam3a_result->getType() == RESULT_TYPE_YNR_PARAM) {
4211 RkAiqIspYnrParamsProxy* ynr = cam3a_result.get_cast_ptr<RkAiqIspYnrParamsProxy>();
4212 #if RKAIQ_HAVE_ANR_V1
4213 convertAiqYnrToIsp20Params(pp_cfg, ynr->data()->result);
4214 iter = results.erase (iter);
4215 #endif
4216 continue;
4217 }
4218 if (cam3a_result->getType() == RESULT_TYPE_ORB_PARAM) {
4219 RkAiqIspOrbParamsProxy* orb = cam3a_result.get_cast_ptr<RkAiqIspOrbParamsProxy>();
4220 convertAiqOrbToIsp20Params(pp_cfg, orb->data()->result);
4221 iter = results.erase (iter);
4222 continue;
4223 }
4224 ++iter;
4225 }
4226 return XCAM_RETURN_NO_ERROR;
4227 }
4228
get_tnr_cfg_params(cam3aResultList & results,struct rkispp_params_tnrcfg & tnr_cfg)4229 XCamReturn Isp20Params::get_tnr_cfg_params(cam3aResultList &results, struct rkispp_params_tnrcfg &tnr_cfg)
4230 {
4231 if (results.empty())
4232 return XCAM_RETURN_ERROR_PARAM;
4233
4234 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s, pp cam3a results size: %d\n", __FUNCTION__, results.size());
4235 SmartPtr<cam3aResult> cam3a_result = get_3a_result(results, RESULT_TYPE_TNR_PARAM);
4236 if (cam3a_result.ptr()) {
4237 RkAiqIspTnrParamsProxy* tnr = nullptr;
4238 tnr = cam3a_result.get_cast_ptr<RkAiqIspTnrParamsProxy>();
4239 #if RKAIQ_HAVE_ANR_V1
4240 if (tnr.ptr())
4241 convertAiqTnrToIsp20Params(tnr_cfg, tnr->data()->result);
4242 #endif
4243 }
4244 return XCAM_RETURN_NO_ERROR;
4245 }
4246
get_fec_cfg_params(cam3aResultList & results,struct rkispp_params_feccfg & fec_cfg)4247 XCamReturn Isp20Params::get_fec_cfg_params(cam3aResultList &results, struct rkispp_params_feccfg &fec_cfg)
4248 {
4249 if (results.empty())
4250 return XCAM_RETURN_ERROR_PARAM;
4251
4252 LOGE_CAMHW_SUBM(ISP20PARAM_SUBM, "%s, pp cam3a results size: %d\n", __FUNCTION__, results.size());
4253 SmartPtr<cam3aResult> cam3a_result = get_3a_result(results, RESULT_TYPE_FEC_PARAM);
4254 if (cam3a_result.ptr()) {
4255 RkAiqIspFecParamsProxy* fec = nullptr;
4256 fec = cam3a_result.get_cast_ptr<RkAiqIspFecParamsProxy>();
4257 if (fec) {
4258 convertAiqFecToIsp20Params(fec_cfg, fec->data()->result);
4259 }
4260 }
4261 return XCAM_RETURN_NO_ERROR;
4262 }
4263
4264 SmartPtr<cam3aResult>
get_3a_result(cam3aResultList & results,int32_t type)4265 Isp20Params::get_3a_result (cam3aResultList &results, int32_t type)
4266 {
4267 cam3aResultList::iterator i_res = results.begin();
4268 SmartPtr<cam3aResult> res = NULL;
4269
4270 for ( ; i_res != results.end(); ++i_res) {
4271 if (type == (*i_res)->getType ()) {
4272 res = (*i_res);
4273 break;
4274 }
4275 }
4276
4277 return res;
4278 }
4279
4280 } //namspace RkCam
4281 //TODO: to solve template ld compile issue, add isp21 source file here now.
4282 #include "isp21/Isp21Params.cpp"
4283 #include "isp3x/Isp3xParams.cpp"
4284 #include "isp32/Isp32Params.cpp"
4285