1 /*
2 * IspParamsSplitter.h - Split ISP params to Left/Right ISP params
3 *
4 * Copyright (c) 2021 Rockchip Electronics Co., Ltd
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 * Author: Cody Xie <cody.xie@rock-chips.com>
19 */
20 #include "IspParamsSplitter.h"
21
22 #include <utility>
23
24 #include "common/rk_isp20_hw.h"
25 #include "common/rkisp2-config.h"
26 #include "common/rkisp3-config.h"
27
28 #include "algos/ae/rk_aiq_types_ae_hw.h"
29
30 using namespace RkCam;
31
32 //#define DEBUG
33
34 #define MAX(a,b) (((a)>(b))?(a):(b))
35
36 namespace {
37 // Internal implementation to split submodule configs eg:
38 // * SplitIsp2xAeLittle
39 // * SplitIsp2xAeBig0
40 // * SplitIsp3xAeBig0
41 // Then a module can be an aggregation of submodules
42 // for example:
43 // SplitAecParams
44 // -> SplitIsp2xAeLittle
45 // -> SplitIsp3xAeBig0
46
47 /*********************************************/
48 /* Aec hwi splitter */
49 /*********************************************/
50
SplitAecWeight(u8 * ori_weight,u8 * left_weight,u8 * right_weight,WinSplitMode mode,u8 wnd_num)51 void SplitAecWeight(
52 u8* ori_weight,
53 u8* left_weight,
54 u8* right_weight,
55 WinSplitMode mode,
56 u8 wnd_num
57 ) {
58 switch (mode) {
59 case LEFT_AND_RIGHT_MODE:
60 for (int i = 0; i < wnd_num; i++) {
61 for (int j = 0; j < wnd_num; j++) {
62 left_weight[i * wnd_num + j] = ori_weight[i * wnd_num + j / 2];
63 right_weight[i * wnd_num + j] = ori_weight[i * wnd_num + j / 2 + j % 2 + wnd_num / 2];
64 }
65 }
66 break;
67 case LEFT_MODE:
68 case RIGHT_MODE:
69 memcpy(left_weight, ori_weight, wnd_num * wnd_num * sizeof(u8));
70 memcpy(right_weight, ori_weight, wnd_num * wnd_num * sizeof(u8));
71 default:
72 break;
73 }
74 }
75
SplitAecSubWin(u8 * subwin_en,struct isp2x_window * ori_win,struct isp2x_window * left_win,struct isp2x_window * right_win,IspParamsSplitter::Rectangle left_isp_rect_,IspParamsSplitter::Rectangle right_isp_rect_,WinSplitMode * mode)76 void SplitAecSubWin(
77 u8* subwin_en,
78 struct isp2x_window* ori_win,
79 struct isp2x_window* left_win,
80 struct isp2x_window* right_win,
81 IspParamsSplitter::Rectangle left_isp_rect_,
82 IspParamsSplitter::Rectangle right_isp_rect_,
83 WinSplitMode* mode
84 ) {
85
86 for (int i = 0; i < ISP2X_RAWAEBIG_SUBWIN_NUM; i++) {
87 if (subwin_en[i] == 1) { //only when subwin is enabled, should split hwi params
88 if (ori_win[i].h_offs + ori_win[i].h_size <= left_isp_rect_.w) {
89 #ifdef DEBUG
90 printf("win locate in left isp\n");
91 #endif
92 mode[i] = LEFT_MODE;
93
94 left_win[i].h_offs = ori_win[i].h_offs;
95 left_win[i].h_size = ori_win[i].h_size;
96 left_win[i].v_offs = ori_win[i].v_offs;
97 left_win[i].v_size = ori_win[i].v_size;
98
99 right_win[i].h_offs = 0;
100 right_win[i].h_size = ori_win[i].h_size;
101 right_win[i].v_offs = ori_win[i].v_offs;
102 right_win[i].v_size = ori_win[i].v_size;
103 }
104 else if (ori_win[i].h_offs >= right_isp_rect_.x) {
105 #ifdef DEBUG
106 printf("win locate in right isp\n");
107 #endif
108 mode[i] = RIGHT_MODE;
109
110 //win only locate in right isp, actually stats of left isp would not be used
111 left_win[i].h_offs = 0;
112 left_win[i].h_size = ori_win[i].h_size;
113 left_win[i].v_offs = ori_win[i].v_offs;
114 left_win[i].v_size = ori_win[i].v_size;
115
116 right_win[i].h_offs = ori_win[i].h_offs - right_isp_rect_.x;
117 right_win[i].h_size = ori_win[i].h_size;
118 right_win[i].v_offs = ori_win[i].v_offs;
119 right_win[i].v_size = ori_win[i].v_size;
120
121 }
122 else {
123 #ifdef DEBUG
124 printf(" win locate at left&right isp\n");
125 #endif
126 mode[i] = LEFT_AND_RIGHT_MODE;
127
128 left_win[i].h_offs = ori_win[i].h_offs;
129 left_win[i].h_size = MAX(0, ((long)left_isp_rect_.w - (long)left_win[i].h_offs));
130 left_win[i].v_offs = ori_win[i].v_offs;
131 left_win[i].v_size = ori_win[i].v_size;
132
133
134 right_win[i].h_offs = left_win[i].h_offs + left_win[i].h_size - right_isp_rect_.x;
135 right_win[i].h_size = MAX(0, ((long)ori_win[i].h_size - (long)left_win[i].h_size));
136 right_win[i].v_offs = ori_win[i].v_offs;
137 right_win[i].v_size = ori_win[i].v_size;
138 }
139 }
140 }
141 }
142
SplitAecCalcBlockSize(struct isp2x_window * left_win,struct isp2x_window * right_win,u8 wnd_num,IspParamsSplitter::Rectangle right_isp_rect_,u16 * block_h)143 void SplitAecCalcBlockSize(
144 struct isp2x_window* left_win,
145 struct isp2x_window* right_win,
146 u8 wnd_num,
147 IspParamsSplitter::Rectangle right_isp_rect_,
148 u16* block_h
149 ) {
150
151 bool loop_en = true;
152
153 while (loop_en && *block_h > 0) {
154
155 left_win->h_size = *block_h * wnd_num;
156 right_win->h_offs = (left_win->h_size + left_win->h_offs > right_isp_rect_.x) ?
157 left_win->h_size + left_win->h_offs - right_isp_rect_.x : 0;
158
159 if (u32(right_win->h_offs + *block_h * wnd_num) > right_isp_rect_.w - 1) {
160
161 (*block_h)--;
162
163 }
164 else {
165 loop_en = false;
166
167 //if (*block_h % 2)
168 //(*block_h)--;
169
170 left_win->h_size = *block_h * wnd_num;
171 right_win->h_offs = (left_win->h_size + left_win->h_offs > right_isp_rect_.x) ?
172 left_win->h_size + left_win->h_offs - right_isp_rect_.x : 0;
173 right_win->h_offs = right_win->h_offs & 0xfffe;
174 right_win->h_size = *block_h * wnd_num;
175 }
176 }
177 }
178
SplitAecWin(isp2x_window * ori_win,isp2x_window * left_win,isp2x_window * right_win,u8 wnd_num,IspParamsSplitter::Rectangle left_isp_rect_,IspParamsSplitter::Rectangle right_isp_rect_,WinSplitMode * mode)179 void SplitAecWin(
180 isp2x_window* ori_win,
181 isp2x_window* left_win,
182 isp2x_window* right_win,
183 u8 wnd_num,
184 IspParamsSplitter::Rectangle left_isp_rect_,
185 IspParamsSplitter::Rectangle right_isp_rect_,
186 WinSplitMode* mode
187 ) {
188
189 //win only locate in left isp, actually stats of right isp would not be used
190 if (ori_win->h_offs + ori_win->h_size <= left_isp_rect_.w) {
191
192 #ifdef DEBUG
193 printf("win locate in left isp\n");
194 #endif
195 *mode = LEFT_MODE;
196
197 left_win->h_offs = ori_win->h_offs;
198 left_win->h_size = ori_win->h_size;
199 left_win->v_offs = ori_win->v_offs;
200 left_win->v_size = ori_win->v_size;
201
202 right_win->h_offs = 0;
203 right_win->h_size = ori_win->h_size;
204 right_win->v_offs = ori_win->v_offs;
205 right_win->v_size = ori_win->v_size;
206 }
207 else if (ori_win->h_offs >= right_isp_rect_.x) {
208
209 #ifdef DEBUG
210 printf("win locate in right isp\n");
211 #endif
212 *mode = RIGHT_MODE;
213
214 //win only locate in right isp, actually stats of left isp would not be used
215 left_win->h_offs = 0;
216 left_win->h_size = ori_win->h_size;
217 left_win->v_offs = ori_win->v_offs;
218 left_win->v_size = ori_win->v_size;
219
220 right_win->h_offs = ori_win->h_offs - right_isp_rect_.x;
221 right_win->h_size = ori_win->h_size;
222 right_win->v_offs = ori_win->v_offs;
223 right_win->v_size = ori_win->v_size;
224
225 }
226 else {
227 if ((ori_win->h_offs + ori_win->h_size / 2) <= left_isp_rect_.w
228 && right_isp_rect_.x <= (ori_win->h_offs + ori_win->h_size / 2)) {
229 #ifdef DEBUG
230 printf(" win locate at left&right isp,and center line locate in overlapping zone!\n");
231 #endif
232 *mode = LEFT_AND_RIGHT_MODE;
233
234 //win center locate at overlap zone
235 left_win->h_offs = ori_win->h_offs;
236 left_win->v_offs = ori_win->v_offs;
237 left_win->v_size = ori_win->v_size;
238
239 right_win->v_offs = ori_win->v_offs;
240 right_win->v_size = ori_win->v_size;
241
242 u16 block_h = ori_win->h_size / (2 * wnd_num);
243 SplitAecCalcBlockSize(left_win, right_win, wnd_num, right_isp_rect_, &block_h);
244 }
245 else {
246 #ifdef DEBUG
247 printf(" win locate at left&right isp,but center line not locate in overlapping zone!\n");
248 #endif
249 if ((ori_win->h_offs + ori_win->h_size / 2) < right_isp_rect_.x) {
250
251 left_win->h_offs = ori_win->h_offs;
252 left_win->v_offs = ori_win->v_offs;
253 left_win->v_size = ori_win->v_size;
254
255 right_win->v_offs = ori_win->v_offs;
256 right_win->v_size = ori_win->v_size;
257
258 u16 h_size_tmp1 = left_isp_rect_.w - ori_win->h_offs;
259 u16 h_size_tmp2 = (right_isp_rect_.x - ori_win->h_offs) * 2;
260
261 if (abs(ori_win->h_size - h_size_tmp1) < abs(ori_win->h_size - h_size_tmp2)) {
262 #ifdef DEBUG
263 printf("correct glb.h_size %d to %d\n", ori_win->h_size, h_size_tmp1);
264 #endif
265 *mode = LEFT_MODE;
266
267 ori_win->h_size = h_size_tmp1;
268
269 left_win->h_size = ori_win->h_size;
270 //actually stats of right isp would not be used
271 right_win->h_offs = 0;
272 right_win->h_size = ori_win->h_size;
273 }
274 else {
275 #ifdef DEBUG
276 printf("correct glb.h_size %d to %d\n", ori_win->h_size, h_size_tmp2);
277 #endif
278 *mode = LEFT_AND_RIGHT_MODE;
279
280 ori_win->h_size = h_size_tmp2;
281
282 u16 block_h = ori_win->h_size / (2 * wnd_num);
283 SplitAecCalcBlockSize(left_win, right_win, wnd_num, right_isp_rect_, &block_h);
284 }
285 }
286 else {
287 left_win->v_offs = ori_win->v_offs;
288 left_win->v_size = ori_win->v_size;
289
290 right_win->v_offs = ori_win->v_offs;
291 right_win->v_size = ori_win->v_size;
292
293 u16 h_size_tmp1 = ori_win->h_offs + ori_win->h_size - right_isp_rect_.x;
294 u16 h_size_tmp2 = (ori_win->h_offs + ori_win->h_size - left_isp_rect_.w) * 2;
295
296 if (abs(ori_win->h_size - h_size_tmp1) < abs(ori_win->h_size - h_size_tmp2)) {
297
298 #ifdef DEBUG
299 printf("correct glb.h_off %d to %d\n", ori_win->h_offs, right_isp_rect_.x);
300 printf("correct glb.h_size %d to %d\n", ori_win->h_size, h_size_tmp1);
301 #endif
302
303 *mode = RIGHT_MODE;
304
305 ori_win->h_size = h_size_tmp1;
306 ori_win->h_offs = right_isp_rect_.x;
307
308 right_win->h_offs = 0;
309 right_win->h_size = ori_win->h_size;
310
311 //actually stats of left isp would not be used
312 left_win->h_offs = 0;
313 left_win->h_size = ori_win->h_size;
314 }
315 else {
316 #ifdef DEBUG
317 printf("correct glb.h_off %d to %d\n", ori_win->h_offs,
318 ori_win->h_offs + ori_win->h_size - (ori_win->h_offs + ori_win->h_size - left_isp_rect_.w) * 2);
319 printf("correct glb.h_size %d to %d\n", ori_win->h_size, h_size_tmp2);
320 #endif
321 *mode = LEFT_AND_RIGHT_MODE;
322
323 ori_win->h_offs = ori_win->h_offs + ori_win->h_size - (ori_win->h_offs + ori_win->h_size - left_isp_rect_.w) * 2;
324 ori_win->h_size = h_size_tmp2;
325 left_win->h_offs = ori_win->h_offs;
326
327 u16 block_h = ori_win->h_size / (2 * wnd_num);
328 SplitAecCalcBlockSize(left_win, right_win, wnd_num, right_isp_rect_, &block_h);
329 }
330 }
331 }
332 }
333 }
334
335 /*********************************************/
336 /* other module hwi splitter */
337 /*********************************************/
338
SplitAwbCalcBlockSize(struct isp2x_window * left_win,struct isp2x_window * right_win,u8 ds_awb,u8 wnd_num,IspParamsSplitter::Rectangle right_isp_rect_,u16 * block_h)339 void SplitAwbCalcBlockSize(
340 struct isp2x_window* left_win,
341 struct isp2x_window* right_win,
342 u8 ds_awb,
343 u8 wnd_num,
344 IspParamsSplitter::Rectangle right_isp_rect_,
345 u16* block_h
346 ) {
347
348 bool loop_en = true;
349 int i = 0;
350
351 while (loop_en && *block_h > 0) {
352
353 left_win->h_size = (*block_h * wnd_num) << ds_awb;
354
355 right_win->h_offs = (left_win->h_size + left_win->h_offs > right_isp_rect_.x) ?
356 left_win->h_size + left_win->h_offs - right_isp_rect_.x : 0;
357
358 if (u32(right_win->h_offs + left_win->h_size) > right_isp_rect_.w ) {
359 (*block_h)--;
360 }
361 else {
362 loop_en = false;
363
364 //if (*block_h % 2)
365 // (*block_h)--;
366
367 left_win->h_size = (*block_h * wnd_num) << ds_awb;
368 right_win->h_offs = (left_win->h_size + left_win->h_offs > right_isp_rect_.x) ?
369 left_win->h_size + left_win->h_offs - right_isp_rect_.x : 0;
370 right_win->h_offs = right_win->h_offs & 0xfffe;
371 right_win->h_size = (*block_h * wnd_num) << ds_awb;
372 }
373 }
374 }
375
SplitAwbWin(isp2x_window * ori_win,isp2x_window * left_win,isp2x_window * right_win,u8 ds_awb,u8 wnd_num,IspParamsSplitter::Rectangle left_isp_rect_,IspParamsSplitter::Rectangle right_isp_rect_,WinSplitMode * mode)376 void SplitAwbWin(
377 isp2x_window* ori_win,
378 isp2x_window* left_win,
379 isp2x_window* right_win,
380 u8 ds_awb,
381 u8 wnd_num,
382 IspParamsSplitter::Rectangle left_isp_rect_,
383 IspParamsSplitter::Rectangle right_isp_rect_,
384 WinSplitMode* mode
385 ) {
386
387 u16 win_ds_hsize = ori_win->h_size >> ds_awb;
388 u16 ori_win_hsize_clip = win_ds_hsize << ds_awb;
389
390 //win only locate in left isp, actually stats of right isp would not be used
391 if (ori_win->h_offs + ori_win_hsize_clip <= left_isp_rect_.w) {
392
393 LOG1_AWB("win locate in left isp\n");
394
395 *mode = LEFT_MODE;
396
397 left_win->h_offs = ori_win->h_offs;
398 left_win->h_size = ori_win_hsize_clip;
399 left_win->v_offs = ori_win->v_offs;
400 left_win->v_size = ori_win->v_size;
401
402 right_win->h_offs = 0;
403 right_win->h_size = ori_win_hsize_clip;
404 right_win->v_offs = ori_win->v_offs;
405 right_win->v_size = ori_win->v_size;
406 }
407 else if (ori_win->h_offs >= right_isp_rect_.x) {
408
409 LOG1_AWB("win locate in right isp\n");
410
411 *mode = RIGHT_MODE;
412
413 //win only locate in right isp, actually stats of left isp would not be used
414 left_win->h_offs = 0;
415 left_win->h_size = ori_win->h_size;
416 left_win->v_offs = ori_win->v_offs;
417 left_win->v_size = ori_win->v_size;
418
419 right_win->h_offs = ori_win->h_offs - right_isp_rect_.x;
420 right_win->h_size = ori_win->h_size;
421 right_win->v_offs = ori_win->v_offs;
422 right_win->v_size = ori_win->v_size;
423
424 }
425 else {
426
427 if ((ori_win->h_offs + ori_win->h_size / 2) <= left_isp_rect_.w
428 && right_isp_rect_.x <= (ori_win->h_offs + ori_win->h_size / 2)) {
429
430 LOG1_AWB(" win locate at left&right isp,and center line locate in overlapping zone!\n");
431
432 *mode = LEFT_AND_RIGHT_MODE;
433
434 //win center locate at overlap zone
435 left_win->h_offs = ori_win->h_offs;
436 left_win->v_offs = ori_win->v_offs;
437 left_win->v_size = ori_win->v_size;
438
439 right_win->v_offs = ori_win->v_offs;
440 right_win->v_size = ori_win->v_size;
441 // u16 block_h = ori_win->h_size / (2 * wnd_num);
442
443 u16 block_h = win_ds_hsize / (2 * wnd_num);
444
445 left_win->h_size = (block_h * wnd_num) << ds_awb;
446
447 right_win->h_offs = (left_win->h_size + left_win->h_offs > right_isp_rect_.x) ?
448 left_win->h_size + left_win->h_offs - right_isp_rect_.x : 0;
449 right_win->h_offs = right_win->h_offs & 0xfffe;
450 right_win->h_size = (win_ds_hsize - block_h * wnd_num) << ds_awb;
451 right_win->h_size = right_win->h_offs + right_win->h_size > right_isp_rect_.w ? (right_isp_rect_.w - right_win->h_offs) : right_win->h_size;
452 }
453 else {
454
455 LOG1_AWB(" win locate at left&right isp,but center line not locate in overlapping zone!\n");
456
457 if ((ori_win->h_offs + ori_win->h_size / 2) < right_isp_rect_.x) {
458
459 left_win->h_offs = ori_win->h_offs;
460 left_win->v_offs = ori_win->v_offs;
461 left_win->v_size = ori_win->v_size;
462
463 right_win->v_offs = ori_win->v_offs;
464 right_win->v_size = ori_win->v_size;
465
466 u16 h_size_tmp1 = left_isp_rect_.w - ori_win->h_offs;
467 u16 h_size_tmp2 = (right_isp_rect_.x - ori_win->h_offs) * 2;
468
469 if (abs(ori_win_hsize_clip - h_size_tmp1) < abs(ori_win_hsize_clip - h_size_tmp2)) {
470
471 LOG1_AWB("correct glb.h_size %d to %d\n", ori_win->h_size, h_size_tmp1);
472
473 *mode = LEFT_MODE;
474
475 ori_win->h_size = h_size_tmp1;
476
477 left_win->h_size = ori_win->h_size;
478 //actually stats of right isp would not be used
479 right_win->h_offs = 0;
480 right_win->h_size = ori_win->h_size;
481 }
482 else {
483 LOG1_AWB("correct glb.h_size %d to %d\n", ori_win->h_size, h_size_tmp2);
484 *mode = LEFT_AND_RIGHT_MODE;
485
486 ori_win->h_size = h_size_tmp2;
487 win_ds_hsize = ori_win->h_size >> ds_awb;
488
489 u16 block_h = win_ds_hsize / (2 * wnd_num);
490
491 SplitAwbCalcBlockSize(left_win, right_win, ds_awb, wnd_num, right_isp_rect_, &block_h);
492 }
493 }
494 else {
495 left_win->v_offs = ori_win->v_offs;
496 left_win->v_size = ori_win->v_size;
497
498 right_win->v_offs = ori_win->v_offs;
499 right_win->v_size = ori_win->v_size;
500
501 u16 h_size_tmp1 = ori_win->h_offs + ori_win->h_size - right_isp_rect_.x;
502 u16 h_size_tmp2 = (ori_win->h_offs + ori_win->h_size - left_isp_rect_.w) * 2;
503
504 if (abs(ori_win_hsize_clip - h_size_tmp1) < abs(ori_win_hsize_clip - h_size_tmp2)) {
505
506 LOG1_AWB("correct glb.h_off %d to %d\n", ori_win->h_offs, right_isp_rect_.x);
507 LOG1_AWB("correct glb.h_size %d to %d\n", ori_win->h_size, h_size_tmp1);
508
509 *mode = RIGHT_MODE;
510
511 ori_win->h_size = h_size_tmp1;
512 ori_win->h_offs = right_isp_rect_.x;
513
514 right_win->h_offs = 0;
515 right_win->h_size = ori_win->h_size;
516
517 //actually stats of left isp would not be used
518 left_win->h_offs = 0;
519 left_win->h_size = ori_win->h_size;
520 }
521 else {
522
523 LOG1_AWB("correct glb.h_off %d to %d\n", ori_win->h_offs,
524 ori_win->h_offs + ori_win->h_size - (ori_win->h_offs + ori_win->h_size - left_isp_rect_.w) * 2);
525 LOG1_AWB("correct glb.h_size %d to %d\n", ori_win->h_size, h_size_tmp2);
526
527 *mode = LEFT_AND_RIGHT_MODE;
528
529 ori_win->h_offs = ori_win->h_offs + ori_win->h_size - (ori_win->h_offs + ori_win->h_size - left_isp_rect_.w) * 2;
530 ori_win->h_size = h_size_tmp2;
531 left_win->h_offs = ori_win->h_offs;
532
533 win_ds_hsize = ori_win->h_size >> ds_awb;
534
535 u16 block_h = win_ds_hsize / (2 * wnd_num);
536
537 SplitAwbCalcBlockSize(left_win, right_win, ds_awb, wnd_num, right_isp_rect_, &block_h);
538 }
539 }
540 }
541 }
542 }
543
SplitAwbMultiWin(struct isp2x_window * ori_win,struct isp2x_window * left_win,struct isp2x_window * right_win,struct isp2x_window * main_left_win,struct isp2x_window * main_right_win,IspParamsSplitter::Rectangle left_isp_rect_,IspParamsSplitter::Rectangle right_isp_rect_,WinSplitMode * mode)544 void SplitAwbMultiWin(
545 struct isp2x_window* ori_win,
546 struct isp2x_window* left_win,
547 struct isp2x_window* right_win,
548 struct isp2x_window* main_left_win,
549 struct isp2x_window* main_right_win,
550 IspParamsSplitter::Rectangle left_isp_rect_,
551 IspParamsSplitter::Rectangle right_isp_rect_,
552 WinSplitMode* mode
553 ) {
554 if (ori_win->h_offs + ori_win->h_size <= main_left_win->h_offs + main_left_win->h_size) {
555
556 LOG1_AWB("win locate in left isp\n");
557
558 *mode = LEFT_MODE;
559
560 left_win->h_offs = ori_win->h_offs;
561 left_win->h_size = ori_win->h_size;
562 left_win->v_offs = ori_win->v_offs;
563 left_win->v_size = ori_win->v_size;
564
565 right_win->h_offs = 0;
566 right_win->h_size = 0;
567 right_win->v_offs = 0;
568 right_win->v_size = 0;
569 }
570 else if (ori_win->h_offs >= right_isp_rect_.x + main_right_win->h_offs) {
571
572 LOG1_AWB("win locate in right isp\n");
573
574 *mode = RIGHT_MODE;
575
576 //win only locate in right isp, actually stats of left isp would not be used
577 left_win->h_offs = 0;
578 left_win->h_size = 0;
579 left_win->v_offs = 0;
580 left_win->v_size = 0;
581
582 right_win->h_offs = MAX((int)main_right_win->h_offs, (int)ori_win->h_offs - (int)right_isp_rect_.x);
583 right_win->h_size = ori_win->h_size;
584 right_win->v_offs = ori_win->v_offs;
585 right_win->v_size = ori_win->v_size;
586
587 }
588 else {
589
590 LOG1_AWB(" win locate at left&right isp\n");
591
592 *mode = LEFT_AND_RIGHT_MODE;
593
594 left_win->h_offs = ori_win->h_offs;
595 left_win->h_size = MAX(0, ((int)main_left_win->h_offs + (int)main_left_win->h_size - (int)left_win->h_offs));
596 left_win->v_offs = ori_win->v_offs;
597 left_win->v_size = ori_win->v_size;
598
599
600 right_win->h_offs = MAX((int)main_right_win->h_offs, (int)left_win->h_offs + (int)left_win->h_size - (int)right_isp_rect_.x);
601 right_win->h_size = MAX(0, ((int)ori_win->h_size - (int)left_win->h_size));
602 right_win->v_offs = ori_win->v_offs;
603 right_win->v_size = ori_win->v_size;
604 }
605 }
606
607 }
608
609 template <>
SplitRawAeLiteParams(struct isp2x_rawaelite_meas_cfg * ori,struct isp2x_rawaelite_meas_cfg * left,struct isp2x_rawaelite_meas_cfg * right)610 XCamReturn IspParamsSplitter::SplitRawAeLiteParams<struct isp2x_rawaelite_meas_cfg>(
611 struct isp2x_rawaelite_meas_cfg* ori, struct isp2x_rawaelite_meas_cfg* left,
612 struct isp2x_rawaelite_meas_cfg* right) {
613
614 u8 wnd_num = 0;
615 if (ori->wnd_num == 0)
616 wnd_num = 1;
617 else
618 wnd_num = 5;
619
620 WinSplitMode mode = LEFT_AND_RIGHT_MODE;
621 WinSplitMode sub_mode[4] = {LEFT_AND_RIGHT_MODE};
622
623 SplitAecWin(&ori->win, &left->win, &right->win, wnd_num, left_isp_rect_, right_isp_rect_, &mode);
624
625 #ifdef DEBUG
626 printf("AeLite left=%d-%d-%d-%d, right=%d-%d-%d-%d\n", left->win.h_offs, left->win.v_offs,
627 left->win.h_size, left->win.v_size, right->win.h_offs, right->win.v_offs,
628 right->win.h_size, right->win.v_size);
629 #endif
630
631 return XCAM_RETURN_NO_ERROR;
632 }
633
634 template <>
SplitRawAeBigParams(struct isp2x_rawaebig_meas_cfg * ori,struct isp2x_rawaebig_meas_cfg * left,struct isp2x_rawaebig_meas_cfg * right)635 XCamReturn IspParamsSplitter::SplitRawAeBigParams<struct isp2x_rawaebig_meas_cfg>(
636 struct isp2x_rawaebig_meas_cfg* ori, struct isp2x_rawaebig_meas_cfg* left,
637 struct isp2x_rawaebig_meas_cfg* right) {
638
639 u8 wnd_num = 0;
640
641 if (ori->wnd_num == 0)
642 wnd_num = 1;
643 else if (ori->wnd_num == 1)
644 wnd_num = 5;
645 else
646 wnd_num = 15;
647
648 WinSplitMode mode = LEFT_AND_RIGHT_MODE;
649 WinSplitMode sub_mode[4] = {LEFT_AND_RIGHT_MODE};
650
651 SplitAecWin(&ori->win, &left->win, &right->win, wnd_num, left_isp_rect_, right_isp_rect_, &mode);
652 SplitAecSubWin(ori->subwin_en, ori->subwin, left->subwin, right->subwin, left_isp_rect_, right_isp_rect_, sub_mode);
653
654 for (int i = 0; i < ISP2X_RAWAEBIG_SUBWIN_NUM; i++) {
655 if (ori->subwin_en[i]) {
656 switch (sub_mode[i]) {
657 case LEFT_AND_RIGHT_MODE:
658 left->subwin_en[i] = true;
659 right->subwin_en[i] = true;
660 break;
661 case LEFT_MODE:
662 left->subwin_en[i] = true;
663 right->subwin_en[i] = false;
664 break;
665 case RIGHT_MODE:
666 left->subwin_en[i] = false;
667 right->subwin_en[i] = true;
668 break;
669
670 }
671 }
672 }
673
674 #ifdef DEBUG
675 printf("AeBig left=%d-%d-%d-%d, right=%d-%d-%d-%d\n", left->win.h_offs, left->win.v_offs,
676 left->win.h_size, left->win.v_size, right->win.h_offs, right->win.v_offs,
677 right->win.h_size, right->win.v_size);
678 #endif
679
680 return XCAM_RETURN_NO_ERROR;
681
682 }
683
684
685 template <>
SplitRawHistLiteParams(struct isp2x_rawhistlite_cfg * ori,struct isp2x_rawhistlite_cfg * left,struct isp2x_rawhistlite_cfg * right)686 XCamReturn IspParamsSplitter::SplitRawHistLiteParams<struct isp2x_rawhistlite_cfg>(
687 struct isp2x_rawhistlite_cfg* ori, struct isp2x_rawhistlite_cfg* left,
688 struct isp2x_rawhistlite_cfg* right) {
689
690 u8 wnd_num = 0;
691 wnd_num = 5;
692
693 WinSplitMode mode = LEFT_AND_RIGHT_MODE;
694
695 SplitAecWin(&ori->win, &left->win, &right->win, wnd_num, left_isp_rect_, right_isp_rect_, &mode);
696 SplitAecWeight(ori->weight, left->weight, right->weight, mode, wnd_num);
697
698 #ifdef DEBUG
699 printf("HistLite left=%d-%d-%d-%d, right=%d-%d-%d-%d\n", left->win.h_offs, left->win.v_offs,
700 left->win.h_size, left->win.v_size, right->win.h_offs, right->win.v_offs,
701 right->win.h_size, right->win.v_size);
702
703 for (int i = 0; i < wnd_num; i++) {
704 for (int j = 0; j < wnd_num; j++)
705 printf("%d ", left->weight[i * wnd_num + j]);
706 printf("\n");
707 }
708 for (int i = 0; i < wnd_num; i++) {
709 for (int j = 0; j < wnd_num; j++)
710 printf("%d ", right->weight[i * wnd_num + j]);
711 printf("\n");
712 }
713 #endif
714
715 return XCAM_RETURN_NO_ERROR;
716
717 }
718
719 template <>
SplitRawHistBigParams(struct isp2x_rawhistbig_cfg * ori,struct isp2x_rawhistbig_cfg * left,struct isp2x_rawhistbig_cfg * right)720 XCamReturn IspParamsSplitter::SplitRawHistBigParams<struct isp2x_rawhistbig_cfg>(
721 struct isp2x_rawhistbig_cfg* ori, struct isp2x_rawhistbig_cfg* left,
722 struct isp2x_rawhistbig_cfg* right) {
723
724 u8 wnd_num = 0;
725
726 if (ori->wnd_num <= 1)
727 wnd_num = 5;
728 else
729 wnd_num = 15;
730
731
732 WinSplitMode mode = LEFT_AND_RIGHT_MODE;
733
734 SplitAecWin(&ori->win, &left->win, &right->win, wnd_num, left_isp_rect_, right_isp_rect_, &mode);
735 SplitAecWeight(ori->weight, left->weight, right->weight, mode, wnd_num);
736
737 #ifdef DEBUG
738 printf("HistBig left=%d-%d-%d-%d, right=%d-%d-%d-%d\n", left->win.h_offs, left->win.v_offs,
739 left->win.h_size, left->win.v_size, right->win.h_offs, right->win.v_offs,
740 right->win.h_size, right->win.v_size);
741
742 for (int i = 0; i < wnd_num; i++) {
743 for (int j = 0; j < wnd_num; j++)
744 printf("%d ", left->weight[i * wnd_num + j]);
745 printf("\n");
746 }
747 for (int i = 0; i < wnd_num; i++) {
748 for (int j = 0; j < wnd_num; j++)
749 printf("%d ", right->weight[i * wnd_num + j]);
750 printf("\n");
751 }
752
753 #endif
754
755 return XCAM_RETURN_NO_ERROR;
756
757 }
758
759
760 template <>
SplitAecParams(struct isp3x_isp_params_cfg * ori,struct isp3x_isp_params_cfg * left,struct isp3x_isp_params_cfg * right)761 XCamReturn IspParamsSplitter::SplitAecParams<struct isp3x_isp_params_cfg>(
762 struct isp3x_isp_params_cfg* ori,
763 struct isp3x_isp_params_cfg* left,
764 struct isp3x_isp_params_cfg* right) {
765
766 XCamReturn ret = XCAM_RETURN_NO_ERROR;
767
768 //RAWAE
769
770 ret = SplitRawAeLiteParams(&ori->meas.rawae0, &left->meas.rawae0, &right->meas.rawae0);
771 ret = SplitRawAeBigParams(&ori->meas.rawae1, &left->meas.rawae1, &right->meas.rawae1);
772 ret = SplitRawAeBigParams(&ori->meas.rawae2, &left->meas.rawae2, &right->meas.rawae2);
773 ret = SplitRawAeBigParams(&ori->meas.rawae3, &left->meas.rawae3, &right->meas.rawae3);
774
775 //RAWHIST
776
777 ret = SplitRawHistLiteParams(&ori->meas.rawhist0, &left->meas.rawhist0, &right->meas.rawhist0);
778 ret = SplitRawHistBigParams(&ori->meas.rawhist1, &left->meas.rawhist1, &right->meas.rawhist1);
779 ret = SplitRawHistBigParams(&ori->meas.rawhist2, &left->meas.rawhist2, &right->meas.rawhist2);
780 ret = SplitRawHistBigParams(&ori->meas.rawhist3, &left->meas.rawhist3, &right->meas.rawhist3);
781
782
783 return XCAM_RETURN_NO_ERROR;
784 }
785
786 // split Awb param
787
788 template <>
SplitAwbParams(struct isp3x_isp_params_cfg * ori,struct isp3x_isp_params_cfg * left,struct isp3x_isp_params_cfg * right)789 XCamReturn IspParamsSplitter::SplitAwbParams<struct isp3x_isp_params_cfg>(
790 struct isp3x_isp_params_cfg* ori,
791 struct isp3x_isp_params_cfg* left,
792 struct isp3x_isp_params_cfg* right) {
793
794 XCamReturn ret = XCAM_RETURN_NO_ERROR;
795
796 isp2x_window ori_win;
797 isp2x_window left_win;
798 isp2x_window right_win;
799 WinSplitMode mode = LEFT_AND_RIGHT_MODE;
800 u8 wnd_num = 15;
801
802 ori_win.h_offs = ori->meas.rawawb.sw_rawawb_h_offs;
803 ori_win.h_size = ori->meas.rawawb.sw_rawawb_h_size;
804 ori_win.v_offs = ori->meas.rawawb.sw_rawawb_v_offs;
805 ori_win.v_size = ori->meas.rawawb.sw_rawawb_v_size;
806
807 memcpy(&left_win, &ori_win, sizeof(ori_win));
808 memcpy(&right_win, &ori_win, sizeof(ori_win));
809
810 // Awb measure window
811 u8 awb_ds;
812 if (ori->meas.rawawb.sw_rawawb_wind_size == 0) {
813 awb_ds = 2;
814 } else {
815 awb_ds = 3;
816 }
817 u16 min_hsize = wnd_num << awb_ds;
818
819 SplitAwbWin(&ori_win, &left_win, &right_win, awb_ds, wnd_num, left_isp_rect_, right_isp_rect_, &mode);
820 if (ori_win.h_size < min_hsize) {
821 ori->meas.rawawb.sw_rawawb_blk_measure_enable = 0;
822 left->meas.rawawb.sw_rawawb_blk_measure_enable = 0;
823 right->meas.rawawb.sw_rawawb_blk_measure_enable = 0;
824 }
825 else {
826 if (mode == LEFT_AND_RIGHT_MODE) {
827 if (left_win.h_size < min_hsize)
828 left->meas.rawawb.sw_rawawb_blk_measure_enable = 0;
829 if (right_win.h_size < min_hsize)
830 right->meas.rawawb.sw_rawawb_blk_measure_enable = 0;
831 }
832 }
833
834 // Awb blk_wei_w
835 //SplitAwbWeight(&ori_win, &left_win, &right_win, ori->meas.rawawb.sw_rawawb_wp_blk_wei_w, left->meas.rawawb.sw_rawawb_wp_blk_wei_w, right->meas.rawawb.sw_rawawb_wp_blk_wei_w, mode, wnd_num);
836 SplitAecWeight(ori->meas.rawawb.sw_rawawb_wp_blk_wei_w, left->meas.rawawb.sw_rawawb_wp_blk_wei_w, right->meas.rawawb.sw_rawawb_wp_blk_wei_w, mode, wnd_num);
837
838 left->meas.rawawb.sw_rawawb_h_offs = left_win.h_offs;
839 left->meas.rawawb.sw_rawawb_h_size = left_win.h_size;
840 left->meas.rawawb.sw_rawawb_v_offs = left_win.v_offs;
841 left->meas.rawawb.sw_rawawb_v_size = left_win.v_size;
842
843 right->meas.rawawb.sw_rawawb_h_offs = right_win.h_offs;
844 right->meas.rawawb.sw_rawawb_h_size = right_win.h_size;
845 right->meas.rawawb.sw_rawawb_v_offs = right_win.v_offs;
846 right->meas.rawawb.sw_rawawb_v_size = right_win.v_size;
847
848 LOGD_AWB("Awb measure window left=%d-%d-%d-%d, right=%d-%d-%d-%d\n", left_win.h_offs, left_win.v_offs,
849 left_win.h_size, left_win.v_size, right_win.h_offs, right_win.v_offs,
850 right_win.h_size, right_win.v_size);
851
852 LOGV_AWB("Awb block weight: \n LEFT = { \n");
853
854 for (int i = 0; i < wnd_num; i++) {
855 for (int j = 0; j < wnd_num; j++)
856 LOGV_AWB("%d ", left->meas.rawawb.sw_rawawb_wp_blk_wei_w[i * wnd_num + j]);
857 LOGV_AWB("\n");
858 }
859 LOGV_AWB("} \n RIGHT = { \n");
860
861 for (int i = 0; i < wnd_num; i++) {
862 for (int j = 0; j < wnd_num; j++)
863 LOGV_AWB("%d ", right->meas.rawawb.sw_rawawb_wp_blk_wei_w[i * wnd_num + j]);
864 LOGV_AWB("\n");
865 }
866 LOGV_AWB("} \n");
867
868 // Awb Multi Window
869 isp2x_window sub_ori_win;
870 isp2x_window sub_left_win;
871 isp2x_window sub_right_win;
872 u16 sub_win_st = 0;
873 u16 sub_win_ed = 0;
874 u16 main_win_st = 0;
875 u16 main_win_ed = 0;
876
877 if (ori->meas.rawawb.sw_rawawb_multiwindow_en) {
878 // Awb Multi window 0
879 sub_ori_win.h_offs = ori->meas.rawawb.sw_rawawb_multiwindow0_h_offs;
880 sub_ori_win.h_size = ori->meas.rawawb.sw_rawawb_multiwindow0_h_size-ori->meas.rawawb.sw_rawawb_multiwindow0_h_offs;
881 sub_ori_win.v_offs = ori->meas.rawawb.sw_rawawb_multiwindow0_v_offs;
882 sub_ori_win.v_size = ori->meas.rawawb.sw_rawawb_multiwindow0_v_size-ori->meas.rawawb.sw_rawawb_multiwindow0_v_offs;
883
884 sub_win_st = left_isp_rect_.x + sub_ori_win.h_offs;
885 sub_win_ed = sub_win_st + sub_ori_win.h_size;
886 main_win_st = left_isp_rect_.x + ori_win.h_offs;
887 main_win_ed = main_win_st + ori_win.h_size;
888
889 if ((sub_win_ed <= main_win_st) || (sub_win_st >= main_win_ed)) {
890 LOGW_AWB("multiwindow_0 [hoffs(%d) hsize(%d)] reset to [0 0] \n", sub_ori_win.h_offs, sub_ori_win.h_size);
891 sub_ori_win.h_offs = 0;
892 sub_ori_win.h_size = 0;
893 } else if ((sub_win_st < main_win_st) && (sub_win_ed <= main_win_ed)) {
894 LOGW_AWB("multiwindow_0 hoffs(%d) reset as same as main window offs(%d) \n", sub_ori_win.h_offs, ori_win.h_offs);
895 sub_ori_win.h_offs = left_isp_rect_.x + ori_win.h_offs;
896 } else if ((sub_win_st < main_win_st) && (sub_win_ed > main_win_ed)) {
897 LOGW_AWB("multiwindow_0 [hoffs(%d) hsize(%d)] reset as same as main window [%d %d] \n", sub_ori_win.h_offs, sub_ori_win.h_size, ori_win.h_offs, ori_win.h_size);
898 sub_ori_win.h_offs = ori_win.h_offs;
899 sub_ori_win.h_size = ori_win.h_size;
900 } else if ((sub_win_st >= main_win_st) && (sub_win_ed > main_win_ed)) {
901 LOGW_AWB("multiwindow_0 hsize(%d) reset to %d (main_win_ed %d - sub_win_st %d) \n", sub_ori_win.h_size, main_win_ed-sub_win_st, main_win_ed, sub_win_st);
902 sub_ori_win.h_size = main_win_ed-sub_win_st;
903 }
904
905 memcpy(&sub_left_win, &sub_ori_win, sizeof(sub_ori_win));
906 memcpy(&sub_right_win, &sub_ori_win, sizeof(sub_ori_win));
907
908 SplitAwbMultiWin(&sub_ori_win, &sub_left_win, &sub_right_win, &left_win, &right_win, left_isp_rect_, right_isp_rect_, &mode);
909 left->meas.rawawb.sw_rawawb_multiwindow0_h_offs = sub_left_win.h_offs;
910 left->meas.rawawb.sw_rawawb_multiwindow0_h_size = sub_left_win.h_size + sub_left_win.h_offs;
911 left->meas.rawawb.sw_rawawb_multiwindow0_v_offs = sub_left_win.v_offs;
912 left->meas.rawawb.sw_rawawb_multiwindow0_v_size = sub_left_win.v_size + sub_left_win.v_offs;
913
914 right->meas.rawawb.sw_rawawb_multiwindow0_h_offs = sub_right_win.h_offs;
915 right->meas.rawawb.sw_rawawb_multiwindow0_h_size = sub_right_win.h_size + sub_right_win.h_offs;
916 right->meas.rawawb.sw_rawawb_multiwindow0_v_offs = sub_right_win.v_offs;
917 right->meas.rawawb.sw_rawawb_multiwindow0_v_size = sub_right_win.v_size + sub_right_win.v_offs;
918
919 LOGD_AWB("Awb Multi window 0 left=%d-%d-%d-%d, right=%d-%d-%d-%d\n", sub_left_win.h_offs, sub_left_win.v_offs,
920 sub_left_win.h_size, sub_left_win.v_size, sub_right_win.h_offs, sub_right_win.v_offs,
921 sub_right_win.h_size, sub_right_win.v_size);
922
923 // Awb Multi window 1
924 sub_ori_win.h_offs = ori->meas.rawawb.sw_rawawb_multiwindow1_h_offs;
925 sub_ori_win.h_size = ori->meas.rawawb.sw_rawawb_multiwindow1_h_size - ori->meas.rawawb.sw_rawawb_multiwindow1_h_offs;
926 sub_ori_win.v_offs = ori->meas.rawawb.sw_rawawb_multiwindow1_v_offs;
927 sub_ori_win.v_size = ori->meas.rawawb.sw_rawawb_multiwindow1_v_size - ori->meas.rawawb.sw_rawawb_multiwindow1_v_offs;
928
929 sub_win_st = left_isp_rect_.x + sub_ori_win.h_offs;
930 sub_win_ed = sub_win_st + sub_ori_win.h_size;
931 main_win_st = left_isp_rect_.x + ori_win.h_offs;
932 main_win_ed = main_win_st + ori_win.h_size;
933
934 if ((sub_win_ed <= main_win_st) || (sub_win_st >= main_win_ed)) {
935 LOGW_AWB("multiwindow_1 [hoffs(%d) hsize(%d)] reset to [0 0] \n", sub_ori_win.h_offs, sub_ori_win.h_size);
936 sub_ori_win.h_offs = 0;
937 sub_ori_win.h_size = 0;
938 } else if ((sub_win_st < main_win_st) && (sub_win_ed <= main_win_ed)) {
939 LOGW_AWB("multiwindow_1 hoffs(%d) reset as same as main window offs(%d) \n", sub_ori_win.h_offs, ori_win.h_offs);
940 sub_ori_win.h_offs = left_isp_rect_.x + ori_win.h_offs;
941 } else if ((sub_win_st < main_win_st) && (sub_win_ed > main_win_ed)) {
942 LOGW_AWB("multiwindow_1 [hoffs(%d) hsize(%d)] reset as same as main window [%d %d] \n", sub_ori_win.h_offs, sub_ori_win.h_size, ori_win.h_offs, ori_win.h_size);
943 sub_ori_win.h_offs = ori_win.h_offs;
944 sub_ori_win.h_size = ori_win.h_size;
945 } else if ((sub_win_st >= main_win_st) && (sub_win_ed > main_win_ed)) {
946 LOGW_AWB("multiwindow_1 hsize(%d) reset to %d (main_win_ed %d - sub_win_st %d) \n", sub_ori_win.h_size, main_win_ed-sub_win_st, main_win_ed, sub_win_st);
947 sub_ori_win.h_size = main_win_ed-sub_win_st;
948 }
949
950
951 memcpy(&sub_left_win, &sub_ori_win, sizeof(sub_ori_win));
952 memcpy(&sub_right_win, &sub_ori_win, sizeof(sub_ori_win));
953
954 SplitAwbMultiWin(&sub_ori_win, &sub_left_win, &sub_right_win, &left_win, &right_win, left_isp_rect_, right_isp_rect_, &mode);
955 left->meas.rawawb.sw_rawawb_multiwindow1_h_offs = sub_left_win.h_offs;
956 left->meas.rawawb.sw_rawawb_multiwindow1_h_size = sub_left_win.h_size + sub_left_win.h_offs;
957 left->meas.rawawb.sw_rawawb_multiwindow1_v_offs = sub_left_win.v_offs;
958 left->meas.rawawb.sw_rawawb_multiwindow1_v_size = sub_left_win.v_size + sub_left_win.v_offs;
959
960 right->meas.rawawb.sw_rawawb_multiwindow1_h_offs = sub_right_win.h_offs;
961 right->meas.rawawb.sw_rawawb_multiwindow1_h_size = sub_right_win.h_size + sub_right_win.h_offs;
962 right->meas.rawawb.sw_rawawb_multiwindow1_v_offs = sub_right_win.v_offs;
963 right->meas.rawawb.sw_rawawb_multiwindow1_v_size = sub_right_win.v_size + sub_right_win.v_offs;
964
965 LOGD_AWB("Awb Multi window 1 left=%d-%d-%d-%d, right=%d-%d-%d-%d\n", sub_left_win.h_offs, sub_left_win.v_offs,
966 sub_left_win.h_size, sub_left_win.v_size, sub_right_win.h_offs, sub_right_win.v_offs,
967 sub_right_win.h_size, sub_right_win.v_size);
968
969 // Awb Multi window 2
970 sub_ori_win.h_offs = ori->meas.rawawb.sw_rawawb_multiwindow2_h_offs;
971 sub_ori_win.h_size = ori->meas.rawawb.sw_rawawb_multiwindow2_h_size - ori->meas.rawawb.sw_rawawb_multiwindow2_h_offs;
972 sub_ori_win.v_offs = ori->meas.rawawb.sw_rawawb_multiwindow2_v_offs;
973 sub_ori_win.v_size = ori->meas.rawawb.sw_rawawb_multiwindow2_v_size - ori->meas.rawawb.sw_rawawb_multiwindow2_v_offs;
974
975 sub_win_st = left_isp_rect_.x + sub_ori_win.h_offs;
976 sub_win_ed = sub_win_st + sub_ori_win.h_size;
977 main_win_st = left_isp_rect_.x + ori_win.h_offs;
978 main_win_ed = main_win_st + ori_win.h_size;
979
980 if ((sub_win_ed <= main_win_st) || (sub_win_st >= main_win_ed)) {
981 LOGW_AWB("multiwindow_2 [hoffs(%d) hsize(%d)] reset to [0 0] \n", sub_ori_win.h_offs, sub_ori_win.h_size);
982 sub_ori_win.h_offs = 0;
983 sub_ori_win.h_size = 0;
984 } else if ((sub_win_st < main_win_st) && (sub_win_ed <= main_win_ed)) {
985 LOGW_AWB("multiwindow_2 hoffs(%d) reset as same as main window offs(%d) \n", sub_ori_win.h_offs, ori_win.h_offs);
986 sub_ori_win.h_offs = left_isp_rect_.x + ori_win.h_offs;
987 } else if ((sub_win_st < main_win_st) && (sub_win_ed > main_win_ed)) {
988 LOGW_AWB("multiwindow_2 [hoffs(%d) hsize(%d)] reset as same as main window [%d %d] \n", sub_ori_win.h_offs, sub_ori_win.h_size, ori_win.h_offs, ori_win.h_size);
989 sub_ori_win.h_offs = ori_win.h_offs;
990 sub_ori_win.h_size = ori_win.h_size;
991 } else if ((sub_win_st >= main_win_st) && (sub_win_ed > main_win_ed)) {
992 LOGW_AWB("multiwindow_2 hsize(%d) reset to %d (main_win_ed %d - sub_win_st %d) \n", sub_ori_win.h_size, main_win_ed-sub_win_st, main_win_ed, sub_win_st);
993 sub_ori_win.h_size = main_win_ed-sub_win_st;
994 }
995
996
997 memcpy(&sub_left_win, &sub_ori_win, sizeof(sub_ori_win));
998 memcpy(&sub_right_win, &sub_ori_win, sizeof(sub_ori_win));
999
1000 SplitAwbMultiWin(&sub_ori_win, &sub_left_win, &sub_right_win, &left_win, &right_win, left_isp_rect_, right_isp_rect_, &mode);
1001 left->meas.rawawb.sw_rawawb_multiwindow2_h_offs = sub_left_win.h_offs;
1002 left->meas.rawawb.sw_rawawb_multiwindow2_h_size = sub_left_win.h_size + sub_left_win.h_offs;
1003 left->meas.rawawb.sw_rawawb_multiwindow2_v_offs = sub_left_win.v_offs;
1004 left->meas.rawawb.sw_rawawb_multiwindow2_v_size = sub_left_win.v_size + sub_left_win.v_offs;
1005
1006 right->meas.rawawb.sw_rawawb_multiwindow2_h_offs = sub_right_win.h_offs;
1007 right->meas.rawawb.sw_rawawb_multiwindow2_h_size = sub_right_win.h_size + sub_right_win.h_offs;
1008 right->meas.rawawb.sw_rawawb_multiwindow2_v_offs = sub_right_win.v_offs;
1009 right->meas.rawawb.sw_rawawb_multiwindow2_v_size = sub_right_win.v_size + sub_right_win.v_offs;
1010
1011 LOGD_AWB("Awb Multi window 2 left=%d-%d-%d-%d, right=%d-%d-%d-%d\n", sub_left_win.h_offs, sub_left_win.v_offs,
1012 sub_left_win.h_size, sub_left_win.v_size, sub_right_win.h_offs, sub_right_win.v_offs,
1013 sub_right_win.h_size, sub_right_win.v_size);
1014
1015 // Awb Multi window 3
1016 sub_ori_win.h_offs = ori->meas.rawawb.sw_rawawb_multiwindow3_h_offs;
1017 sub_ori_win.h_size = ori->meas.rawawb.sw_rawawb_multiwindow3_h_size - ori->meas.rawawb.sw_rawawb_multiwindow3_h_offs;
1018 sub_ori_win.v_offs = ori->meas.rawawb.sw_rawawb_multiwindow3_v_offs;
1019 sub_ori_win.v_size = ori->meas.rawawb.sw_rawawb_multiwindow3_v_size -ori->meas.rawawb.sw_rawawb_multiwindow3_v_offs ;
1020
1021 sub_win_st = left_isp_rect_.x + sub_ori_win.h_offs;
1022 sub_win_ed = sub_win_st + sub_ori_win.h_size;
1023 main_win_st = left_isp_rect_.x + ori_win.h_offs;
1024 main_win_ed = main_win_st + ori_win.h_size;
1025
1026 if ((sub_win_ed <= main_win_st) || (sub_win_st >= main_win_ed)) {
1027 LOGW_AWB("multiwindow_3 [hoffs(%d) hsize(%d)] reset to [0 0] \n", sub_ori_win.h_offs, sub_ori_win.h_size);
1028 sub_ori_win.h_offs = 0;
1029 sub_ori_win.h_size = 0;
1030 } else if ((sub_win_st < main_win_st) && (sub_win_ed <= main_win_ed)) {
1031 LOGW_AWB("multiwindow_3 hoffs(%d) reset as same as main window offs(%d) \n", sub_ori_win.h_offs, ori_win.h_offs);
1032 sub_ori_win.h_offs = left_isp_rect_.x + ori_win.h_offs;
1033 } else if ((sub_win_st < main_win_st) && (sub_win_ed > main_win_ed)) {
1034 LOGW_AWB("multiwindow_3 [hoffs(%d) hsize(%d)] reset as same as main window [%d %d] \n", sub_ori_win.h_offs, sub_ori_win.h_size, ori_win.h_offs, ori_win.h_size);
1035 sub_ori_win.h_offs = ori_win.h_offs;
1036 sub_ori_win.h_size = ori_win.h_size;
1037 } else if ((sub_win_st >= main_win_st) && (sub_win_ed > main_win_ed)) {
1038 LOGW_AWB("multiwindow_3 hsize(%d) reset to %d (main_win_ed %d - sub_win_st %d) \n", sub_ori_win.h_size, main_win_ed-sub_win_st, main_win_ed, sub_win_st);
1039 sub_ori_win.h_size = main_win_ed-sub_win_st;
1040 }
1041
1042
1043 memcpy(&sub_left_win, &sub_ori_win, sizeof(sub_ori_win));
1044 memcpy(&sub_right_win, &sub_ori_win, sizeof(sub_ori_win));
1045
1046 SplitAwbMultiWin(&sub_ori_win, &sub_left_win, &sub_right_win, &left_win, &right_win, left_isp_rect_, right_isp_rect_, &mode);
1047 left->meas.rawawb.sw_rawawb_multiwindow3_h_offs = sub_left_win.h_offs;
1048 left->meas.rawawb.sw_rawawb_multiwindow3_h_size = sub_left_win.h_size + sub_left_win.h_offs;
1049 left->meas.rawawb.sw_rawawb_multiwindow3_v_offs = sub_left_win.v_offs;
1050 left->meas.rawawb.sw_rawawb_multiwindow3_v_size = sub_left_win.v_size + sub_left_win.v_offs ;
1051
1052 right->meas.rawawb.sw_rawawb_multiwindow3_h_offs = sub_right_win.h_offs;
1053 right->meas.rawawb.sw_rawawb_multiwindow3_h_size = sub_right_win.h_size + sub_right_win.h_offs;
1054 right->meas.rawawb.sw_rawawb_multiwindow3_v_offs = sub_right_win.v_offs;
1055 right->meas.rawawb.sw_rawawb_multiwindow3_v_size = sub_right_win.v_size + sub_right_win.v_offs;
1056
1057 LOGD_AWB("Awb Multi window 3 left=%d-%d-%d-%d, right=%d-%d-%d-%d\n", sub_left_win.h_offs, sub_left_win.v_offs,
1058 sub_left_win.h_size, sub_left_win.v_size, sub_right_win.h_offs, sub_right_win.v_offs,
1059 sub_right_win.h_size, sub_right_win.v_size);
1060 }
1061
1062 return ret;
1063
1064 }
1065
1066 template <>
SplitAfParams(struct isp3x_isp_params_cfg * ori,struct isp3x_isp_params_cfg * left,struct isp3x_isp_params_cfg * right)1067 XCamReturn IspParamsSplitter::SplitAfParams<struct isp3x_isp_params_cfg>(
1068 struct isp3x_isp_params_cfg* ori,
1069 struct isp3x_isp_params_cfg* left,
1070 struct isp3x_isp_params_cfg* right) {
1071 struct isp3x_rawaf_meas_cfg org_af = left->meas.rawaf;
1072 struct isp3x_rawaf_meas_cfg* l_af = &left->meas.rawaf;
1073 struct isp3x_rawaf_meas_cfg* r_af = &right->meas.rawaf;
1074 struct isp2x_rawaebig_meas_cfg org_ae3 = left->meas.rawae3;
1075 struct isp2x_rawaebig_meas_cfg* l_ae3 = &left->meas.rawae3;
1076 struct isp2x_rawaebig_meas_cfg* r_ae3 = &right->meas.rawae3;
1077 int32_t l_isp_st, l_isp_ed, r_isp_st, r_isp_ed;
1078 int32_t l_win_st, l_win_ed, r_win_st, r_win_ed;
1079 int32_t x_st, x_ed, l_blknum, r_blknum, ov_w, blk_w, r_skip_blknum;
1080
1081 ov_w = left_isp_rect_.w + left_isp_rect_.x - right_isp_rect_.x;
1082 x_st = org_af.win[0].h_offs;
1083 x_ed = x_st + org_af.win[0].h_size;
1084 l_isp_st = left_isp_rect_.x;
1085 l_isp_ed = left_isp_rect_.x + left_isp_rect_.w;
1086 r_isp_st = right_isp_rect_.x;
1087 r_isp_ed = right_isp_rect_.x + right_isp_rect_.w;
1088 LOGD_AF("wina.x_st %d, wina.x_ed %d, l_isp_st %d, l_isp_ed %d, r_isp_st %d, r_isp_ed %d",
1089 x_st, x_ed, l_isp_st, l_isp_ed, r_isp_st, r_isp_ed);
1090
1091 //// winA ////
1092 // af win in both side
1093 if ((x_st < r_isp_st) && (x_ed > l_isp_ed)) {
1094 // af win < one isp width
1095 if (org_af.win[0].h_size < left_isp_rect_.w) {
1096 blk_w = org_af.win[0].h_size / ISP2X_RAWAF_SUMDATA_ROW;
1097 l_blknum = (l_isp_ed - x_st + blk_w - 1) / blk_w;
1098 r_blknum = ISP2X_RAWAF_SUMDATA_ROW - l_blknum;
1099 l_win_ed = l_isp_ed - 2;
1100 l_win_st = l_win_ed - blk_w * ISP2X_RAWAF_SUMDATA_ROW;
1101 if (blk_w < ov_w) {
1102 r_skip_blknum = ov_w / blk_w;
1103 r_win_st = ov_w - r_skip_blknum * blk_w;
1104 r_win_ed = ov_w + (ISP2X_RAWAF_SUMDATA_ROW - r_skip_blknum) * blk_w;
1105 }
1106 else {
1107 r_skip_blknum = 0;
1108 r_win_st = 2;
1109 r_win_ed = r_win_st + ISP2X_RAWAF_SUMDATA_ROW * blk_w;
1110 }
1111 }
1112 // af win < one isp width * 1.5
1113 else if (org_af.win[0].h_size < left_isp_rect_.w * 3/2) {
1114 l_win_st = x_st;
1115 l_win_ed = l_isp_ed - 2;
1116 blk_w = (l_win_ed - l_win_st) / (ISP2X_RAWAF_SUMDATA_ROW + 1);
1117 l_win_st = l_win_ed - blk_w * ISP2X_RAWAF_SUMDATA_ROW;
1118 l_blknum = ((l_win_ed - l_win_st) * ISP2X_RAWAF_SUMDATA_ROW + org_af.win[0].h_size - 1) / org_af.win[0].h_size;
1119 r_blknum = ISP2X_RAWAF_SUMDATA_ROW - l_blknum;
1120 if (blk_w < ov_w) {
1121 r_skip_blknum = ov_w / blk_w;
1122 r_win_st = ov_w - r_skip_blknum * blk_w;
1123 r_win_ed = ov_w + (ISP2X_RAWAF_SUMDATA_ROW - r_skip_blknum) * blk_w;
1124 }
1125 else {
1126 r_skip_blknum = 0;
1127 r_win_st = 2;
1128 r_win_ed = r_win_st + ISP2X_RAWAF_SUMDATA_ROW * blk_w;
1129 }
1130 } else {
1131 l_win_st = x_st;
1132 l_win_ed = l_isp_ed - 2;
1133 blk_w = (l_win_ed - l_win_st) / ISP2X_RAWAF_SUMDATA_ROW;
1134 l_win_st = l_win_ed - blk_w * ISP2X_RAWAF_SUMDATA_ROW;
1135 r_win_st = 2;
1136 r_win_ed = r_win_st + blk_w * ISP2X_RAWAF_SUMDATA_ROW;
1137 l_blknum = ISP2X_RAWAF_SUMDATA_ROW;
1138 r_blknum = ISP2X_RAWAF_SUMDATA_ROW;
1139 r_skip_blknum = 0;
1140 }
1141 LOGD_AF("wina: blk_w %d, ov_w %d, l_blknum %d, r_blknum %d, r_skip_blknum %d",
1142 blk_w, ov_w, l_blknum, r_blknum, r_skip_blknum);
1143 }
1144 // af win in right side
1145 else if ((x_st >= r_isp_st) && (x_ed > l_isp_ed)) {
1146 l_blknum = 0;
1147 r_blknum = ISP2X_RAWAF_SUMDATA_ROW;
1148 r_win_st = x_st - right_isp_rect_.x;
1149 r_win_ed = x_ed - right_isp_rect_.x;
1150 l_win_st = r_win_st;
1151 l_win_ed = r_win_ed;
1152 }
1153 // af win in left side
1154 else {
1155 l_blknum = ISP2X_RAWAF_SUMDATA_ROW;
1156 r_blknum = 0;
1157 l_win_st = x_st;
1158 l_win_ed = x_ed;
1159 r_win_st = l_win_st;
1160 r_win_ed = l_win_ed;
1161 }
1162
1163 l_af->win[0].h_offs = l_win_st;
1164 l_af->win[0].h_size = l_win_ed - l_win_st;
1165 r_af->win[0].h_offs = r_win_st;
1166 r_af->win[0].h_size = r_win_ed - r_win_st;
1167
1168 //// winB ////
1169 x_st = org_af.win[1].h_offs;
1170 x_ed = x_st + org_af.win[1].h_size;
1171 LOGD_AF("winb.x_st %d, winb.x_ed %d, l_isp_st %d, l_isp_ed %d, r_isp_st %d, r_isp_ed %d",
1172 x_st, x_ed, l_isp_st, l_isp_ed, r_isp_st, r_isp_ed);
1173
1174 // af win in both side
1175 if ((x_st < r_isp_st) && (x_ed > l_isp_ed)) {
1176 l_win_st = x_st;
1177 l_win_ed = l_isp_ed - 2;
1178 r_win_st = ov_w - 2;
1179 r_win_ed = x_ed - right_isp_rect_.x;
1180 }
1181 // af win in right side
1182 else if ((x_st >= r_isp_st) && (x_ed > l_isp_ed)) {
1183 r_win_st = x_st - right_isp_rect_.x;
1184 r_win_ed = x_ed - right_isp_rect_.x;
1185 l_win_st = r_win_st;
1186 l_win_ed = r_win_ed;
1187 }
1188 // af win in left side
1189 else {
1190 l_win_st = x_st;
1191 l_win_ed = x_ed;
1192 r_win_st = l_win_st;
1193 r_win_ed = l_win_ed;
1194 }
1195
1196 l_af->win[1].h_offs = l_win_st;
1197 l_af->win[1].h_size = l_win_ed - l_win_st;
1198 r_af->win[1].h_offs = r_win_st;
1199 r_af->win[1].h_size = r_win_ed - r_win_st;
1200
1201 // rawae3 is used by af now!!!
1202 if (org_af.ae_mode) {
1203 l_ae3->win.h_offs = l_af->win[0].h_offs;
1204 l_ae3->win.v_offs = l_af->win[0].v_offs;
1205 l_ae3->win.h_size = l_af->win[0].h_size;
1206 l_ae3->win.v_size = l_af->win[0].v_size;
1207 r_ae3->win.h_offs = r_af->win[0].h_offs;
1208 r_ae3->win.v_offs = r_af->win[0].v_offs;
1209 r_ae3->win.h_size = r_af->win[0].h_size;
1210 r_ae3->win.v_size = r_af->win[0].v_size;
1211 }
1212
1213 LOGD_AF("AfWinA left=%d-%d-%d-%d, right=%d-%d-%d-%d",
1214 l_af->win[0].h_offs, l_af->win[0].v_offs,
1215 l_af->win[0].h_size, l_af->win[0].v_size,
1216 r_af->win[0].h_offs, r_af->win[0].v_offs,
1217 r_af->win[0].h_size, r_af->win[0].v_size);
1218
1219 LOGD_AF("AfWinB left=%d-%d-%d-%d, right=%d-%d-%d-%d",
1220 l_af->win[1].h_offs, l_af->win[1].v_offs,
1221 l_af->win[1].h_size, l_af->win[1].v_size,
1222 r_af->win[1].h_offs, r_af->win[1].v_offs,
1223 r_af->win[1].h_size, r_af->win[1].v_size);
1224
1225 return XCAM_RETURN_NO_ERROR;
1226 }
1227
AlscMatrixScale(unsigned short ori_matrix[],unsigned short left_matrix[],unsigned short right_matrix[],int cols,int rows)1228 int AlscMatrixScale(unsigned short ori_matrix[], unsigned short left_matrix[],
1229 unsigned short right_matrix[], int cols, int rows) {
1230 int ori_col_index = 0;
1231 int lef_dst_index = 0;
1232 int rht_dst_index = 0;
1233 int mid_col = cols / 2;
1234 int row_index = 0;
1235
1236 for (row_index = 0; row_index < rows; row_index++) {
1237 for (ori_col_index = 0; ori_col_index < cols;ori_col_index++) {
1238 if (ori_col_index < mid_col) {
1239 left_matrix[lef_dst_index++] =
1240 ori_matrix[row_index * cols + ori_col_index];
1241 left_matrix[lef_dst_index++] =
1242 (ori_matrix[row_index * cols + ori_col_index] +
1243 ori_matrix[row_index * cols + ori_col_index + 1]) / 2;
1244 } else if (ori_col_index == mid_col) {
1245 left_matrix[lef_dst_index++] =
1246 ori_matrix[row_index * cols + ori_col_index];
1247 right_matrix[rht_dst_index++] =
1248 ori_matrix[row_index * cols + ori_col_index];
1249 } else {
1250 right_matrix[rht_dst_index++] =
1251 (ori_matrix[row_index * cols + ori_col_index] +
1252 ori_matrix[row_index * cols + ori_col_index - 1]) / 2;
1253 right_matrix[rht_dst_index++] =
1254 ori_matrix[row_index * cols + ori_col_index];
1255 }
1256 }
1257 }
1258
1259 return 0;
1260 }
1261
AlscMatrixSplit(const unsigned short * ori_matrix,int cols,int rows,unsigned short left[],unsigned short right[])1262 int AlscMatrixSplit(const unsigned short* ori_matrix, int cols, int rows, unsigned short left[],
1263 unsigned short right[]) {
1264 int out_cols = cols / 2 + cols % 2;
1265 int out_rows = rows;
1266 int left_start_addr = 0;
1267 int right_start_addr = cols - out_cols;
1268 unsigned short* left_index = left;
1269 unsigned short* right_index = right;
1270
1271 while (out_rows--) {
1272 memcpy(left_index, ori_matrix + left_start_addr, out_cols * sizeof(unsigned short));
1273 memcpy(right_index, ori_matrix + right_start_addr, out_cols * sizeof(unsigned short));
1274 left_index += out_cols;
1275 right_index += out_cols;
1276 left_start_addr += cols;
1277 right_start_addr += cols;
1278 }
1279
1280 return 0;
1281 }
1282
SplitAlscXtable(const unsigned short * in_array,int in_size,int ori_imgw,unsigned short * dst_left,unsigned short * dst_right,int left_w,int right_w)1283 int SplitAlscXtable(const unsigned short* in_array, int in_size, int ori_imgw,
1284 unsigned short* dst_left, unsigned short* dst_right,
1285 int left_w, int right_w) {
1286 int in_index = 0;
1287 int left_index = 0;
1288 int right_index = 0;
1289 for (in_index = 0; in_index < in_size; in_index++) {
1290 if (in_index < (in_size / 2)) {
1291 dst_left[left_index++] =
1292 ceil(in_array[in_index] * 1.0 / ori_imgw * left_w);
1293 dst_left[left_index++] =
1294 floor(in_array[in_index] * 1.0 / ori_imgw * left_w);
1295 } else {
1296 dst_right[right_index++] =
1297 ceil(in_array[in_index] * 1.0 / ori_imgw * right_w);
1298 dst_right[right_index++] =
1299 floor(in_array[in_index] * 1.0 / ori_imgw * right_w);
1300 }
1301 }
1302
1303 return 0;
1304 }
1305
lscGradUpdate(unsigned short xgrad_tbl[],unsigned short ygrad_tbl[],unsigned short x_sect_tbl[],unsigned short y_sect_tbl[],int x_sect_size,int y_sect_size)1306 int lscGradUpdate(unsigned short xgrad_tbl[],
1307 unsigned short ygrad_tbl[],
1308 unsigned short x_sect_tbl[],
1309 unsigned short y_sect_tbl[],
1310 int x_sect_size,
1311 int y_sect_size) {
1312 uint32_t x_size = x_sect_size;
1313 uint32_t y_size = y_sect_size;
1314
1315 for (uint32_t i = 0; i < x_size; i++) {
1316 if (0 < x_sect_tbl[i]) {
1317 xgrad_tbl[i] = (uint16_t)((double)(1UL << 15) / x_sect_tbl[i] + 0.5);
1318 } else {
1319 return XCAM_RETURN_ERROR_PARAM;
1320 }
1321 }
1322 for (uint32_t i = 0; i < y_size; i++) {
1323 if (0 < y_sect_tbl[i]) {
1324 ygrad_tbl[i] = (uint16_t)((double)(1UL << 15) / y_sect_tbl[i] + 0.5);
1325 } else {
1326 return XCAM_RETURN_ERROR_PARAM;
1327 }
1328 }
1329
1330 return XCAM_RETURN_NO_ERROR;
1331 }
1332
1333 template <>
SplitAlscParams(struct isp3x_isp_params_cfg * ori,struct isp3x_isp_params_cfg * left,struct isp3x_isp_params_cfg * right)1334 XCamReturn IspParamsSplitter::SplitAlscParams<struct isp3x_isp_params_cfg>(
1335 struct isp3x_isp_params_cfg* ori, struct isp3x_isp_params_cfg* left,
1336 struct isp3x_isp_params_cfg* right) {
1337 struct isp3x_lsc_cfg* lsc_cfg_ori = &ori->others.lsc_cfg;
1338 struct isp3x_lsc_cfg* lsc_cfg_lef = &left->others.lsc_cfg;
1339 struct isp3x_lsc_cfg* lsc_cfg_rht = &right->others.lsc_cfg;
1340
1341 memcpy(lsc_cfg_lef->y_size_tbl, lsc_cfg_ori->y_size_tbl,
1342 sizeof(lsc_cfg_ori->y_size_tbl));
1343 memcpy(lsc_cfg_rht->y_size_tbl, lsc_cfg_ori->y_size_tbl,
1344 sizeof(lsc_cfg_ori->y_size_tbl));
1345
1346 SplitAlscXtable(lsc_cfg_ori->x_size_tbl, ISP3X_LSC_SIZE_TBL_SIZE,
1347 pic_rect_.w,
1348 lsc_cfg_lef->x_size_tbl,
1349 lsc_cfg_rht->x_size_tbl,
1350 left_isp_rect_.w,
1351 right_isp_rect_.w);
1352
1353 AlscMatrixScale(lsc_cfg_ori->r_data_tbl,
1354 lsc_cfg_lef->r_data_tbl,
1355 lsc_cfg_rht->r_data_tbl,
1356 ISP3X_LSC_SIZE_TBL_SIZE + 1,
1357 ISP3X_LSC_SIZE_TBL_SIZE + 1);
1358 AlscMatrixScale(lsc_cfg_ori->gr_data_tbl,
1359 lsc_cfg_lef->gr_data_tbl,
1360 lsc_cfg_rht->gr_data_tbl,
1361 ISP3X_LSC_SIZE_TBL_SIZE + 1,
1362 ISP3X_LSC_SIZE_TBL_SIZE + 1);
1363 AlscMatrixScale(lsc_cfg_ori->gb_data_tbl,
1364 lsc_cfg_lef->gb_data_tbl,
1365 lsc_cfg_rht->gb_data_tbl,
1366 ISP3X_LSC_SIZE_TBL_SIZE + 1,
1367 ISP3X_LSC_SIZE_TBL_SIZE + 1);
1368 AlscMatrixScale(lsc_cfg_ori->b_data_tbl,
1369 lsc_cfg_lef->b_data_tbl,
1370 lsc_cfg_rht->b_data_tbl,
1371 ISP3X_LSC_SIZE_TBL_SIZE + 1,
1372 ISP3X_LSC_SIZE_TBL_SIZE + 1);
1373
1374 lscGradUpdate(lsc_cfg_lef->x_grad_tbl, lsc_cfg_lef->y_grad_tbl,
1375 lsc_cfg_lef->x_size_tbl, lsc_cfg_lef->y_size_tbl,
1376 ISP3X_LSC_GRAD_TBL_SIZE, ISP3X_LSC_GRAD_TBL_SIZE);
1377
1378 lscGradUpdate(lsc_cfg_rht->x_grad_tbl, lsc_cfg_rht->y_grad_tbl,
1379 lsc_cfg_rht->x_size_tbl, lsc_cfg_rht->y_size_tbl,
1380 ISP3X_LSC_GRAD_TBL_SIZE, ISP3X_LSC_GRAD_TBL_SIZE);
1381
1382 return XCAM_RETURN_NO_ERROR;
1383 }
1384
SetPicInfo(IspParamsSplitter::Rectangle && pic_rect)1385 IspParamsSplitter& IspParamsSplitter::SetPicInfo(IspParamsSplitter::Rectangle&& pic_rect) {
1386 pic_rect_ = std::move(pic_rect);
1387 return *this;
1388 }
1389
SetPicInfo(IspParamsSplitter::Rectangle & pic_rect)1390 IspParamsSplitter& IspParamsSplitter::SetPicInfo(IspParamsSplitter::Rectangle& pic_rect) {
1391 pic_rect_ = pic_rect;
1392 return *this;
1393 }
1394
SetLeftIspRect(IspParamsSplitter::Rectangle && left_isp_rect)1395 IspParamsSplitter& IspParamsSplitter::SetLeftIspRect(IspParamsSplitter::Rectangle&& left_isp_rect) {
1396 left_isp_rect_ = std::move(left_isp_rect);
1397 return *this;
1398 }
1399
SetLeftIspRect(IspParamsSplitter::Rectangle & left_isp_rect)1400 IspParamsSplitter& IspParamsSplitter::SetLeftIspRect(IspParamsSplitter::Rectangle& left_isp_rect) {
1401 left_isp_rect_ = left_isp_rect;
1402 return *this;
1403 }
1404
SetRightIspRect(IspParamsSplitter::Rectangle && right_isp_rect)1405 IspParamsSplitter& IspParamsSplitter::SetRightIspRect(
1406 IspParamsSplitter::Rectangle&& right_isp_rect) {
1407 right_isp_rect_ = std::move(right_isp_rect);
1408 return *this;
1409 }
1410
SetRightIspRect(IspParamsSplitter::Rectangle & right_isp_rect)1411 IspParamsSplitter& IspParamsSplitter::SetRightIspRect(
1412 IspParamsSplitter::Rectangle& right_isp_rect) {
1413 right_isp_rect_ = right_isp_rect;
1414 return *this;
1415 }
1416
GetPicInfo() const1417 const IspParamsSplitter::Rectangle& IspParamsSplitter::GetPicInfo() const {
1418 return pic_rect_;
1419 }
1420
GetLeftIspRect() const1421 const IspParamsSplitter::Rectangle& IspParamsSplitter::GetLeftIspRect() const {
1422 return left_isp_rect_;
1423 }
1424
GetRightIspRect() const1425 const IspParamsSplitter::Rectangle& IspParamsSplitter::GetRightIspRect() const {
1426 return right_isp_rect_;
1427 }
1428
1429 template <>
SplitIspParams(struct isp3x_isp_params_cfg * orig_isp_params,struct isp3x_isp_params_cfg * isp_params)1430 XCamReturn IspParamsSplitter::SplitIspParams<struct isp3x_isp_params_cfg>(
1431 struct isp3x_isp_params_cfg* orig_isp_params,
1432 struct isp3x_isp_params_cfg* isp_params) {
1433 XCamReturn ret = XCAM_RETURN_NO_ERROR;
1434
1435 struct isp3x_isp_params_cfg* left_isp_params = isp_params;
1436 struct isp3x_isp_params_cfg* right_isp_params = isp_params + 1;
1437
1438 // Modules that use the same params for both left and right isp
1439 // will not need to implent split function
1440 memcpy(right_isp_params, left_isp_params, sizeof(struct isp3x_isp_params_cfg));
1441
1442 ret = SplitAecParams(orig_isp_params, left_isp_params, right_isp_params);
1443 // Should return failure ?
1444 ret = SplitAwbParams(orig_isp_params, left_isp_params, right_isp_params);
1445 ret = SplitAfParams(orig_isp_params, left_isp_params, right_isp_params);
1446 ret = SplitAlscParams(orig_isp_params, left_isp_params, right_isp_params);
1447
1448 LOGD_CAMHW("Split ISP Params: left %p right %p size %d",
1449 left_isp_params,
1450 right_isp_params,
1451 sizeof(*left_isp_params));
1452
1453 return ret;
1454 }
1455