/*
|
* Copyright (C) 2020 Rockchip Electronics Co., Ltd.
|
* Authors:
|
* PutinLee <putin.lee@rock-chips.com>
|
* Cerf Yu <cerf.yu@rock-chips.com>
|
*
|
* 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.
|
*/
|
|
#define LOG_NDEBUG 0
|
#define LOG_TAG "rgaColorPalette"
|
|
#include <stdint.h>
|
#include <stdlib.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <errno.h>
|
#include <time.h>
|
|
#include <ui/PixelFormat.h>
|
#include <ui/GraphicBuffer.h>
|
#include <ui/GraphicBufferMapper.h>
|
#include <hardware/hardware.h>
|
#include <RockchipRga.h>
|
#include "RgaUtils.h"
|
#include "core/NormalRga.h"
|
|
#include "im2d_api/im2d.hpp"
|
|
using namespace android;
|
|
#define IS_IM2D_API 1
|
|
sp<GraphicBuffer> GraphicBuffer_Init(int width, int height,int format)
|
{
|
#ifdef ANDROID_7_DRM
|
sp<GraphicBuffer> gb(new GraphicBuffer(width,height,format,
|
GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_FB));
|
#else
|
sp<GraphicBuffer> gb(new GraphicBuffer(width,height,format,
|
GRALLOC_USAGE_SW_WRITE_OFTEN | GRALLOC_USAGE_SW_READ_OFTEN));
|
#endif
|
|
if (gb->initCheck())
|
{
|
printf("GraphicBuffer check error : %s\n",strerror(errno));
|
return NULL;
|
}
|
|
return gb;
|
}
|
|
/********** write data to buffer or init buffer**********/
|
int GraphicBuffer_Fill(sp<GraphicBuffer> gb, int flag, int index) {
|
int ret;
|
char* buf = NULL;
|
ret = gb->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)&buf);
|
if (ret) {
|
printf("lock buffer error : %s\n",strerror(errno));
|
return -1;
|
} else
|
printf("lock buffer %s \n","ok");
|
|
if(flag) {
|
memset(buf,0xFF,get_bpp_from_format(RkRgaGetRgaFormatFromAndroid(gb->getPixelFormat()))*gb->getWidth()*gb->getHeight());
|
}
|
else {
|
ret = get_buf_from_file(buf, RkRgaGetRgaFormatFromAndroid(gb->getPixelFormat()), gb->getWidth(), gb->getHeight(), index);
|
if (!ret)
|
printf("open file %s \n", "ok");
|
else {
|
printf ("open file %s \n", "fault");
|
return -1;
|
}
|
}
|
|
ret = gb->unlock();
|
if (ret) {
|
printf("unlock buffer error : %s\n",strerror(errno));
|
return -1;
|
} else
|
printf("unlock buffer %s \n","ok");
|
|
return 0;
|
}
|
|
int GraphicBuffer_Fill_LUT(sp<GraphicBuffer> gb, int flag, int index) {
|
int ret, i;
|
char* buf = NULL;
|
ret = gb->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)&buf);
|
|
if (ret) {
|
printf("lock buffer error : %s\n",strerror(errno));
|
return -1;
|
} else
|
printf("lock buffer %s \n","ok");
|
|
/*Draw lut table*/
|
if(flag) {
|
for (i = 0; i < 32*4; i+=4) {
|
buf[i+0] = 0xFF;
|
buf[i+1] = 0x00;
|
buf[i+2] = 0x00;
|
buf[i+3] = 0x00;
|
}
|
for (; i < 32*2*4; i+=4) {
|
buf[i+0] = 0x00;
|
buf[i+1] = 0xFF;
|
buf[i+2] = 0x00;
|
buf[i+3] = 0x00;
|
}
|
for (; i < 32*3*4; i+=4) {
|
buf[i+0] = 0x00;
|
buf[i+1] = 0x00;
|
buf[i+2] = 0xFF;
|
buf[i+3] = 0x00;
|
}
|
for (; i < 32*4*4; i+=4) {
|
buf[i+0] = 0xaf;
|
buf[i+1] = 0xaf;
|
buf[i+2] = 0xaf;
|
buf[i+3] = 0x00;
|
}
|
for (; i < 32*5*4; i+=4) {
|
buf[i+0] = 0xFF;
|
buf[i+1] = 0xFF;
|
buf[i+2] = 0x00;
|
buf[i+3] = 0x00;
|
}
|
for (; i < 32*6*4; i+=4) {
|
buf[i+0] = 0xFF;
|
buf[i+1] = 0x00;
|
buf[i+2] = 0xFF;
|
buf[i+3] = 0x00;
|
}
|
for (; i < 32*7*4; i+=4) {
|
buf[i+0] = 0x00;
|
buf[i+1] = 0xFF;
|
buf[i+2] = 0xFF;
|
buf[i+3] = 0x00;
|
}
|
for (; i < 32*8*4; i+=4) {
|
buf[i+0] = 0xFF;
|
buf[i+1] = 0xFF;
|
buf[i+2] = 0xFF;
|
buf[i+3] = 0x00;
|
}
|
}
|
else {
|
ret = get_buf_from_file(buf, gb->getPixelFormat(), gb->getWidth(), gb->getHeight(), index);
|
if (!ret)
|
printf("open file %s \n", "ok");
|
else {
|
printf ("open file %s \n", "fault");
|
return -1;
|
}
|
}
|
|
ret = gb->unlock();
|
if (ret) {
|
printf("unlock buffer error : %s\n",strerror(errno));
|
return -1;
|
} else
|
printf("unlock buffer %s \n","ok");
|
|
return 0;
|
}
|
|
/********** output buf data to file **********/
|
int Out2Bin(sp<GraphicBuffer> gb, int index)
|
{
|
char* dstbuf = NULL;
|
int ret = 0;
|
if (gb != NULL)
|
{
|
ret = gb->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)&dstbuf);
|
if (ret)
|
{
|
printf("lock buffer_src error : %s\n",strerror(errno));
|
return ret;
|
}
|
output_buf_data_to_file(dstbuf, gb->getPixelFormat(), gb->getWidth(), gb->getHeight(), index);
|
ret = gb->unlock();
|
if (ret)
|
{
|
printf("unlock buffer_dst error : %s\n",strerror(errno));
|
return ret;
|
}
|
}
|
return 0;
|
}
|
|
int main()
|
{
|
int ret = 0;
|
int srcWidth,srcHeight,srcFormat;
|
int dstWidth,dstHeight,dstFormat;
|
int lutWidth,lutHeight,lutFormat;
|
|
sp<GraphicBuffer> src_buf;
|
sp<GraphicBuffer> dst_buf;
|
sp<GraphicBuffer> lut_buf;
|
|
#if !IS_IM2D_API
|
rga_info_t src;
|
rga_info_t dst;
|
rga_info_t lut;
|
|
RockchipRga& rkRga(RockchipRga::get());
|
#else
|
rga_buffer_t imsrc;
|
rga_buffer_t imdst;
|
rga_buffer_t imlut;
|
#endif
|
|
/********** SrcInfo set **********/
|
srcWidth = 1280;
|
srcHeight = 720;
|
srcFormat = HAL_PIXEL_FORMAT_BPP_8;
|
|
/********** DstInfo set **********/
|
dstWidth = 1280;
|
dstHeight = 720;
|
dstFormat = HAL_PIXEL_FORMAT_RGBA_8888;
|
|
/*
|
* The minimum page size set by mmu is 64k,
|
* and mmu will report an error if it is
|
* smaller than this size. Actually only
|
* use 256*1*4 byte.
|
*/
|
/********** LutInfo set **********/
|
lutWidth = 256;
|
lutHeight = 64;
|
lutFormat = HAL_PIXEL_FORMAT_RGBA_8888;
|
|
/*********** Init GraphicBuffer ***********/
|
src_buf = GraphicBuffer_Init(srcWidth, srcHeight, srcFormat);
|
dst_buf = GraphicBuffer_Init(dstWidth, dstHeight, dstFormat);
|
lut_buf = GraphicBuffer_Init(lutWidth, lutHeight, lutFormat);
|
if (src_buf == NULL || dst_buf == NULL || lut_buf == NULL)
|
{
|
printf("GraphicBuff init error!\n");
|
return -1;
|
}
|
|
/*********** fill or empty GraphicBuffer ***********/
|
if(-1 == GraphicBuffer_Fill(src_buf, 0, 0))
|
{
|
printf("%s, src write Graphicbuffer error!\n", __FUNCTION__);
|
return -1;
|
}
|
if(-1 == GraphicBuffer_Fill(dst_buf, 1, 0))
|
{
|
printf("%s, dst empty Graphicbuffer error!\n", __FUNCTION__);
|
return -1;
|
}
|
if(-1 == GraphicBuffer_Fill_LUT(lut_buf, 1, 0))
|
{
|
printf("%s, lut table write Graphicbuffer error!\n", __FUNCTION__);
|
return -1;
|
}
|
|
/*********** color palette ***********/
|
#if !IS_IM2D_API
|
memset(&src, 0, sizeof(rga_info_t));
|
memset(&dst, 0, sizeof(rga_info_t));
|
memset(&lut, 0, sizeof(rga_info_t));
|
|
rga_set_rect(&src.rect, 0,0,srcWidth,srcHeight,srcWidth/*stride*/,srcHeight,srcFormat);
|
rga_set_rect(&dst.rect, 0, 0,srcWidth,srcHeight,dstWidth/*stride*/,dstHeight,dstFormat);
|
rga_set_rect(&lut.rect, 0, 0,lutWidth,lutHeight,lutWidth/*stride*/,lutHeight,lutFormat);
|
|
src.hnd = src_buf->handle;
|
dst.hnd = dst_buf->handle;
|
lut.hnd = lut_buf->handle;
|
|
ret = rkRga.RkRgaCollorPalette(&src, &dst, &lut);
|
#else
|
imsrc = wrapbuffer_GraphicBuffer(src_buf);
|
imdst = wrapbuffer_GraphicBuffer(dst_buf);
|
imlut = wrapbuffer_GraphicBuffer(lut_buf);
|
if(imsrc.width == 0 || imdst.width == 0) {
|
printf("%s, %s\n", __FUNCTION__, imStrError());
|
return -1;
|
}
|
|
ret = impalette(imsrc, imdst, imlut);
|
printf("paletting .... %s\n", imStrError(ret));
|
#endif
|
|
/*********** Out to binary ***********/
|
Out2Bin(lut_buf, 0);
|
Out2Bin(dst_buf, 0);
|
}
|
