1842 lines
46 KiB
C
1842 lines
46 KiB
C
#include "osal/string.h"
|
||
#include "math.h"
|
||
#include "typesdef.h"
|
||
#include "sys_config.h"
|
||
#include "lib/vef/video_ef.h"
|
||
// #include "hal/dma.h"
|
||
|
||
|
||
volatile vf_cblk g_vf_cblk;
|
||
|
||
#if 0
|
||
void memcpy16(uint32 dst, uint32 src, uint32 cnt)
|
||
{
|
||
uint16* ps = src & 0xfffffffe;
|
||
uint16* pd = dst & 0xfffffffe;
|
||
for(uint32 i = 0;i<cnt/2;i++)
|
||
{
|
||
pd[i] = ps[i];
|
||
}
|
||
}
|
||
#endif
|
||
void memcpy32(uint32 dst, uint32 src, uint32 cnt)
|
||
{
|
||
// os_printf("dst : %x ,src : %x ", dst, src);
|
||
uint32* ps = (uint32*)(src & 0xfffffffc);
|
||
uint32* pd = (uint32*)(dst & 0xfffffffc);
|
||
// os_printf("pd : %x ,ps : %x\r\n", pd, ps);
|
||
for(uint32 i = 0;i<cnt/4;i++)
|
||
{
|
||
pd[i] = ps[i];
|
||
}
|
||
}
|
||
|
||
void line_inv(uint8 *in, uint8* out, uint8 *tmp,uint32 cnt)
|
||
{
|
||
#if 0
|
||
os_memcpy(&tmp[cnt], in, cnt);
|
||
for(uint32 i = 0;i<cnt;i++)
|
||
{
|
||
tmp[i] = tmp[2*cnt-1-i];
|
||
}
|
||
os_memcpy(out, tmp, cnt);
|
||
#elif 1
|
||
uint32 *in32 = (uint32*)in;
|
||
uint32 *out32 = (uint32*)out;
|
||
for(uint32 i = 0;i<cnt/4;i++)
|
||
{
|
||
out32[cnt/4-i-1] = __builtin_bswap32 (in32[i]);
|
||
}
|
||
#elif 0
|
||
uint32 *in32 = (uint32*)in;
|
||
uint32 *out32 = (uint32*)out;
|
||
os_memcpy(&tmp[cnt], in, cnt);
|
||
for(uint32 i = 0;i<cn/4;i++)
|
||
{
|
||
tmp[i] = tmp[2*cnt-1-i];
|
||
}
|
||
os_memcpy(out, tmp, cnt);
|
||
#elif 0
|
||
uint16 *in16 = (uint16*)in;
|
||
uint16 *out16 = (uint16*)out;
|
||
for(uint32 i = 0;i<cnt/2;i++)
|
||
{
|
||
out16[cnt/4-i-1] = in16[i];
|
||
}
|
||
|
||
#endif
|
||
|
||
}
|
||
|
||
void line_mov(uint8 *in, uint8* out, uint8 *tmp,uint32 cnt)
|
||
{
|
||
#if 0
|
||
memcpy32(tmp, in, cnt);
|
||
memcpy32(out, tmp, cnt);
|
||
#elif 1
|
||
hw_memcpy(out, in, cnt);
|
||
#endif
|
||
}
|
||
|
||
void get_img_retc(uint8* iyuv, uint16 ph, uint16 pw, uint16 sh, uint16 sw,
|
||
uint8 *oyuv, uint16 oh, uint16 ow)
|
||
{
|
||
uint16 s_row, s_col, e_row, e_col;
|
||
uint16 col;
|
||
uint16 img_col;
|
||
uint8 *iy,*iu,*iv;
|
||
uint8 *oy,*ou,*ov;
|
||
|
||
s_row = sh;
|
||
s_col = sw;
|
||
e_row = s_row + oh;
|
||
e_col = s_col + ow;
|
||
iy = iyuv;
|
||
iu = iy + ph*pw;
|
||
iv = iu + ph*pw/4;
|
||
oy = oyuv;
|
||
ou = oy + oh*ow;
|
||
ov = ou + oh*ow/4;
|
||
uint8* line_tmp = os_malloc(ow);
|
||
|
||
for(uint16 row = s_row, img_row=0;row<e_row;row++,img_row++)
|
||
{
|
||
// for(uint16 col = s_col,img_col=0;col<e_col;col++,img_col++) {
|
||
// oy[img_row*ow+img_col] = iy[row*pw+col];
|
||
// ou[(img_row/2)*(ow/2)+img_col/2] = iu[(row/2)*(pw/2)+col/2];
|
||
// ov[(img_row/2)*(ow/2)+img_col/2] = iv[(row/2)*(pw/2)+col/2];
|
||
// }
|
||
col = s_col;
|
||
img_col = 0;
|
||
hw_memcpy(&oy[img_row*ow+img_col], &iy[(row)*(pw)+col], e_col - s_col);
|
||
// line_cpy(&iy[(row)*(pw)+col], &oy[img_row*ow+img_col], line_tmp, e_col - s_col);
|
||
if( !(row & 1)) {
|
||
memcpy(&ou[(img_row/2)*(ow/2)+img_col/2], &iu[(row/2)*(pw/2)+col/2], (e_col - s_col)/2);
|
||
memcpy(&ov[(img_row/2)*(ow/2)+img_col/2], &iv[(row/2)*(pw/2)+col/2], (e_col - s_col)/2);
|
||
// line_cpy(&ou[(img_row/2)*(ow/2)+img_col/2], &iu[(row/2)*(pw/2)+col/2], line_tmp, (e_col - s_col)/2);
|
||
// line_cpy(&ov[(img_row/2)*(ow/2)+img_col/2], &iv[(row/2)*(pw/2)+col/2], line_tmp, (e_col - s_col)/2);
|
||
}
|
||
}
|
||
os_free(line_tmp);
|
||
}
|
||
|
||
// extern __bobj struct dma_device *m2mdma;
|
||
void get_img_retc_blkcpy(uint8* iyuv, uint16 ph, uint16 pw, uint16 sh, uint16 sw,
|
||
uint8 *oyuv, uint16 oh, uint16 ow)
|
||
{
|
||
uint8 *iy,*iu,*iv;
|
||
uint8 *oy,*ou,*ov;
|
||
iy = iyuv;
|
||
iu = iy + ph*pw;
|
||
iv = iu + ph*pw/4;
|
||
oy = oyuv;
|
||
ou = oy + oh*ow;
|
||
ov = ou + oh*ow/4;
|
||
// os_printf("%x %x\r\n", oy, &iy[sh*pw+sw]);
|
||
// os_printf("bw %d sw %d", ow, pw);
|
||
// hw_blkcpy0(oy, &iy[sw] , ow, oh, pw, ow);
|
||
// hw_blkcpy0(ou, &iu[(sh/2)*(pw/2)+(sw/2)] , ow/2, oh/2, pw/2, ow/2);
|
||
// hw_blkcpy0(ov, &iv[(sh/2)*(pw/2)+(sw/2)] , ow/2, oh/2, pw/2, ow/2);
|
||
|
||
}
|
||
|
||
|
||
void put_img_retc(uint8* iyuv, uint16 ph, uint16 pw,
|
||
uint8 *oyuv, uint16 sh, uint16 sw, uint16 oh, uint16 ow)
|
||
{
|
||
uint16 s_row, s_col, e_row, e_col;
|
||
uint16 col;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
uint16 img_col;
|
||
s_row = sh;
|
||
s_col = sw;
|
||
e_row = s_row + ph;
|
||
e_col = s_col + pw;
|
||
iy = iyuv;
|
||
iu = iyuv + ph*pw;
|
||
iv = iyuv + ph*pw + ph*pw/4;
|
||
oy = oyuv;
|
||
ou = oyuv + oh*ow;
|
||
ov = oyuv + oh*ow + oh*ow/4;
|
||
|
||
for(uint16 row = s_row,img_row=0;row<e_row;row++,img_row++)
|
||
{
|
||
// for(uint16 col = s_col,img_col=0;col<e_col;col++,img_col++) {
|
||
// oy[row*ow+col] = iy[img_row*pw+img_col];
|
||
|
||
// ou[(row/2)*(ow/2)+col/2] = iu[(img_row/2)*(pw/2)+img_col/2];
|
||
// ov[(row/2)*(ow/2)+col/2] = iv[(img_row/2)*(pw/2)+img_col/2];
|
||
// iindex++;
|
||
// }
|
||
col = s_col;
|
||
img_col = 0;
|
||
hw_memcpy(&oy[row*ow+col], &iy[(img_row)*(pw)+img_col], e_col - s_col);
|
||
if( !(row & 1)) {
|
||
memcpy(&ou[(row/2)*(ow/2)+col/2], &iu[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
memcpy(&ov[(row/2)*(ow/2)+col/2], &iv[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
}
|
||
}
|
||
}
|
||
|
||
void put_img_retc_ix(uint8* iyuv, uint16 ph, uint16 pw,
|
||
uint8 *oyuv, uint16 sh, uint16 sw, uint16 oh, uint16 ow)
|
||
{
|
||
uint16 s_row, s_col, e_row, e_col;
|
||
uint16 col;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
uint16 img_col;
|
||
s_row = sh;
|
||
s_col = sw;
|
||
e_row = s_row + ph;
|
||
e_col = s_col + pw;
|
||
iy = iyuv;
|
||
iu = iyuv + ph*pw;
|
||
iv = iyuv + ph*pw + ph*pw/4;
|
||
oy = oyuv;
|
||
ou = oyuv + oh*ow;
|
||
ov = oyuv + oh*ow + oh*ow/4;
|
||
|
||
uint8* line_tmp = os_malloc(pw*2);
|
||
|
||
for(uint16 row = s_row,img_row=0;row<e_row;row++,img_row++)
|
||
{
|
||
// for(uint16 col = s_col,img_col=pw-1;col<e_col;col++,img_col--) {
|
||
// oy[row*ow+col] = iy[img_row*pw+img_col];
|
||
// ou[(row/2)*(ow/2)+col/2] = iu[(img_row/2)*(pw/2)+img_col/2];
|
||
// ov[(row/2)*(ow/2)+col/2] = iv[(img_row/2)*(pw/2)+img_col/2];
|
||
// iindex++;
|
||
// }
|
||
col = s_col;
|
||
img_col = 0;
|
||
line_inv(&iy[(img_row)*(pw)+img_col], &oy[row*ow+col], line_tmp, e_col - s_col);
|
||
// hw_memcpy(&oy[row*ow+col], &iy[(img_row)*(pw)+img_col], e_col - s_col);
|
||
if( !(row & 1)) {
|
||
line_inv(&iu[(img_row/2)*(pw/2)+img_col/2], &ou[(row/2)*(ow/2)+col/2], line_tmp, (e_col - s_col)/2);
|
||
line_inv(&iv[(img_row/2)*(pw/2)+img_col/2], &ov[(row/2)*(ow/2)+col/2], line_tmp, (e_col - s_col)/2);
|
||
// hw_memcpy(&ou[(row/2)*(ow/2)+col/2], &iu[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
// hw_memcpy(&ov[(row/2)*(ow/2)+col/2], &iv[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
}
|
||
}
|
||
os_free(line_tmp);
|
||
}
|
||
|
||
void put_img_retc_iy(uint8* iyuv, uint16 ph, uint16 pw,
|
||
uint8 *oyuv, uint16 sh, uint16 sw, uint16 oh, uint16 ow)
|
||
{
|
||
uint16 s_row, s_col, e_row, e_col;
|
||
uint16 col;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
uint16 img_col;
|
||
s_row = sh;
|
||
s_col = sw;
|
||
e_row = s_row + ph;
|
||
e_col = s_col + pw;
|
||
iy = iyuv;
|
||
iu = iyuv + ph*pw;
|
||
iv = iyuv + ph*pw + ph*pw/4;
|
||
oy = oyuv;
|
||
ou = oyuv + oh*ow;
|
||
ov = oyuv + oh*ow + oh*ow/4;
|
||
|
||
for(uint16 row = s_row,img_row=ph-1;row<e_row;row++,img_row--)
|
||
{
|
||
// for(uint16 col = s_col,img_col=0;col<e_col;col++,img_col++) {
|
||
|
||
// oy[row*ow+col] = iy[img_row*pw+img_col];
|
||
// ou[(row/2)*(ow/2)+col/2] = iu[(img_row/2)*(pw/2)+img_col/2];
|
||
// ov[(row/2)*(ow/2)+col/2] = iv[(img_row/2)*(pw/2)+img_col/2];
|
||
// iindex++;
|
||
// }
|
||
col = s_col;
|
||
img_col = 0;
|
||
hw_memcpy(&oy[row*ow+col], &iy[(img_row)*(pw)+img_col], e_col - s_col);
|
||
if( !(row & 1)) {
|
||
memcpy(&ou[(row/2)*(ow/2)+col/2], &iu[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
memcpy(&ov[(row/2)*(ow/2)+col/2], &iv[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
}
|
||
}
|
||
}
|
||
|
||
void put_img_retc_ixy(uint8* iyuv, uint16 ph, uint16 pw,
|
||
uint8 *oyuv, uint16 sh, uint16 sw, uint16 oh, uint16 ow)
|
||
{
|
||
uint16 s_row, s_col, e_row, e_col;
|
||
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
s_row = sh;
|
||
s_col = sw;
|
||
e_row = s_row + ph;
|
||
e_col = s_col + pw;
|
||
iy = iyuv;
|
||
iu = iyuv + ph*pw;
|
||
iv = iyuv + ph*pw + ph*pw/4;
|
||
oy = oyuv;
|
||
ou = oyuv + oh*ow;
|
||
ov = oyuv + oh*ow + oh*ow/4;
|
||
uint16 iindex = 0;
|
||
for(uint16 row = s_row,img_row=ph-1;row<e_row;row++,img_row--)
|
||
{
|
||
for(uint16 col = s_col,img_col=pw-1;col<e_col;col++,img_col--) {
|
||
oy[row*ow+col] = iy[img_row*pw+img_col];
|
||
ou[(row/2)*(ow/2)+col/2] = iu[(img_row/2)*(pw/2)+img_col/2];
|
||
ov[(row/2)*(ow/2)+col/2] = iv[(img_row/2)*(pw/2)+img_col/2];
|
||
iindex++;
|
||
}
|
||
}
|
||
}
|
||
|
||
void mov_img_retc(uint8* iyuv, uint16 ih, uint16 iw, uint16 imy, uint16 imx,
|
||
uint8 *oyuv, uint16 oh, uint16 ow, uint16 omy, uint16 omx, uint16 blkh, uint16 blkw)
|
||
{
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
iy = iyuv;
|
||
iu = iyuv + ih*iw;
|
||
iv = iyuv + ih*iw + ih*iw/4;
|
||
oy = oyuv;
|
||
ou = oyuv + oh*ow;
|
||
ov = oyuv + oh*ow + oh*ow/4;
|
||
uint8 line_tmp[640];
|
||
|
||
// handle y data
|
||
for(uint16 row = 0;row<blkh;row++)
|
||
{
|
||
line_mov(&iy[(imy+row)*(iw)+imx], &oy[(omy+row)*(ow)+omx], line_tmp, blkw);
|
||
// hw_memcpy(&oy[(omy+row)*(ow)+omx], &iy[(imy+row)*(iw)+imx], blkw);
|
||
}
|
||
|
||
// // handle uv data
|
||
for(uint16 row = 0;row<blkh/2;row++)
|
||
{
|
||
line_mov(&iu[(imy/2+row)*(iw/2)+imx/2], &ou[(omy/2+row)*(ow/2)+omx/2], line_tmp, blkw/2);
|
||
// hw_memcpy(&ou[(omy/2+row)*(ow/2)+omx/2], &iu[(imy/2+row)*(iw/2)+imx/2], blkw/2);
|
||
}
|
||
|
||
for(uint16 row = 0;row<blkh/2;row++)
|
||
{
|
||
line_mov(&iv[(imy/2+row)*(iw/2)+imx/2], &ov[(omy/2+row)*(ow/2)+omx/2], line_tmp, blkw/2);
|
||
// hw_memcpy(&ov[(omy/2+row)*(ow/2)+omx/2], &iv[(imy/2+row)*(iw/2)+imx/2], blkw/2);
|
||
}
|
||
}
|
||
|
||
void mov_img_retc_ix(uint8* iyuv, uint16 ih, uint16 iw, uint16 imy, uint16 imx,
|
||
uint8 *oyuv, uint16 oh, uint16 ow, uint16 omy, uint16 omx, uint16 blkh, uint16 blkw)
|
||
{
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
iy = iyuv;
|
||
iu = iyuv + ih*iw;
|
||
iv = iyuv + ih*iw + ih*iw/4;
|
||
oy = oyuv;
|
||
ou = oyuv + oh*ow;
|
||
ov = oyuv + oh*ow + oh*ow/4;
|
||
uint8 line_tmp[640];
|
||
|
||
// handle y data
|
||
for(uint16 row = 0;row<blkh;row++)
|
||
{
|
||
line_inv(&iy[(imy+row)*(iw)+imx], &oy[(omy+row)*(ow)+omx], line_tmp, blkw);
|
||
}
|
||
|
||
// // handle uv data
|
||
for(uint16 row = 0;row<blkh/2;row++)
|
||
{
|
||
line_inv(&iu[(imy/2+row)*(iw/2)+imx/2], &ou[(omy/2+row)*(ow/2)+omx/2], line_tmp, blkw/2);
|
||
}
|
||
|
||
for(uint16 row = 0;row<blkh/2;row++)
|
||
{
|
||
line_inv(&iv[(imy/2+row)*(iw/2)+imx/2], &ov[(omy/2+row)*(ow/2)+omx/2], line_tmp, blkw/2);
|
||
}
|
||
}
|
||
|
||
void mov_img_retc_iy(uint8* iyuv, uint16 ih, uint16 iw, uint16 imy, uint16 imx,
|
||
uint8 *oyuv, uint16 oh, uint16 ow, uint16 omy, uint16 omx, uint16 blkh, uint16 blkw)
|
||
{
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
iy = iyuv;
|
||
iu = iyuv + ih*iw;
|
||
iv = iyuv + ih*iw + ih*iw/4;
|
||
oy = oyuv;
|
||
ou = oyuv + oh*ow;
|
||
ov = oyuv + oh*ow + oh*ow/4;
|
||
uint8 line_tmp[640];
|
||
|
||
// handle y data
|
||
for(uint16 row = 0;row<blkh;row++)
|
||
{
|
||
line_mov(&iy[(imy+row)*(iw)+imx], &oy[(omy+blkh-row)*(ow)+omx], line_tmp, blkw);
|
||
}
|
||
|
||
// // handle uv data
|
||
for(uint16 row = 0;row<blkh/2;row++)
|
||
{
|
||
line_mov(&iu[(imy/2+row)*(iw/2)+imx/2], &ou[(omy/2+blkh/2-row)*(ow/2)+omx/2], line_tmp, blkw/2);
|
||
}
|
||
|
||
for(uint16 row = 0;row<blkh/2;row++)
|
||
{
|
||
line_mov(&iv[(imy/2+row)*(iw/2)+imx/2], &ov[(omy/2+blkh/2-row)*(ow/2)+omx/2], line_tmp, blkw/2);
|
||
}
|
||
}
|
||
|
||
void mov_img_retc_iy1(uint8* iyuv, uint16 ih, uint16 iw, uint16 imy, uint16 imx,
|
||
uint8 *oyuv, uint16 oh, uint16 ow, uint16 omy, uint16 omx, uint16 blkh, uint16 blkw)
|
||
{
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
iy = iyuv;
|
||
iu = iyuv + ih*iw;
|
||
iv = iyuv + ih*iw + ih*iw/4;
|
||
oy = oyuv;
|
||
ou = oyuv + oh*ow;
|
||
ov = oyuv + oh*ow + oh*ow/4;
|
||
uint8 line_tmp[640];
|
||
|
||
// handle y data
|
||
for(uint16 row = 0;row<blkh;row++)
|
||
{
|
||
line_mov(&iy[(imy+row)*(iw)+imx], &oy[(omy+blkh-row)*(ow)+omx], line_tmp, blkw);
|
||
}
|
||
|
||
// // handle uv data
|
||
for(uint16 row = 0;row<blkh/2;row++)
|
||
{
|
||
line_mov(&iu[(imy/2+row)*(iw/2)+imx/2], &ou[(omy/2+blkh/2-row)*(ow/2)+omx/2], line_tmp, blkw/2);
|
||
}
|
||
|
||
for(uint16 row = 0;row<blkh/2;row++)
|
||
{
|
||
line_mov(&iv[(imy/2+row)*(iw/2)+imx/2], &ov[(omy/2+blkh/2-row)*(ow/2)+omx/2], line_tmp, blkw/2);
|
||
}
|
||
}
|
||
|
||
void put_img_hexagon(uint8* iyuv, uint16 ph, uint16 pw, double angle,
|
||
uint8 *oyuv, int16 sh, int16 sw, uint16 oh, uint16 ow)
|
||
{
|
||
int16 s_row, s_col, e_row, e_col;
|
||
int16 row, col;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
// uint8 y_val, u_val, v_val;
|
||
uint16 tri_h = (ph - pw)/2;
|
||
|
||
uint32 strih;
|
||
uint16 striw;
|
||
uint16 stril;
|
||
uint32 ucos = cos(angle/2)*524288;
|
||
uint32 usin = sin(angle/2)*524288;
|
||
volatile uint16 img_row = 0;
|
||
volatile uint16 img_col = 0;
|
||
s_row = sh;
|
||
s_col = sw;
|
||
e_row = s_row + ph;
|
||
e_col = s_col + pw;
|
||
iy = iyuv;
|
||
iu = &iyuv[ph*pw];
|
||
iv = &iyuv[ph*pw+ph*pw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
if(e_row > oh) {
|
||
e_row = oh;
|
||
}
|
||
//os_printf("sr %d er %d\r\n", s_row, e_row);
|
||
|
||
s_row = sh;
|
||
// e_row = s_row + tri_h;
|
||
for(row = s_row;row<e_row;row++,img_row++)
|
||
{
|
||
if(row < 0) continue;
|
||
strih = row - s_row;
|
||
if(strih == 0) {
|
||
s_col = sw+(pw/2);
|
||
e_col = sw+(pw/2);
|
||
} else if(strih < tri_h) {
|
||
stril = strih *524288 / ucos;
|
||
striw = stril * usin * 2 / 524288;
|
||
//os_//os_printf("striw %d\r\n", striw);
|
||
s_col = sw + (pw/2) - (striw/2);
|
||
e_col = sw + (pw/2) + (striw/2);
|
||
} else if(strih < tri_h+pw) {
|
||
s_col = sw + (pw/2) - (pw/2);
|
||
e_col = sw + (pw/2) + (pw/2);
|
||
} else if(strih < tri_h+pw+tri_h) {
|
||
strih = ph - strih - 1;
|
||
stril = strih *524288 / ucos;
|
||
striw = stril * usin * 2 / 524288;
|
||
s_col = sw + (pw/2) - (striw/2);
|
||
e_col = sw + (pw/2) + (striw/2);
|
||
}
|
||
|
||
img_col = s_col - sw;
|
||
if(s_col <0) {
|
||
img_col += 0 - (s_col);
|
||
s_col = 0;
|
||
}
|
||
if(e_col > ow) {
|
||
e_col = ow;
|
||
}
|
||
// //os_printf("s %d e %d\r\n", s_col, e_col);
|
||
//os_printf("row=%d irow=%d scol=%d ecol=%d\r\n", row, img_row, s_col, e_col);
|
||
// for(col = s_col;col<e_col;col++,img_col++) {
|
||
// oy[row*ow+col] = iy[(img_row)*(pw)+img_col];
|
||
// }
|
||
// if(row & 1) {
|
||
// for(col = s_col;col<e_col;col++,img_col++) {
|
||
// ou[(row/2)*(ow/2)+col/2] = iu[(img_row/2)*(pw/2)+img_col/2];
|
||
// ov[(row/2)*(ow/2)+col/2] = iv[(img_row/2)*(pw/2)+img_col/2];
|
||
// }
|
||
// }
|
||
col = s_col;
|
||
hw_memcpy(&oy[row*ow+col], &iy[(img_row)*(pw)+img_col], e_col - s_col);
|
||
if( !(row & 1)) {
|
||
hw_memcpy(&ou[(row/2)*(ow/2)+col/2], &iu[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
hw_memcpy(&ov[(row/2)*(ow/2)+col/2], &iv[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
}
|
||
|
||
}
|
||
// s_row = e_row;
|
||
// e_row = s_row + pw;
|
||
// for(row = s_row;row<e_row;row++,img_row++)
|
||
// {
|
||
// if(row < 0) continue;
|
||
// strih = row - s_row;
|
||
// if(strih == 0) {
|
||
// s_col = sw+(pw/2);
|
||
// e_col = sw+(pw/2);
|
||
// } else if(strih < tri_h) {
|
||
// stril = strih *524288 / ucos;
|
||
// striw = stril * usin * 2 / 524288;
|
||
// //os_//os_printf("striw %d\r\n", striw);
|
||
// s_col = sw + (pw/2) - (striw/2);
|
||
// e_col = sw + (pw/2) + (striw/2);
|
||
// } else if(strih < tri_h+pw) {
|
||
// s_col = sw + (pw/2) - (pw/2);
|
||
// e_col = sw + (pw/2) + (pw/2);
|
||
// } else if(strih < tri_h+pw+tri_h) {
|
||
// strih = ph - strih - 1;
|
||
// stril = strih *524288 / ucos;
|
||
// striw = stril * usin * 2 / 524288;
|
||
// s_col = sw + (pw/2) - (striw/2);
|
||
// e_col = sw + (pw/2) + (striw/2);
|
||
// }
|
||
|
||
// img_col = s_col - sw;
|
||
// if(s_col <0) {
|
||
// img_col += 0 - (s_col);
|
||
// s_col = 0;
|
||
// }
|
||
// if(e_col > ow) {
|
||
// e_col = ow;
|
||
// }
|
||
// // //os_printf("s %d e %d\r\n", s_col, e_col);
|
||
// //os_printf("row=%d irow=%d scol=%d ecol=%d\r\n", row, img_row, s_col, e_col);
|
||
// // for(col = s_col;col<e_col;col++,img_col++) {
|
||
// // oy[row*ow+col] = iy[(img_row)*(pw)+img_col];
|
||
// // }
|
||
// // if(row & 1) {
|
||
// // for(col = s_col;col<e_col;col++,img_col++) {
|
||
// // ou[(row/2)*(ow/2)+col/2] = iu[(img_row/2)*(pw/2)+img_col/2];
|
||
// // ov[(row/2)*(ow/2)+col/2] = iv[(img_row/2)*(pw/2)+img_col/2];
|
||
// // }
|
||
// // }
|
||
// col = s_col;
|
||
// hw_memcpy(&oy[row*ow+col], &iy[(img_row)*(pw)+img_col], e_col - s_col);
|
||
// if(row & 1) {
|
||
// hw_memcpy(&ou[(row/2)*(ow/2)+col/2], &iu[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
// hw_memcpy(&ov[(row/2)*(ow/2)+col/2], &iv[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
// }
|
||
|
||
// }
|
||
// s_row = e_row;
|
||
// e_row = s_row + tri_h;
|
||
// for(row = s_row;row<e_row;row++,img_row++)
|
||
// {
|
||
// if(row < 0) continue;
|
||
// strih = row - s_row;
|
||
// if(strih == 0) {
|
||
// s_col = sw+(pw/2);
|
||
// e_col = sw+(pw/2);
|
||
// } else if(strih < tri_h) {
|
||
// stril = strih *524288 / ucos;
|
||
// striw = stril * usin * 2 / 524288;
|
||
// //os_//os_printf("striw %d\r\n", striw);
|
||
// s_col = sw + (pw/2) - (striw/2);
|
||
// e_col = sw + (pw/2) + (striw/2);
|
||
// } else if(strih < tri_h+pw) {
|
||
// s_col = sw + (pw/2) - (pw/2);
|
||
// e_col = sw + (pw/2) + (pw/2);
|
||
// } else if(strih < tri_h+pw+tri_h) {
|
||
// strih = ph - strih - 1;
|
||
// stril = strih *524288 / ucos;
|
||
// striw = stril * usin * 2 / 524288;
|
||
// s_col = sw + (pw/2) - (striw/2);
|
||
// e_col = sw + (pw/2) + (striw/2);
|
||
// }
|
||
|
||
// img_col = s_col - sw;
|
||
// if(s_col <0) {
|
||
// img_col += 0 - (s_col);
|
||
// s_col = 0;
|
||
// }
|
||
// if(e_col > ow) {
|
||
// e_col = ow;
|
||
// }
|
||
// // //os_printf("s %d e %d\r\n", s_col, e_col);
|
||
// //os_printf("row=%d irow=%d scol=%d ecol=%d\r\n", row, img_row, s_col, e_col);
|
||
// // for(col = s_col;col<e_col;col++,img_col++) {
|
||
// // oy[row*ow+col] = iy[(img_row)*(pw)+img_col];
|
||
// // }
|
||
// // if(row & 1) {
|
||
// // for(col = s_col;col<e_col;col++,img_col++) {
|
||
// // ou[(row/2)*(ow/2)+col/2] = iu[(img_row/2)*(pw/2)+img_col/2];
|
||
// // ov[(row/2)*(ow/2)+col/2] = iv[(img_row/2)*(pw/2)+img_col/2];
|
||
// // }
|
||
// // }
|
||
// col = s_col;
|
||
// hw_memcpy(&oy[row*ow+col], &iy[(img_row)*(pw)+img_col], e_col - s_col);
|
||
// if(row & 1) {
|
||
// hw_memcpy(&ou[(row/2)*(ow/2)+col/2], &iu[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
// hw_memcpy(&ov[(row/2)*(ow/2)+col/2], &iv[(img_row/2)*(pw/2)+img_col/2], (e_col - s_col)/2);
|
||
// }
|
||
// }
|
||
|
||
}
|
||
|
||
void put_img_hexagon1(uint8* iyuv, uint16 ph, uint16 pw, double angle, uint16 retc_h,
|
||
uint8 *oyuv, int16 sh, int16 sw, uint16 oh, uint16 ow)
|
||
{
|
||
int16 s_row, s_col = 0, e_row, e_col = 0;
|
||
int16 row, col;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
uint16 tri_h = (ph - retc_h)/2;
|
||
|
||
uint32 strih;
|
||
uint32 striw;
|
||
uint32 stril;
|
||
uint32 ucos = cos(angle/2)*1048576;
|
||
uint32 usin = sin(angle/2)*1048576;
|
||
volatile uint16 img_row = 0;
|
||
volatile uint16 img_col = 0;
|
||
|
||
iy = iyuv;
|
||
iu = &iyuv[ph*pw];
|
||
iv = &iyuv[ph*pw+ph*pw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
|
||
s_row = sh;
|
||
// e_row = s_row + tri_h;
|
||
e_row = s_row + ph;
|
||
if(s_row < 0) {
|
||
img_row = 0 - s_row;
|
||
s_row = 0;
|
||
}
|
||
if(e_row > oh) {
|
||
e_row = oh;
|
||
}
|
||
//printf("srow %d erow %d img_row %d\r\n", s_row, e_row, img_row);
|
||
for(row = s_row;row<e_row;row++,img_row++)
|
||
{
|
||
strih = row - sh;
|
||
if(strih < tri_h) {
|
||
stril = strih *1048576 / ucos;
|
||
striw = stril * usin * 2 / 1048576;
|
||
//printf("striw %d\r\n", striw);
|
||
s_col = sw + (pw/2) - (striw/2);
|
||
e_col = sw + (pw/2) + (striw/2);
|
||
} else if(strih < tri_h+retc_h) {
|
||
s_col = sw + (pw/2) - (pw/2);
|
||
e_col = sw + (pw/2) + (pw/2);
|
||
//continue;
|
||
} else if(strih < tri_h+retc_h+tri_h) {
|
||
strih = ph - strih - 1;
|
||
stril = strih *1048576 / ucos;
|
||
striw = stril * usin * 2 / 1048576;
|
||
s_col = sw + (pw/2) - (striw/2);
|
||
e_col = sw + (pw/2) + (striw/2);
|
||
}
|
||
|
||
img_col = s_col - sw;
|
||
if(s_col <0) {
|
||
img_col += 0 - (s_col);
|
||
s_col = 0;
|
||
}
|
||
if(e_col > ow) {
|
||
e_col = ow;
|
||
}
|
||
|
||
col = s_col;
|
||
//printf("s %d e %d row %d \r\n", s_col, e_col, row);
|
||
// if(s_col > e_col) {
|
||
// continue;
|
||
// }
|
||
//for(int16 col = s_col;col<e_col;col++,img_col++) {
|
||
//if(col > 20-1 && col <25-1 && row > 40-1 && row <51-1){
|
||
//oy[row*ow+col] = iy[(img_row)*(pw)+img_col];
|
||
|
||
|
||
//}
|
||
|
||
hw_memcpy(&oy[row*ow+col], &iy[(img_row)*(pw)+img_col], e_col-s_col);
|
||
if(!(row&1)) {
|
||
memcpy(&ou[(row/2)*(ow/2)+col/2], &iu[(img_row/2)*(pw/2)+img_col/2], (e_col-s_col)/2);
|
||
memcpy(&ov[(row/2)*(ow/2)+col/2], &iv[(img_row/2)*(pw/2)+img_col/2], (e_col-s_col)/2);
|
||
}
|
||
}
|
||
//printf("img_row %d\r\n", img_row);
|
||
}
|
||
|
||
void hexagon_table_init(uint8* iyuv, uint16 ph, uint16 pw, double angle, uint16 retc_h, uint16* htable)
|
||
{
|
||
|
||
|
||
uint16 tri_h = (ph - retc_h)/2;
|
||
|
||
uint32 strih;
|
||
uint32 striw;
|
||
uint32 stril;
|
||
uint32 ucos = cos(angle/2)*1048576;
|
||
uint32 usin = sin(angle/2)*1048576;
|
||
|
||
|
||
|
||
//printf("srow %d erow %d img_row %d\r\n", s_row, e_row, img_row);
|
||
// for(row = s_row;row<e_row;row++,img_row++)
|
||
// {
|
||
uint32 htmp;
|
||
for(strih = 0;strih < tri_h+retc_h+tri_h;strih++)
|
||
{
|
||
htmp = strih;
|
||
if(strih < tri_h) {
|
||
stril = strih * 1048576 / ucos;
|
||
striw = stril * usin * 2 / 1048576;
|
||
//printf("striw %d\r\n", striw);
|
||
} else if(strih < tri_h+retc_h) {
|
||
striw = (pw);
|
||
//continue;
|
||
} else if(strih < tri_h+retc_h+tri_h) {
|
||
htmp = ph - htmp - 1;
|
||
stril = htmp *1048576 / ucos;
|
||
striw = stril * usin * 2 / 1048576;
|
||
}
|
||
htable[strih] = striw;
|
||
}
|
||
}
|
||
|
||
|
||
void put_img_hexagon2(uint8* iyuv, uint16 ph, uint16 pw, uint16* htable, uint16 retc_h,
|
||
uint8 *oyuv, int16 sh, int16 sw, uint16 oh, uint16 ow)
|
||
{
|
||
int16 s_row, s_col, e_row, e_col;
|
||
int16 row, col;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
|
||
|
||
uint32 strih;
|
||
uint32 striw;
|
||
|
||
volatile uint16 img_row = 0;
|
||
volatile uint16 img_col = 0;
|
||
|
||
iy = iyuv;
|
||
iu = &iyuv[ph*pw];
|
||
iv = &iyuv[ph*pw+ph*pw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
|
||
|
||
s_row = sh;
|
||
// e_row = s_row + tri_h;
|
||
e_row = s_row + ph;
|
||
if(s_row < 0) {
|
||
img_row = 0 - s_row;
|
||
s_row = 0;
|
||
}
|
||
if(e_row > oh) {
|
||
e_row = oh;
|
||
}
|
||
//printf("srow %d erow %d img_row %d\r\n", s_row, e_row, img_row);
|
||
for(row = s_row;row<e_row;row++,img_row++)
|
||
{
|
||
strih = row - sh;
|
||
striw = htable[strih];
|
||
s_col = sw + (pw/2) - (striw/2);
|
||
e_col = sw + (pw/2) + (striw/2);
|
||
img_col = s_col - sw;
|
||
if(s_col <0) {
|
||
img_col += 0 - (s_col);
|
||
s_col = 0;
|
||
}
|
||
if(e_col > ow) {
|
||
e_col = ow;
|
||
}
|
||
|
||
col = s_col;
|
||
|
||
// printf("%x %x %x %x\r\n", s_col, e_col, col, img_col);
|
||
//printf("s %d e %d row %d \r\n", s_col, e_col, row);
|
||
// if(s_col > e_col) {
|
||
// continue;
|
||
// }
|
||
//for(int16 col = s_col;col<e_col;col++,img_col++) {
|
||
//if(col > 20-1 && col <25-1 && row > 40-1 && row <51-1){
|
||
//oy[row*ow+col] = iy[(img_row)*(pw)+img_col];
|
||
//}
|
||
|
||
|
||
hw_memcpy(&oy[row*ow+col], &iy[(img_row)*(pw)+img_col], e_col-s_col);
|
||
if(!(row&1)) {
|
||
memcpy(&ou[(row/2)*(ow/2)+col/2], &iu[(img_row/2)*(pw/2)+img_col/2], (e_col-s_col)/2);
|
||
memcpy(&ov[(row/2)*(ow/2)+col/2], &iv[(img_row/2)*(pw/2)+img_col/2], (e_col-s_col)/2);
|
||
}
|
||
}
|
||
//printf("img_row %d\r\n", img_row);
|
||
}
|
||
|
||
void mov_img_hexagon(uint8* iyuv, uint16 ih, uint16 iw, int16 imy, int16 imx,
|
||
uint8 *oyuv, uint16 oh, uint16 ow, int16 omy, int16 omx,
|
||
uint16* htable, uint16 hag_h, uint16 hag_w)
|
||
{
|
||
int16 s_row, s_col, e_row, e_col;
|
||
int16 row, col;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
uint32 strih;
|
||
uint16 striw;
|
||
|
||
volatile uint16 img_row = 0;
|
||
volatile uint16 img_col = 0;
|
||
|
||
iy = iyuv;
|
||
iu = &iyuv[ih*iw];
|
||
iv = &iyuv[ih*iw+ih*iw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
|
||
|
||
s_row = omy;
|
||
// printf("%d\r\n",omy);
|
||
// e_row = s_row + tri_h;
|
||
e_row = s_row + hag_h;
|
||
if(s_row < 0) {
|
||
img_row = 0 - s_row;
|
||
s_row = 0;
|
||
}
|
||
if(e_row > oh) {
|
||
e_row = oh;
|
||
}
|
||
// printf("srow %d erow %d img_row %d\r\n", s_row, e_row, img_row);
|
||
// printf("%d %d\r\n", sw, pw);
|
||
for(row = s_row;row<e_row;row++,img_row++)
|
||
{
|
||
strih = row - omy;
|
||
// printf("strih %d \r\n", strih);
|
||
striw = htable[strih];
|
||
striw = striw & 0xfffc;
|
||
// printf("striw %d strih %d\r\n", striw, strih);
|
||
s_col = omx + (hag_w/2) - (striw/2);
|
||
e_col = omx + (hag_w/2) + (striw/2);
|
||
img_col = s_col - omx;
|
||
if(s_col <0) {
|
||
img_col += 0 - (s_col);
|
||
s_col = 0;
|
||
}
|
||
if(e_col > ow) {
|
||
e_col = ow;
|
||
}
|
||
|
||
col = s_col;
|
||
|
||
// printf("striw %d s %d e %d row %d \r\n", striw, s_col, e_col, row);
|
||
// if(s_col > e_col) {
|
||
// continue;
|
||
// }
|
||
//for(int16 col = s_col;col<e_col;col++,img_col++) {
|
||
//if(col > 20-1 && col <25-1 && row > 40-1 && row <51-1){
|
||
//oy[row*ow+col] = iy[(img_row)*(pw)+img_col];
|
||
//}
|
||
|
||
// memcpy(&oy[row*ow+col], &iy[(img_row)*(iw)+img_col], e_col-s_col);
|
||
// if(!(row&1)) {
|
||
// memcpy(&ou[(row/2)*(ow/2)+col/2], &iu[(img_row/2)*(iw/2)+img_col/2], (e_col-s_col)/2);
|
||
// memcpy(&ov[(row/2)*(ow/2)+col/2], &iv[(img_row/2)*(iw/2)+img_col/2], (e_col-s_col)/2);
|
||
// }
|
||
|
||
// line_mov(&iy[(img_row + imy)*(iw)+(img_col+imx)], &oy[row*ow+col], line_tmp, e_col-s_col);
|
||
// if(!(row&1)) {
|
||
// line_mov(&iu[((img_row+imy)/2)*(iw/2)+(img_col+imx)/2], &ou[(row/2)*(ow/2)+col/2], line_tmp, (e_col-s_col)/2);
|
||
// line_mov(&iv[((img_row+imy)/2)*(iw/2)+(img_col+imx)/2], &ov[(row/2)*(ow/2)+col/2], line_tmp, (e_col-s_col)/2);
|
||
// }
|
||
|
||
memcpy32((uint32)&oy[row*ow+col], (uint32)&iy[(img_row + imy)*(iw)+(img_col+imx)], e_col-s_col);
|
||
if(!(row&1)) {
|
||
memcpy32((uint32)&ou[(row/2)*(ow/2)+col/2], (uint32)&iu[((img_row+imy)/2)*(iw/2)+(img_col+imx)/2], (e_col-s_col)/2);
|
||
memcpy32((uint32)&ov[(row/2)*(ow/2)+col/2], (uint32)&iv[((img_row+imy)/2)*(iw/2)+(img_col+imx)/2], (e_col-s_col)/2);
|
||
}
|
||
|
||
}
|
||
//printf("img_row %d\r\n", img_row);
|
||
}
|
||
|
||
|
||
void sw_scaler_shrink_x(uint8* iyuv, uint16 ph, uint16 pw,
|
||
uint8 *oyuv, uint16 oh, uint16 ow)
|
||
{
|
||
|
||
uint16 row;
|
||
float col;
|
||
uint16 irow,icol;
|
||
uint16 orow,ocol;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
iy = iyuv;
|
||
iu = &iyuv[ph*pw];
|
||
iv = &iyuv[ph*pw+ph*pw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
// memset(ou, 128, oh*ow/4);
|
||
// memset(ov, 128, oh*ow/4);
|
||
float ih = (float)ph/(float)oh;
|
||
float iw = (float)pw/(float)ow;
|
||
printf("ih %f, iw %f\r\n", ih,iw);
|
||
for(row = 0,orow = 0;row<ph;row++,orow++)
|
||
{
|
||
irow = row;
|
||
for(col = 0,ocol=0;col<pw;col+=iw,ocol++) {
|
||
icol = col;
|
||
|
||
oy[orow*ow+ocol] = iy[irow*pw+icol];
|
||
}
|
||
|
||
if( !(row&1)) {
|
||
for(col = 0,ocol=0;col<(pw/2);col+=iw,ocol++) {
|
||
|
||
icol = col;
|
||
// if(irow > 155 && icol > 20)
|
||
// printf("o(%d,%d) i(%d,%d) (%f)\r\n", orow,ocol, irow,icol, col);
|
||
ov[(orow/2)*(ow/2)+ocol] = iv[(irow/2)*(pw/2)+icol];
|
||
ou[(orow/2)*(ow/2)+ocol] = iu[(irow/2)*(pw/2)+icol];
|
||
}
|
||
}
|
||
}
|
||
// printf("row : %f , col : %f\r\n", row , col);
|
||
// printf("orow : %f , ocol : %f", orow , ocol);
|
||
}
|
||
|
||
void sw_scaler_shrink1_x(uint8* iyuv, uint16 ph, uint16 pw,
|
||
uint8 *oyuv, uint16 oh, uint16 ow)
|
||
{
|
||
|
||
uint16 row;
|
||
uint16 col;
|
||
uint16 irow,icol;
|
||
uint16 orow,ocol;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
uint8 index = 0;
|
||
uint32 sum = 0;
|
||
uint8 tmp = pw-ow;
|
||
uint8 j_index[256];
|
||
os_memset(j_index, 1, 256);
|
||
|
||
iy = iyuv;
|
||
iu = &iyuv[ph*pw];
|
||
iv = &iyuv[ph*pw+ph*pw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
// memset(ou, 128, oh*ow/4);
|
||
// memset(ov, 128, oh*ow/4);
|
||
|
||
|
||
float f_index = (float)ow/(float)tmp;
|
||
for(float fcol = 0;fcol<ow;fcol+=f_index)
|
||
{
|
||
icol = fcol;
|
||
j_index[icol]++;
|
||
}
|
||
if(j_index[ow-1] == 2) {
|
||
j_index[ow-1] = 1;
|
||
}
|
||
for(index = 0;index<ow;index++)
|
||
{
|
||
sum += j_index[index];
|
||
// printf("%d ", j_index[index]);
|
||
}
|
||
// printf("\r\nsum %d \r\n",sum);
|
||
// printf("ih %f, iw %f\r\n", ih,iw);
|
||
for(row = 0,orow = 0;row<ph;row++,orow++)
|
||
{
|
||
index = 0;
|
||
irow = row;
|
||
for(col = 0,ocol=0;col<pw;col+=j_index[index++],ocol++) {
|
||
icol = col;
|
||
// printf("o(%d,%d) i(%d,%d) (%f)\r\n", orow,ocol, irow,icol, col);
|
||
oy[orow*ow+ocol] = iy[irow*pw+icol];
|
||
}
|
||
index = 0;
|
||
if( !(row&1)) {
|
||
for(col = 0,ocol=0;col<(pw/2);col+=(j_index[index++]),ocol++) {
|
||
icol = col;
|
||
// if(irow > 155 && icol > 20)
|
||
// printf("o(%d,%d) i(%d,%d) (%d)\r\n", orow,ocol, irow,icol, col);
|
||
ov[(orow/2)*(ow/2)+(ocol)] = iv[(irow/2)*(pw/2)+(icol)];
|
||
ou[(orow/2)*(ow/2)+(ocol)] = iu[(irow/2)*(pw/2)+(icol)];
|
||
}
|
||
}
|
||
}
|
||
// printf("row : %f , col : %f\r\n", row , col);
|
||
// printf("orow : %f , ocol : %f", orow , ocol);
|
||
}
|
||
|
||
void sw_line_shrink(uint8* iyuv, uint16 pw, uint8* oyuv, uint16 ow, uint8 *s_tmp)
|
||
{
|
||
if(ow == 0){
|
||
return;
|
||
}
|
||
uint32 jp1 = pw/ow;
|
||
|
||
uint32 n2 = pw-(ow*jp1);
|
||
|
||
|
||
memset(s_tmp, jp1, ow);
|
||
// s_tmp[0] = jp1-1;
|
||
// printf("iw %d , ow %d\r\n", pw, ow);
|
||
// printf("n1 : %d , n2: %d\r\n", n1,n2);
|
||
// printf(" n1 + n2 = %d\r\n", n1+n2);
|
||
// printf(" n1*j1 + n2*j2 = %d\r\n",n1*jp1+n2*jp2);
|
||
if(n2 == 0) {
|
||
;
|
||
} else {
|
||
float f_i = (float)ow/(float)n2;
|
||
uint32 int_i = f_i*1024*512;
|
||
for(;int_i<ow*1024*512;int_i+=f_i*1024*512)
|
||
// for(;f_i < ow;f_i+=(float)ow/(float)n2)
|
||
{
|
||
s_tmp[(int_i)/1024/512]++;
|
||
// s_tmp[(uint32)f_i]++;
|
||
}
|
||
}
|
||
|
||
|
||
// test
|
||
// uint32 sum = 0;
|
||
// for(uint32 i = 0;i<ow;i++)
|
||
// {
|
||
// printf("%d ", s_tmp[i]);
|
||
// sum += s_tmp[i];
|
||
// }
|
||
// printf("\r\nsum:%d\r\n", sum);
|
||
|
||
uint32 iindex = 0;
|
||
for(uint32 i = 0;i<ow;i++)
|
||
{
|
||
|
||
oyuv[i] = iyuv[iindex];
|
||
iindex += s_tmp[i];
|
||
}
|
||
|
||
}
|
||
|
||
void sw_scaler_shrink2_x(uint8* iyuv, uint16 ph, uint16 pw,
|
||
uint8 *oyuv, uint16 oh, uint16 ow)
|
||
{
|
||
|
||
uint16 row;
|
||
|
||
|
||
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
|
||
|
||
uint8 temp[256];
|
||
|
||
iy = iyuv;
|
||
iu = &iyuv[ph*pw];
|
||
iv = &iyuv[ph*pw+ph*pw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
|
||
for(row = 0;row<ph;row++)
|
||
{
|
||
sw_line_shrink(&iy[row*pw], pw, &oy[row*ow], ow, temp);
|
||
}
|
||
|
||
for(row = 0;row<ph/2;row++)
|
||
{
|
||
sw_line_shrink(&iu[row*(pw/2)], pw/2, &ou[row*ow/2], ow/2, temp);
|
||
sw_line_shrink(&iv[row*(pw/2)], pw/2, &ov[row*ow/2], ow/2, temp);
|
||
}
|
||
// printf("row : %f , col : %f\r\n", row , col);
|
||
// printf("orow : %f , ocol : %f", orow , ocol);
|
||
}
|
||
|
||
//leanar fill
|
||
void sw_y_fill_x(uint8* y1, uint8* y2, uint32 cnt)
|
||
{
|
||
uint32 index = 0;
|
||
int32 nval;
|
||
float k = ( *(y2+1) - *(y2) ) / cnt;
|
||
y1[0] = y2[0];
|
||
while(cnt)
|
||
{
|
||
nval = y1[index] + (int8)k;
|
||
if(nval > 255) {
|
||
y1[index+1] = 255;
|
||
} else if(nval < 0){
|
||
y1[index+1] = 0;
|
||
} else {
|
||
y1[index+1] = nval;
|
||
}
|
||
index++;
|
||
cnt--;
|
||
k +=k;
|
||
//printf("%d ",cnt);
|
||
}
|
||
}
|
||
//
|
||
void sw_uv_fill_x(uint8* uv1, uint8* uv2, uint32 cnt)
|
||
{
|
||
uint32 index = 0;
|
||
int32 nval;
|
||
// cnt = cnt/2;
|
||
float k = (*(uv2+1) - *(uv2)) / cnt;
|
||
uv1[0] = uv2[0];
|
||
while(cnt)
|
||
{
|
||
nval = uv1[index] + (int8)k;
|
||
if(nval > 255) {
|
||
uv1[index+1] = 255;
|
||
} else if(nval < 0){
|
||
uv1[index+1] = 0;
|
||
} else {
|
||
uv1[index+1] = nval;
|
||
}
|
||
index++;
|
||
cnt--;
|
||
k +=k;
|
||
}
|
||
}
|
||
|
||
void sw_scaler_enlarge_x(uint8* iyuv, uint16 ph, uint16 pw,uint16 rn, uint16 cn,
|
||
uint8 *oyuv, uint16 oh, uint16 ow)
|
||
{
|
||
|
||
uint16 row, col;
|
||
uint16 icol;
|
||
uint16 orow,ocol;
|
||
uint16 cnt;
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
if(cn&1) {
|
||
ow = (cn+1)*pw;
|
||
} else {
|
||
ow = (pw-1)*cn+pw;
|
||
}
|
||
ow = (cn+1)*pw;
|
||
iy = iyuv;
|
||
iu = &iyuv[ph*pw];
|
||
iv = &iyuv[ph*pw+ph*pw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
// memset(ou, 128, oh*ow/4);
|
||
// memset(ov, 128, oh*ow/4);
|
||
printf("----ow : %d\r\n", ow);
|
||
for(row = 0,orow = 0;row<ph;row++,orow++)
|
||
{
|
||
for(col = 0,ocol = 0,cnt = 0;col<pw;col++,ocol++) {
|
||
// oy[orow*ow+(ocol+cnt)] = iy[row*pw+col];
|
||
// if(row < 30 && col < 20)
|
||
// printf("o(%d,%d) i(%d,%d)\r\n", orow,ocol, row,col);
|
||
sw_y_fill_x(&oy[orow*ow+(ocol)], &iy[row*pw+col], cn);
|
||
ocol+= cn;
|
||
}
|
||
|
||
if( !(row&1)) {
|
||
for(col = 0,ocol=0;col<(pw/2);col++,ocol++) {
|
||
icol = col;
|
||
sw_uv_fill_x(&ou[(orow/2)*(ow/2)+ocol], &iu[(row/2)*(pw/2)+icol], cn);
|
||
sw_uv_fill_x(&ov[(orow/2)*(ow/2)+ocol], &iv[(row/2)*(pw/2)+icol], cn);
|
||
ocol+= cn;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void sw_interpolt_1(uint8* v1, uint8* v2, uint32 cnt)
|
||
{
|
||
uint32 index = 0;
|
||
// cnt = cnt/2;
|
||
v1[0] = v2[0];
|
||
while(cnt)
|
||
{
|
||
v1[index+1] = v1[index];
|
||
index++;
|
||
cnt--;
|
||
}
|
||
}
|
||
|
||
void sw_interpolt_2(uint8* v1, uint8* v2, uint32 cnt)
|
||
{
|
||
uint32 index = 0;
|
||
// cnt = cnt/2;
|
||
|
||
int8 k = (*(v2+1) - *(v2)) / (cnt+3);
|
||
v1[0] = v2[0];
|
||
while(cnt)
|
||
{
|
||
// nval = v1[index] + k;
|
||
// if(nval < 0) {
|
||
// v1[index+1] = 0;
|
||
// } else if(nval > 255) {
|
||
// v1[index+1] = 255;
|
||
// } else {
|
||
// v1[index+1] = nval;
|
||
// }
|
||
v1[index+1] = v1[index] + k;
|
||
index++;
|
||
cnt--;
|
||
k +=k;
|
||
}
|
||
}
|
||
|
||
void sw_line_expend(uint8* iyuv, uint16 pw, uint8* oyuv, uint16 ow, uint8 *s_tmp)
|
||
{
|
||
uint32 i1 = ow/pw;
|
||
uint32 i2 = ow/pw-1;
|
||
uint32 n1 = ow - (i1*pw);
|
||
|
||
|
||
memset(s_tmp, i2, pw);
|
||
// s_tmp[0] = i1-1;
|
||
// printf("n1 : %d , n2: %d\r\n", n1,n2);
|
||
// printf(" n1 + n2 = %d\r\n", n1+n2);
|
||
// printf(" n1*i1 + n2*i2 = %d\r\n",n1*i1+n2*i2);
|
||
if(n1 == 0) {
|
||
;
|
||
} else {
|
||
double f_i = (float)pw/(float)n1;
|
||
uint32 int_i = f_i*1024*512;
|
||
for(;int_i<pw*1024*512;int_i+=f_i*1024*512)
|
||
// for(;f_i < ow;f_i+=(float)ow/(float)n2)
|
||
{
|
||
s_tmp[(int_i)/1024/512]++;
|
||
// s_tmp[(uint32)f_i]++;
|
||
}
|
||
}
|
||
|
||
// test
|
||
// uint32 sum = pw;
|
||
// for(uint32 i = 0;i<ow;i++)
|
||
// {
|
||
// printf("%d ", s_tmp[i]);
|
||
// sum += s_tmp[i];
|
||
// }
|
||
// printf("\r\nsum:%d\r\n", sum);
|
||
|
||
uint32 oindex = 0;
|
||
for(uint32 i = 0;i<pw;i++)
|
||
{
|
||
sw_interpolt_2(&oyuv[oindex], &iyuv[i], s_tmp[i]);
|
||
oindex += (s_tmp[i]+1);
|
||
}
|
||
|
||
}
|
||
|
||
void sw_img_trans(uint8* iyuv, uint16 ph, uint16 pw,
|
||
uint8 *oyuv, uint16 oh, uint16 ow)
|
||
{
|
||
|
||
uint16 row;
|
||
|
||
|
||
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
|
||
|
||
uint8 temp[512];
|
||
|
||
iy = iyuv;
|
||
iu = &iyuv[ph*pw];
|
||
iv = &iyuv[ph*pw+ph*pw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
uint32 b = pw/4;
|
||
uint32 a = pw/8*3;
|
||
uint32 step = 10;
|
||
// sw_line_shrink(&iy[row*pw], 160, &oy[row*ow], 156, temp);
|
||
for(row = 120;row<ph;row++)
|
||
{
|
||
sw_line_shrink(&iy[row*pw], a, &oy[row*ow], a-step, temp);
|
||
sw_line_expend(&iy[row*pw+a], b, &oy[row*ow+a-step], b+2*step, temp);
|
||
sw_line_shrink(&iy[row*pw+a+b], a, &oy[row*ow+a-step+b+2*step], a-step, temp);
|
||
if(row % 10 == 0)
|
||
{
|
||
b += 2*step;
|
||
a -= step;
|
||
}
|
||
|
||
if(b == pw || a== 0)
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
printf("row %d\r\n", row);
|
||
// for(row = 0;row<ph/2;row++)
|
||
// {
|
||
// sw_line_expend(&iu[row*(pw/2)], pw/2, &ou[row*ow/2], ow/2, temp);
|
||
// sw_line_expend(&iv[row*(pw/2)], pw/2, &ov[row*ow/2], ow/2, temp);
|
||
// }
|
||
}
|
||
|
||
void sw_scaler_enlarge1_x(uint8* iyuv, uint16 ph, uint16 pw,
|
||
uint8 *oyuv, uint16 oh, uint16 ow)
|
||
{
|
||
|
||
uint16 row;
|
||
|
||
|
||
|
||
uint8 *iy, *iu, *iv;
|
||
uint8 *oy, *ou, *ov;
|
||
|
||
|
||
|
||
uint8 temp[512];
|
||
|
||
iy = iyuv;
|
||
iu = &iyuv[ph*pw];
|
||
iv = &iyuv[ph*pw+ph*pw/4];
|
||
oy = oyuv;
|
||
ou = &oyuv[oh*ow];
|
||
ov = &oyuv[oh*ow + oh*ow/4];
|
||
|
||
for(row = 0;row<ph;row++)
|
||
{
|
||
sw_line_expend(&iy[row*pw], pw, &oy[row*ow], ow, temp);
|
||
}
|
||
|
||
for(row = 0;row<ph/2;row++)
|
||
{
|
||
sw_line_expend(&iu[row*(pw/2)], pw/2, &ou[row*ow/2], ow/2, temp);
|
||
sw_line_expend(&iv[row*(pw/2)], pw/2, &ov[row*ow/2], ow/2, temp);
|
||
}
|
||
}
|
||
|
||
|
||
inline void data_recfg(int s_i,int s_j,int d_i,int d_j,int s_w,char *sbuf,int cfg_type){
|
||
int *sbuf_32;
|
||
|
||
sbuf_32 = (int *)sbuf;
|
||
if(cfg_type == 1) //2*2
|
||
{
|
||
//s_w = s_w*4;
|
||
sbuf_32[s_i+4*s_w*s_j] = sbuf_32[d_i+4*s_w*d_j];
|
||
sbuf_32[(s_i+4*s_w*s_j+s_w)] = sbuf_32[d_i+4*s_w*d_j+s_w];
|
||
sbuf_32[(s_i+4*s_w*s_j+2*s_w)] = sbuf_32[d_i+4*s_w*d_j+2*s_w];
|
||
sbuf_32[(s_i+4*s_w*s_j+3*s_w)] = sbuf_32[d_i+4*s_w*d_j+3*s_w];
|
||
}
|
||
else if(cfg_type == 2) //2*1
|
||
{
|
||
sbuf_32[s_i+4*s_w*s_j] = sbuf_32[d_i+4*s_w*d_j];
|
||
sbuf_32[(s_i+4*s_w*s_j+s_w)] = sbuf_32[d_i+4*s_w*d_j+s_w];
|
||
}
|
||
else if(cfg_type == 3) //1*1
|
||
{
|
||
sbuf[s_i+s_w*s_j] = sbuf[d_i+s_w*d_j];
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
void reduce_and_reflash(int s_w,int s_h,char *sbuf,int mode_type,int buf_type){
|
||
int cache_w,cache_h;
|
||
int reduce_w,reduce_h;
|
||
int x_size;
|
||
int h_log = 0;
|
||
int i ,j;
|
||
int mode = mode_type;
|
||
int shift_x = 0,shift_y = 0;
|
||
int log = 0;
|
||
cache_w = s_w / 3; //ƽ������
|
||
x_size = (cache_w+1)/2; //���ȵ�һ��
|
||
cache_h = 3*x_size - 2;
|
||
|
||
reduce_w = s_w / 2 - 1; //mid_w
|
||
reduce_h = (s_h - cache_h)/2 - 1; //start_top
|
||
|
||
h_log = x_size;
|
||
|
||
|
||
while(mode)
|
||
{
|
||
switch(mode){
|
||
case 3:
|
||
shift_x = x_size*-1;
|
||
shift_y = -1 *(2*x_size );
|
||
break;
|
||
|
||
case 4:
|
||
shift_x = x_size*1;
|
||
shift_y = -1 *(2*x_size );
|
||
break;
|
||
|
||
case 2:
|
||
shift_x = x_size*1;
|
||
shift_y = (2*(x_size - 1)) /*+ x_size*/-3;
|
||
break;
|
||
|
||
case 1:
|
||
shift_x = x_size*-1;
|
||
shift_y = (2*(x_size - 1)) /*+ x_size*/-3;
|
||
break;
|
||
|
||
case 6:
|
||
shift_x = 2*x_size*-1;
|
||
shift_y = 0;
|
||
break;
|
||
|
||
case 5:
|
||
shift_x = 2*x_size;
|
||
shift_y = 0;
|
||
break;
|
||
|
||
case 0:
|
||
|
||
return;
|
||
|
||
}
|
||
|
||
|
||
|
||
mode --;
|
||
//printf("shift_x:%d shift_y:%d s_h:%d\n",shift_x,shift_y,s_h);
|
||
|
||
log = 1;
|
||
for(j = 0;j < h_log+1;j++){
|
||
//printf("\r\n\r\n\r\n\r\n");
|
||
//printf("log:%d %d\n",log,reduce_h + shift_y + j);
|
||
for(i = 0;i < log;i++)
|
||
{
|
||
if(reduce_h + shift_y + j >= 0)
|
||
{
|
||
data_recfg((reduce_w + shift_x + i -j),(j+reduce_h+shift_y),(reduce_w + i-j),(j+reduce_h),s_w,sbuf,buf_type);
|
||
}
|
||
|
||
}
|
||
log = log+2;
|
||
}
|
||
|
||
|
||
for(j = 0;j < h_log-1;j++){
|
||
//printf("\r\n\r\n\r\n\r\n");
|
||
for(i = 0;i < h_log*2+1;i++)
|
||
{
|
||
if((reduce_h + shift_y + j + h_log +1>= 0) &&(reduce_h + shift_y + j + h_log +1< s_h))
|
||
{
|
||
data_recfg((reduce_w - h_log + shift_x + i),(j+reduce_h+shift_y + h_log+1),(reduce_w - h_log + i),(j+reduce_h + h_log+1),s_w,sbuf,buf_type);
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
log = h_log*2+1;
|
||
for(j = 0;j < h_log+1;j++){
|
||
//printf("\r\n\r\n\r\n\r\n");
|
||
//printf("reduce_h:%d shift_y:%d s_h:%d\n",reduce_h,shift_y,s_h);
|
||
for(i = 0;i < log;i++)
|
||
{
|
||
if(reduce_h + shift_y + j + 2*h_log< s_h)
|
||
{
|
||
data_recfg((reduce_w - h_log + shift_x + i +j),(j+reduce_h+shift_y + 2*h_log),(reduce_w - h_log + i+j),(j+reduce_h+2*h_log),s_w,sbuf,buf_type);
|
||
}
|
||
}
|
||
log = log-2;
|
||
}
|
||
|
||
|
||
}
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
uint16 *ve_htable;
|
||
void hexagon_ve(uint8* in, uint8* tem, uint32 w, uint32 h)
|
||
{
|
||
|
||
static uint8_t flag = 0;
|
||
get_img_retc(in, h, w, 120-60, 160-60, tem, 160, 140);
|
||
// get_img_retc_blkcpy(in, h, w, 0-80+120, 20+70, tem, 160, 140);
|
||
// csi_dcache_invalid_range(in, w*h+w*h/2);
|
||
if(flag == 0){
|
||
flag = 1;
|
||
ve_htable = os_malloc(2*h);
|
||
hexagon_table_init(in, 160, 140, 3.1415*2/3+0.04, 80, ve_htable);
|
||
}
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80, 20, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80, 20+140, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120, 20-70, 240, 320);
|
||
// // put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120, 20+70, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120, 20+140+70, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120+120, 20, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120+120, 20+140, 240, 320);
|
||
|
||
|
||
put_img_hexagon2(tem, 160, 140, ve_htable, 80, in, 0-80, 20, 240, 320);
|
||
put_img_hexagon2(tem, 160, 140, ve_htable, 80, in, 0-80, 20+140, 240, 320);
|
||
put_img_hexagon2(tem, 160, 140, ve_htable, 80, in, 0-80+120, 20-70, 240, 320);
|
||
// put_img_hexagon2(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120, 20+70, 240, 320);
|
||
put_img_hexagon2(tem, 160, 140, ve_htable, 80, in, 0-80+120, 20+140+70, 240, 320);
|
||
put_img_hexagon2(tem, 160, 140, ve_htable, 80, in, 0-80+120+120, 20, 240, 320);
|
||
put_img_hexagon2(tem, 160, 140, ve_htable, 80, in, 0-80+120+120, 20+140, 240, 320);
|
||
|
||
csi_dcache_clean_range((uint32_t*)in, w*h+w*h/2);
|
||
}
|
||
|
||
void hexagon_ve1(uint8* in, uint8* tem, uint32 w, uint32 h)
|
||
{
|
||
|
||
static uint8_t flag = 0;
|
||
// get_img_retc(in, h, w, 100, 100, tem, 160*2, 140*2);
|
||
// get_img_retc_blkcpy(in, h, w, 0-80+120, 20+70, tem, 160, 140);
|
||
if(flag == 0){
|
||
flag = 1;
|
||
ve_htable = os_malloc(h*2);
|
||
hexagon_table_init(in, 160, 140, 3.1415*2/3+0.04, 80, ve_htable);
|
||
}
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80, 20, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80, 20+140, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120, 20-70, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120, 20+140+70, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120+120, 20, 240, 320);
|
||
// put_img_hexagon1(tem, 160, 140, 3.1415*2/3+0.04, 80, in, 0-80+120+120, 20+140, 240, 320);
|
||
|
||
mov_img_hexagon(in, h, w, 60, 100, in, h, w, 0-80, 20, ve_htable, 160, 140);
|
||
mov_img_hexagon(in, h, w, 60, 100, in, h, w, 0-80, 20+140, ve_htable, 160, 140);
|
||
mov_img_hexagon(in, h, w, 60, 100, in, h, w, 0-80+120, 20-70, ve_htable, 160, 140);
|
||
mov_img_hexagon(in, h, w, 60, 100, in, h, w, 0-80+120, 20+140+70, ve_htable, 160, 140);
|
||
mov_img_hexagon(in, h, w, 60, 100, in, h, w, 0-80+120+120, 20, ve_htable, 160, 140);
|
||
mov_img_hexagon(in, h, w, 60, 100, in, h, w, 0-80+120+120, 20+140, ve_htable, 160, 140);
|
||
|
||
|
||
// mov_img_hexagon(in, h, w, 100, 100, in, 240, 320, 0-160, 40, ve_htable, 160*2, 140*2);
|
||
// mov_img_hexagon(in, h, w, 100, 100, in, 240, 320, 0-160, 40+280, ve_htable, 160*2, 140*2);
|
||
// mov_img_hexagon(in, h, w, 100, 100, in, 240, 320, 0-160+240, 40-140, ve_htable, 160*2, 140*2);
|
||
// mov_img_hexagon(in, h, w, 100, 100, in, 240, 320, 0-160+240, 40+140+280, ve_htable, 160*2, 140*2);
|
||
// mov_img_hexagon(in, h, w, 100, 100, in, 240, 320, 0-160+240+240, 40, ve_htable, 160*2, 140*2);
|
||
// mov_img_hexagon(in, h, w, 100, 100, in, 240, 320, 0-160+240+240, 40+280, ve_htable, 160*2, 140*2);
|
||
csi_dcache_clean_range((uint32_t*)in, w*h+w*h/2);
|
||
csi_dcache_invalid_range((uint32_t*)in, w*h+w*h/2);
|
||
}
|
||
|
||
void hexagon_ve2(uint8* in, uint8* tem, uint32 w, uint32 h)
|
||
{
|
||
reduce_and_reflash(80,240/2,(char *)in, 6,2); //640*480 ====> 160 * 120
|
||
// reduce_and_reflash(40,120/2,in+320*240, 6,2);
|
||
// reduce_and_reflash(40,120/2,in+320*240+320*240/4, 6,2);
|
||
memset(in+320*240, 128, 320*240/4);
|
||
memset(in+320*240+320*240/4, 128, 320*240/4);
|
||
// csi_dcache_clean_range(in, w*h+w*h/2);
|
||
// csi_dcache_invalid_range(in, w*h+w*h/2);
|
||
}
|
||
|
||
|
||
void block_9(uint8* in, uint8* tem, uint32 w, uint32 h)
|
||
{
|
||
// // get_img_retc(in, h, w, 120-60, 160-60, tem, 80, 108);
|
||
// get_img_retc(in, h, w, 0, 0, tem, 80, 108);
|
||
// csi_dcache_invalid_range(in, w*h+w*h/2);
|
||
// // put_img_retc(tem, 80, 108, in, 0, 0, 240, 320);
|
||
// put_img_retc(tem, 80, 108, in, 0, 108, 240, 320);
|
||
// put_img_retc(tem, 80, 108, in, 0, 108+108, 240, 320);
|
||
|
||
|
||
// put_img_retc(tem, 80, 108, in, 80, 0, 240, 320);
|
||
// put_img_retc(tem, 80, 108, in, 80, 108, 240, 320);
|
||
// put_img_retc(tem, 80, 108, in, 80, 108+108, 240, 320);
|
||
|
||
// put_img_retc(tem, 80, 108, in, 160, 0, 240, 320);
|
||
// put_img_retc(tem, 80, 108, in, 160, 108, 240, 320);
|
||
// put_img_retc(tem, 80, 108, in, 160, 108+108, 240, 320);
|
||
// csi_dcache_clean_range(in, w*h+w*h/2);
|
||
|
||
uint32 w1 = 0,w2 = 0,w3 = 0;
|
||
if( w == 320) {
|
||
w1 = 100;
|
||
w2 = 120;
|
||
w3 = 100;
|
||
} else if(w ==640){
|
||
w1 = 200;
|
||
w2 = 240;
|
||
w3 = 200;
|
||
}
|
||
mov_img_retc(in, h, w, h/3, w2,
|
||
in, h, w, h/3, 0,
|
||
h/3, w1);
|
||
mov_img_retc(in, h, w, h/3, w2,
|
||
in, h, w, h/3, w1+w2,
|
||
h/3, w3);
|
||
mov_img_retc(in, h, w, h/3, w,
|
||
in, h, w, 0, 0,
|
||
h/3, w);
|
||
mov_img_retc(in, h, w, h/3, w,
|
||
in, h, w, 2*h/3, 0,
|
||
h/3, w );
|
||
|
||
csi_dcache_clean_range((uint32_t*)in, w*h+w*h/2);
|
||
csi_dcache_invalid_range((uint32_t*)in, w*h+w*h/2);
|
||
}
|
||
|
||
void block_4(uint8* in, uint8* tem, uint32 w, uint32 h)
|
||
{
|
||
// // get_img_retc(in, h, w, 120-60, 160-60, tem, 120, 160);
|
||
// get_img_retc(in, h, w, 0, 0, tem, 120, 160);
|
||
// csi_dcache_invalid_range(in, w*h+w*h/2);
|
||
// // put_img_retc(tem, 120, 160, in, 0, 0, 240, 320);
|
||
// put_img_retc(tem, 120, 160, in, 120, 160, 240, 320);
|
||
// put_img_retc(tem, 120, 160, in, 0, 160, 240, 320);
|
||
// put_img_retc(tem, 120, 160, in, 120, 0, 240, 320);
|
||
// csi_dcache_clean_range(in, w*h+w*h/2);
|
||
mov_img_retc(in, h, w, 0, 0,
|
||
in, h, w, 0, w/2, h/2, w/2);
|
||
mov_img_retc(in, h, w, 0, 0,
|
||
in, h, w, h/2, 0, h/2, w);
|
||
// csi_dcache_clean_range(in, w*h+w*h/2);
|
||
// csi_dcache_invalid_range(in, w*h+w*h/2);
|
||
}
|
||
|
||
void block_2_yinv(uint8* in, uint8* tem, uint32 w, uint32 h)
|
||
{
|
||
// get_img_retc(in, h, w, 0, 0, tem, 120, 320);
|
||
// csi_dcache_invalid_range(in, w*h+w*h/2);
|
||
// //put_img_retc(tem, 120, 320, in, 0, 0, 240, 320);
|
||
// put_img_retc_iy(tem, 120, 320, in, 120, 0, 240, 320);
|
||
// csi_dcache_clean_range(in, w*h+w*h/2);
|
||
|
||
mov_img_retc_iy(in, h, w, h/2, 0,
|
||
in, h, w, 0, 0,
|
||
h/2, w);
|
||
csi_dcache_clean_range((uint32_t*)in, w*h+w*h/2);
|
||
csi_dcache_invalid_range((uint32_t*)in, w*h+w*h/2);
|
||
}
|
||
|
||
void block_2_xinv(uint8* in, uint8* tem, uint32 w, uint32 h)
|
||
{
|
||
// get_img_retc_blkcpy(in, h, w, 0, 0, tem, 240, 160);
|
||
// get_img_retc(in, h, w, 0, 0, tem, 240, 160);
|
||
|
||
// csi_dcache_invalid_range(tem, 160*h+160*h/2);
|
||
// put_img_retc(tem, 240, 160, in, 0, 0, 240, 320);
|
||
mov_img_retc_ix(in, h, w, 0, 0, in, h, w, 0, w/2, h, w/2);
|
||
|
||
csi_dcache_clean_range((uint32_t*)in, w*h+w*h/2);
|
||
csi_dcache_invalid_range((uint32_t*)in, w*h+w*h/2);
|
||
}
|
||
|
||
// void uv_offset(uint8* in, uint8* tmp, uint32 w, uint32 h, int32 uoff, int32 voff)
|
||
// {
|
||
// uint16 s_row, s_col, e_row, e_col;
|
||
// uint16 row, col;
|
||
// uint16 i,j;
|
||
// uint32 uv_len = h*w/4;
|
||
// uint32 w_len;
|
||
// uint16 img_row,img_col;
|
||
// uint8 *iy,*iu,*iv;
|
||
// iy = in;
|
||
// iu = &iy[h*w];
|
||
// iv = &iu[h*w/4];
|
||
// uint8* line_tmp = os_malloc(128);
|
||
// if(line_tmp == NULL) {
|
||
// os_printf("ve_malloc fail\r\n");
|
||
// }
|
||
|
||
// if(uoff != 0) {
|
||
// while(uv_len > 0)
|
||
// {
|
||
// w_len = uv_len > 128 ? 128 : uv_len;
|
||
// hw_memcpy(line_tmp, iu, w_len);
|
||
// for(j = 0;j<w_len;j++) {
|
||
// if(line_tmp[j] +uoff > 255) {
|
||
// line_tmp[j] = 255;
|
||
// } else if(line_tmp[j] +uoff <0) {
|
||
// line_tmp[j] = 0;
|
||
// } else {
|
||
// line_tmp[j] += uoff;
|
||
// }
|
||
// }
|
||
// hw_memcpy(iu, line_tmp, w_len);
|
||
// uv_len -= w_len;
|
||
// iu += w_len;
|
||
// }
|
||
// csi_dcache_clean_range(iu, w*h/4);
|
||
// csi_dcache_invalid_range(iu, w*h/4);
|
||
// }
|
||
// uv_len = h*w/4;
|
||
|
||
// if(voff != 0) {
|
||
// while(uv_len > 0)
|
||
// {
|
||
// w_len = uv_len > 128 ? 128 : uv_len;
|
||
// hw_memcpy(line_tmp, iv, w_len);
|
||
// for(j = 0;j<w_len;j++) {
|
||
// if(line_tmp[j] +voff > 255) {
|
||
// line_tmp[j] = 255;
|
||
// } else if(line_tmp[j] +voff <0) {
|
||
// line_tmp[j] = 0;
|
||
// } else {
|
||
// line_tmp[j] += voff;
|
||
// }
|
||
// }
|
||
// hw_memcpy(iv, line_tmp, w_len);
|
||
// uv_len -= w_len;
|
||
// iv += w_len;
|
||
// }
|
||
// csi_dcache_clean_range(iv, w*h/4);
|
||
// csi_dcache_invalid_range(iv, w*h/4);
|
||
// }
|
||
// os_free(line_tmp);
|
||
// }
|
||
|
||
void uv_offset(uint8* in, uint8* tmp, uint32 w, uint32 h, int32 uoff, int32 voff)
|
||
{
|
||
|
||
|
||
int32 val;
|
||
uint32 j;
|
||
uint32 uv_len = h*w/4;
|
||
|
||
|
||
uint8 *iy,*iu,*iv;
|
||
iy = in;
|
||
iu = &iy[h*w];
|
||
iv = &iu[h*w/4];
|
||
|
||
|
||
if(uoff != 0) {
|
||
j = 0;
|
||
while(uv_len > 0)
|
||
{
|
||
val = iu[j] + uoff;
|
||
if(val > 255) {
|
||
iu[j] = 255;
|
||
} else if(val <0) {
|
||
iu[j] = 0;
|
||
} else {
|
||
iu[j] = val;
|
||
}
|
||
uv_len--;
|
||
j++;
|
||
}
|
||
}
|
||
|
||
|
||
uv_len = h*w/4;
|
||
if(voff != 0) {
|
||
j = 0;
|
||
while(uv_len > 0)
|
||
{
|
||
val = iv[j] + voff;
|
||
if(val > 255) {
|
||
iv[j] = 255;
|
||
} else if(val <0) {
|
||
iv[j] = 0;
|
||
} else {
|
||
iv[j] = val;
|
||
}
|
||
uv_len--;
|
||
j++;
|
||
}
|
||
|
||
}
|
||
csi_dcache_clean_range((uint32_t*)iu, w*h/2);
|
||
csi_dcache_invalid_range((uint32_t*)iu, w*h/2);
|
||
|
||
}
|
||
|
||
void ve_gray_img(uint8* in, uint8* tmp, uint32 w, uint32 h)
|
||
{
|
||
|
||
|
||
|
||
uint32 j;
|
||
uint32 uv_len = h*w/4;
|
||
|
||
|
||
volatile uint8 *iy,*iu,*iv;
|
||
iy = in;
|
||
iu = &iy[h*w];
|
||
iv = &iu[h*w/4];
|
||
|
||
|
||
j = 0;
|
||
while(uv_len > 0)
|
||
{
|
||
iu[j] = 128;
|
||
uv_len--;
|
||
j++;
|
||
}
|
||
|
||
uv_len = h*w/4;
|
||
j = 0;
|
||
while(uv_len > 0)
|
||
{
|
||
iv[j] = 128;
|
||
uv_len--;
|
||
j++;
|
||
}
|
||
|
||
csi_dcache_clean_range((uint32_t*)iu, w*h/2);
|
||
csi_dcache_invalid_range((uint32_t*)iu, w*h/2);
|
||
}
|
||
|
||
void vf_switch(uint32 sw)
|
||
{
|
||
g_vf_cblk.desp.open = sw;
|
||
}
|
||
|
||
void vf_set_addr(uint32 src, uint32 dst)
|
||
{
|
||
g_vf_cblk.p_src = src;
|
||
g_vf_cblk.p_dst = dst;
|
||
}
|
||
|