/*
|
* Copyright (c) 2019 Rockchip Corporation
|
*
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
*/
|
|
#include "sample_comm.h"
|
|
static void sample_a3dlut_usage()
|
{
|
printf("Usage : \n");
|
printf(" ImgProc API: \n");
|
printf("\t 0) 3DLUT: Set 3DLUT MANUAL Mode.\n");
|
printf("\t 1) 3DLUT: Set 3DLUT AUTO Mode.\n");
|
printf("\t 2) 3DLUT: Get 3DLUT Mode.\n");
|
printf("\t 3) 3DLUT: Set 3DLUT Manual Lut.\n");
|
printf("\t 4) 3DLUT: Get 3DLUT Lut.\n");
|
printf("\t 5) 3DLUT: Get A3DLUT Strength.\n");
|
printf("\t 6) 3DLUT: Get A3DLUT LutName.\n");
|
printf(" Module API: \n");
|
printf("\t a) 3DLUT: Set 3dlut Attr & Sync .\n");
|
printf("\t b) 3DLUT: Set 3dlut Attr & Async .\n");
|
printf("\t c) 3DLUT: Set Mode Manual & Sync.\n");
|
printf("\t d) 3DLUT: Set Mode Manual & Async.\n");
|
printf("\t e) 3DLUT: Set Mode Auto & Sync.\n");
|
printf("\t f) 3DLUT: Set Mode Auto & Async.\n");
|
printf("\t g) 3DLUT: Set Manual attr & Sync.\n");
|
printf("\t i) 3DLUT: Set Manual attr & Async.\n");
|
printf("\t j) 3DLUT: Query A3DLUT Info.\n");
|
printf("\n");
|
printf("\t h) 3DLUT: help.\n");
|
printf("\t q) 3DLUT: return to main sample screen.\n");
|
|
printf("\n");
|
printf("\t please press the key: ");
|
|
return;
|
}
|
|
void sample_print_a3dlut_info(const void *arg)
|
{
|
printf ("enter 3DLUT modult test!\n");
|
}
|
|
/*
|
******************************
|
*
|
* ImgProc level API Sample Func
|
*
|
******************************
|
*/
|
|
static int sample_set_a3dlut_manual(const rk_aiq_sys_ctx_t* ctx)
|
{
|
opMode_t mode = OP_MANUAL;
|
rk_aiq_uapi2_setLut3dMode(ctx, mode);
|
return 0;
|
}
|
|
static int sample_set_a3dlut_auto(const rk_aiq_sys_ctx_t* ctx)
|
{
|
opMode_t mode = OP_AUTO;
|
rk_aiq_uapi2_setLut3dMode(ctx, mode);
|
return 0;
|
}
|
|
static int sample_get_a3dlut_mode(const rk_aiq_sys_ctx_t* ctx)
|
{
|
opMode_t mode;
|
rk_aiq_uapi2_getLut3dMode(ctx, &mode);
|
if (mode == OP_MANUAL)
|
printf("Get 3DLUT Mode is: Manual \n");
|
else if (mode == OP_AUTO)
|
printf("Get 3DLUT Mode is: AUTO\n");
|
else
|
printf("Get 3DLUT Mode is: INVALID\n");
|
return 0;
|
}
|
|
static int sample_set_a3dlut_manual_lut(const rk_aiq_sys_ctx_t* ctx)
|
{
|
rk_aiq_lut3d_table_t mlut;
|
memset(&mlut, 0, sizeof(mlut));
|
// create mlut
|
rk_aiq_uapi2_getM3dLut(ctx, &mlut);
|
memcpy(mlut.look_up_table_b, mlut.look_up_table_r, sizeof(unsigned short) * 729);
|
for(int i = 0; i < 729; i++)
|
mlut.look_up_table_g[i] = mlut.look_up_table_r[i]<<2;
|
// set mlut
|
rk_aiq_uapi2_setM3dLut(ctx, &mlut);
|
printf("Set 3DLUT Manual Lut\n\n");
|
return 0;
|
}
|
|
static int sample_get_a3dlut_lut(const rk_aiq_sys_ctx_t* ctx)
|
{
|
rk_aiq_lut3d_table_t mlut;
|
rk_aiq_uapi2_getM3dLut(ctx, &mlut);
|
printf("Get 3DLUT Lut: ");
|
printf("\t r: %d, %d, %d \n", mlut.look_up_table_r[0],
|
mlut.look_up_table_r[1],
|
mlut.look_up_table_r[2]);
|
printf("\t g: %d, %d, %d \n", mlut.look_up_table_g[0],
|
mlut.look_up_table_g[1],
|
mlut.look_up_table_g[2]);
|
printf("\t b: %d, %d, %d \n", mlut.look_up_table_b[0],
|
mlut.look_up_table_b[1],
|
mlut.look_up_table_b[2]);
|
return 0;
|
}
|
|
static int sample_get_a3dlut_strength(const rk_aiq_sys_ctx_t* ctx)
|
{
|
float alpha;
|
rk_aiq_uapi2_getA3dLutStrth(ctx, &alpha);
|
printf("Get A3DLUT Strength: %f\n\n", alpha);
|
return 0;
|
}
|
|
static int sample_get_a3dlut_lutname(const rk_aiq_sys_ctx_t* ctx)
|
{
|
char lutname[25];
|
rk_aiq_uapi2_getA3dLutName(ctx, lutname);
|
printf("Get A3DLUT LutName: %s\n\n", lutname);
|
return 0;
|
}
|
|
/*
|
******************************
|
*
|
* Module level API Sample Func
|
*
|
******************************
|
*/
|
|
static int sample_3dlut_set3dlutAttr(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
rk_aiq_lut3d_attrib_t attr;
|
memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
|
//get
|
ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "set3dlutAttr failed in getting a3dlut attrib!");
|
//modify
|
attr.sync.sync_mode = sync;
|
if (attr.mode > 1 ) {
|
attr.mode = RK_AIQ_LUT3D_MODE_MANUAL;
|
memset(attr.stManual.look_up_table_g, 0, 729*sizeof(unsigned short));
|
} else {
|
attr.mode = RK_AIQ_LUT3D_MODE_AUTO;
|
}
|
//set
|
ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "set 3DLUT Attr failed!");
|
printf("set 3DLUT Attr\n\n");
|
|
return 0;
|
}
|
|
static int sample_3dlut_get3dlutAttr(const rk_aiq_sys_ctx_t* ctx)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
rk_aiq_lut3d_attrib_t attr;
|
memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
|
//get
|
ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "get 3dlut Attr failed!");
|
printf("get 3DLUT Attr:\n\n");
|
printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
|
printf("\t enable = %s\n", (attr.byPass ? "false" : "true"));
|
if (attr.mode == RK_AIQ_LUT3D_MODE_MANUAL){
|
printf("\t mode = Manual\n");
|
printf("\t manual lut");
|
printf("\t\t r: %d, %d, %d \n", attr.stManual.look_up_table_r[0],
|
attr.stManual.look_up_table_r[1],
|
attr.stManual.look_up_table_r[2]);
|
printf("\t\t g: %d, %d, %d \n", attr.stManual.look_up_table_g[0],
|
attr.stManual.look_up_table_g[1],
|
attr.stManual.look_up_table_g[2]);
|
printf("\t\t b: %d, %d, %d \n", attr.stManual.look_up_table_b[0],
|
attr.stManual.look_up_table_b[1],
|
attr.stManual.look_up_table_b[2]);
|
} else if (attr.mode == RK_AIQ_LUT3D_MODE_AUTO){
|
printf("\t mode = Auto\n");
|
} else {
|
printf("\t mode is invalid!");
|
}
|
return 0;
|
}
|
|
static int sample_3dlut_setModeManual(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
rk_aiq_lut3d_attrib_t attr;
|
memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
|
//get
|
ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "setModeManual failed in getting a3dlut attrib!");
|
//modify
|
attr.sync.sync_mode = sync;
|
attr.mode = RK_AIQ_LUT3D_MODE_MANUAL;
|
//set
|
ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Manual failed!");
|
printf("set 3DLUT Mode Manual\n\n");
|
|
return 0;
|
}
|
|
static int sample_3dlut_setModeAuto(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
rk_aiq_lut3d_attrib_t attr;
|
memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
|
//get
|
ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "setModeAuto failed in getting a3dlut attrib!");
|
//modify
|
attr.sync.sync_mode = sync;
|
attr.mode = RK_AIQ_LUT3D_MODE_AUTO;
|
//set
|
ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "set Mode Auto failed!");
|
printf("set 3DLUT Mode Auto\n\n");
|
|
return 0;
|
}
|
|
static int sample_3dlut_getMode(const rk_aiq_sys_ctx_t* ctx)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
rk_aiq_lut3d_attrib_t attr;
|
memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
|
//get
|
ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "get 3dlut Mode failed!");
|
printf("get 3DLUT Mode:\n\n");
|
printf("\t sync = %d, done = %d\n", attr.sync.sync_mode, attr.sync.done);
|
if (attr.mode == RK_AIQ_LUT3D_MODE_MANUAL){
|
printf("\t mode = Manual\n");
|
} else if (attr.mode == RK_AIQ_LUT3D_MODE_AUTO){
|
printf("\t mode = Auto\n");
|
} else {
|
printf("\t mode is invalid!");
|
}
|
return 0;
|
}
|
|
static int sample_3dlut_setM3dlut(const rk_aiq_sys_ctx_t* ctx, rk_aiq_uapi_mode_sync_e sync)
|
{
|
XCamReturn ret = XCAM_RETURN_NO_ERROR;
|
rk_aiq_lut3d_attrib_t attr;
|
memset(&attr,0,sizeof(rk_aiq_lut3d_attrib_t));
|
//get
|
ret = rk_aiq_user_api2_a3dlut_GetAttrib(ctx, &attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "setM3dlut failed in getting a3dlut attrib!");
|
//modify
|
attr.sync.sync_mode = sync;
|
attr.mode = RK_AIQ_LUT3D_MODE_MANUAL;
|
if (attr.stManual.look_up_table_g[2] > 0) {
|
memset(attr.stManual.look_up_table_g, 0, 729*sizeof(unsigned short));
|
} else {
|
memcpy(attr.stManual.look_up_table_g, attr.stManual.look_up_table_r, \
|
sizeof(attr.stManual.look_up_table_r));
|
}
|
|
//set
|
ret = rk_aiq_user_api2_a3dlut_SetAttrib(ctx, attr);
|
RKAIQ_SAMPLE_CHECK_RET(ret, "set Manual attr failed!");
|
printf("set Manual attr\n\n");
|
|
return 0;
|
}
|
|
|
static int sample_query_a3dlut_info(const rk_aiq_sys_ctx_t* ctx)
|
{
|
rk_aiq_lut3d_querry_info_t info;
|
rk_aiq_user_api2_a3dlut_Query3dlutInfo(ctx, &info);
|
printf("Query 3DLUT Info:\n\n");
|
printf("\t enable: %s, \n", (info.lut3d_en ? "true" : "false"));
|
printf("\t lut: ");
|
printf("\t\t r: %d, %d, %d \n", info.look_up_table_r[0],
|
info.look_up_table_r[1],
|
info.look_up_table_r[2]);
|
printf("\t\t g: %d, %d, %d \n", info.look_up_table_g[0],
|
info.look_up_table_g[1],
|
info.look_up_table_g[2]);
|
printf("\t\t b: %d, %d, %d \n", info.look_up_table_b[0],
|
info.look_up_table_b[1],
|
info.look_up_table_b[2]);
|
printf("\t alpha: %f \n", info.alpha);
|
printf("\t lutname: %s \n", info.name);
|
return 0;
|
}
|
|
XCamReturn sample_a3dlut_module(const void *arg)
|
{
|
int key = -1;
|
CLEAR();
|
|
const demo_context_t *demo_ctx = (demo_context_t *)arg;
|
const rk_aiq_sys_ctx_t* ctx;
|
if (demo_ctx->camGroup){
|
ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->camgroup_ctx);
|
} else {
|
ctx = (rk_aiq_sys_ctx_t*)(demo_ctx->aiq_ctx);
|
}
|
|
/*TODO: when rkaiq_3A_server & rkisp_demo run in two different shell, rk_aiq_sys_ctx_t would be null?*/
|
if (ctx == NULL) {
|
ERR ("%s, ctx is nullptr\n", __FUNCTION__);
|
return XCAM_RETURN_ERROR_PARAM;
|
}
|
|
sample_a3dlut_usage ();
|
|
do {
|
|
key = getchar ();
|
while (key == '\n' || key == '\r')
|
key = getchar();
|
printf ("\n");
|
|
switch (key)
|
{
|
case 'h':
|
CLEAR();
|
sample_a3dlut_usage ();
|
break;
|
case '0':
|
sample_set_a3dlut_manual(ctx);
|
printf("Set 3DLUT MANUAL Mode\n\n");
|
break;
|
case '1':
|
sample_set_a3dlut_auto(ctx);
|
printf("Set 3DLUT AUTO Mode\n\n");
|
break;
|
case '2':
|
sample_get_a3dlut_mode(ctx);
|
break;
|
case '3':
|
sample_set_a3dlut_manual_lut(ctx);
|
break;
|
case '4':
|
sample_get_a3dlut_lut(ctx);
|
break;
|
case '5':
|
sample_get_a3dlut_strength(ctx);
|
break;
|
case '6':
|
sample_get_a3dlut_lutname(ctx);
|
break;
|
case 'a':
|
sample_3dlut_set3dlutAttr(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
|
sample_3dlut_get3dlutAttr(ctx);
|
break;
|
case 'b':
|
sample_3dlut_set3dlutAttr(ctx, RK_AIQ_UAPI_MODE_ASYNC);
|
sample_3dlut_get3dlutAttr(ctx);
|
usleep(40*1000);
|
sample_3dlut_get3dlutAttr(ctx);
|
break;
|
case 'c':
|
sample_3dlut_setModeManual(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
|
sample_3dlut_getMode(ctx);
|
break;
|
case 'd':
|
sample_3dlut_setModeManual(ctx, RK_AIQ_UAPI_MODE_ASYNC);
|
sample_3dlut_getMode(ctx);
|
usleep(40*1000);
|
sample_3dlut_getMode(ctx);
|
break;
|
case 'e':
|
sample_3dlut_setModeAuto(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
|
sample_3dlut_getMode(ctx);
|
break;
|
case 'f':
|
sample_3dlut_setModeAuto(ctx, RK_AIQ_UAPI_MODE_ASYNC);
|
sample_3dlut_getMode(ctx);
|
usleep(40*1000);
|
sample_3dlut_getMode(ctx);
|
break;
|
case 'g':
|
sample_3dlut_setM3dlut(ctx, RK_AIQ_UAPI_MODE_DEFAULT);
|
sample_3dlut_get3dlutAttr(ctx);
|
break;
|
break;
|
case 'i':
|
sample_3dlut_setM3dlut(ctx, RK_AIQ_UAPI_MODE_ASYNC);
|
sample_3dlut_get3dlutAttr(ctx);
|
usleep(40*1000);
|
sample_3dlut_get3dlutAttr(ctx);
|
break;
|
case 'j':
|
sample_query_a3dlut_info(ctx);
|
break;
|
default:
|
break;
|
}
|
} while (key != 'q' && key != 'Q');
|
|
return XCAM_RETURN_NO_ERROR;
|
}
|
