add kernel/.gitignore

hc

2024-08-16 a24a44ff9ca902811b99aa9663d697cf452e08ef

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include "rk_aiq_uapi_ablc_int.h"
#include "ablc/rk_aiq_types_ablc_algo_prvt.h"
 
 
void BlcParamsNewMalloc
(
    AblcParams_t*           pStoreBlcPara,
    AblcParams_t*           pInputBlcPara
) {
    LOGD_ABLC( "%s:enter!\n", __FUNCTION__);
 
    // initial checks
    DCT_ASSERT(pStoreBlcPara != NULL);
    DCT_ASSERT(pInputBlcPara != NULL);
 
    if(pStoreBlcPara->len != pInputBlcPara->len) {
        LOGD_ABLC( "%s:enter store_Len:%d! inputLen:%d\n", __FUNCTION__,
                   pStoreBlcPara->len,
                   pInputBlcPara->len);
        if(pStoreBlcPara->iso)
            free(pStoreBlcPara->iso);
 
        if(pStoreBlcPara->blc_b)
            free(pStoreBlcPara->blc_b);
 
        if(pStoreBlcPara->blc_gb)
            free(pStoreBlcPara->blc_gb);
 
        if(pStoreBlcPara->blc_gr)
            free(pStoreBlcPara->blc_gr);
 
        if(pStoreBlcPara->blc_r)
            free(pStoreBlcPara->blc_r);
 
        pStoreBlcPara->len = pInputBlcPara->len;
        pStoreBlcPara->iso = (float*)malloc(sizeof(float) * (pInputBlcPara->len));
        pStoreBlcPara->blc_r = (float*)malloc(sizeof(float) * (pInputBlcPara->len));
        pStoreBlcPara->blc_gr = (float*)malloc(sizeof(float) * (pInputBlcPara->len));
        pStoreBlcPara->blc_gb = (float*)malloc(sizeof(float) * (pInputBlcPara->len));
        pStoreBlcPara->blc_b = (float*)malloc(sizeof(float) * (pInputBlcPara->len));
 
    }
 
    pStoreBlcPara->enable = pInputBlcPara->enable;
    for(int i = 0; i < pInputBlcPara->len; i++) {
        pStoreBlcPara->iso[i] = pInputBlcPara->iso[i];
        pStoreBlcPara->blc_r[i] = pInputBlcPara->blc_r[i];
        pStoreBlcPara->blc_gr[i] = pInputBlcPara->blc_gr[i];
        pStoreBlcPara->blc_gb[i] = pInputBlcPara->blc_gb[i];
        pStoreBlcPara->blc_b[i] = pInputBlcPara->blc_b[i];
 
        LOGD_ABLC("ablc iso:%f blc:%f %f %f %f\n",
                  pStoreBlcPara->iso[i],
                  pStoreBlcPara->blc_r[i],
                  pStoreBlcPara->blc_gr[i],
                  pStoreBlcPara->blc_gb[i],
                  pStoreBlcPara->blc_b[i]);
    }
 
    LOGD_ABLC( "%s:exit!\n", __FUNCTION__);
}
 
 
XCamReturn
rk_aiq_uapi_ablc_SetAttrib(RkAiqAlgoContext *ctx,
                           rk_aiq_blc_attrib_t *attr,
                           bool need_sync)
{
    AblcContext_t* pAblcCtx = (AblcContext_t*)ctx;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
    pAblcCtx->eMode = attr->eMode;
    if(attr->eMode == ABLC_OP_MODE_MANUAL) {
        pAblcCtx->stBlc0Manual = attr->stBlc0Manual;
        pAblcCtx->stBlc1Manual = attr->stBlc1Manual;
    } else if(attr->eMode == ABLC_OP_MODE_AUTO) {
        BlcParamsNewMalloc(&pAblcCtx->stBlc0Params, &attr->stBlc0Auto);
        BlcParamsNewMalloc(&pAblcCtx->stBlc1Params, &attr->stBlc1Auto);
    }
 
 
    pAblcCtx->isReCalculate |= 1;
    return ret;
}
 
XCamReturn
rk_aiq_uapi_ablc_GetAttrib(const RkAiqAlgoContext *ctx,
                           rk_aiq_blc_attrib_t *attr)
{
 
    AblcContext_t* pAblcCtx = (AblcContext_t*)ctx;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
 
    attr->eMode = pAblcCtx->eMode;
    memcpy(&attr->stBlc0Manual, &pAblcCtx->stBlc0Manual, sizeof(attr->stBlc0Manual));
    memcpy(&attr->stBlc1Manual, &pAblcCtx->stBlc1Manual, sizeof(attr->stBlc1Manual));
 
    BlcParamsNewMalloc(&attr->stBlc0Auto, &pAblcCtx->stBlc0Params);
    BlcParamsNewMalloc(&attr->stBlc1Auto, &pAblcCtx->stBlc1Params);
    return ret;
}
 
 
XCamReturn
rk_aiq_uapi_ablc_GetProc(const RkAiqAlgoContext *ctx,
                         AblcProc_t *ProcRes)
{
    AblcContext_t* pAblcCtx = (AblcContext_t*)ctx;
    XCamReturn ret = XCAM_RETURN_NO_ERROR;
 
    *ProcRes = pAblcCtx->ProcRes;
    return ret;
}