1014 lines
32 KiB
C
1014 lines
32 KiB
C
/*
|
|
* Copyright (c) XMEDIA. All rights reserved.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
|
|
#include "common.h"
|
|
#include "xmedia_vb.h"
|
|
#include "xmedia_sys.h"
|
|
#include "xmedia_vi.h"
|
|
#include "xmedia_vo.h"
|
|
#include "xmedia_vgs.h"
|
|
|
|
#include "sample_comm_ive.h"
|
|
|
|
static xmedia_bool g_b_mpi_init = XMEDIA_FALSE;
|
|
|
|
xmedia_s32 sample_ive_sys_mmz_alloc(xmedia_u64 *pu64_phy_addr,
|
|
xmedia_void **pp_vir_addr,
|
|
const xmedia_char *str_mmb,
|
|
const xmedia_char *str_zone,
|
|
xmedia_u32 u32_len)
|
|
{
|
|
*pu64_phy_addr = xmedia_mmz_alloc(str_zone, str_mmb, u32_len);
|
|
if (*pu64_phy_addr == 0) {
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
*pp_vir_addr = xmedia_mmz_map(*pu64_phy_addr, u32_len, 0);
|
|
if (*pp_vir_addr == NULL) {
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
xmedia_s32 sample_ive_sys_mmz_alloc_cached(xmedia_u64 *pu64_phy_addr,
|
|
xmedia_void **pp_vir_addr,
|
|
const xmedia_char *str_mmb,
|
|
const xmedia_char *str_zone,
|
|
xmedia_u32 u32_len)
|
|
{
|
|
*pu64_phy_addr = xmedia_mmz_alloc(str_zone, str_mmb, u32_len);
|
|
if (*pu64_phy_addr == 0) {
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
*pp_vir_addr = xmedia_mmz_map(*pu64_phy_addr, u32_len, 1);
|
|
if (*pp_vir_addr == NULL) {
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
|
|
xmedia_s32 sample_ive_sys_mmz_free(xmedia_u64 u64_phy_addr, xmedia_void *p_vir_addr)
|
|
{
|
|
xmedia_s32 ret;
|
|
|
|
ret = xmedia_mmz_unmap(p_vir_addr);
|
|
if (ret != XMEDIA_SUCCESS) {
|
|
return -1;
|
|
}
|
|
|
|
return xmedia_mmz_free(u64_phy_addr);
|
|
}
|
|
|
|
|
|
xmedia_s32 sample_ive_sys_mmz_flush_cache(xmedia_u64 u64_phy_addr,
|
|
xmedia_void *p_vir_addr,
|
|
xmedia_u32 u32_size)
|
|
{
|
|
return xmedia_mmz_flush_cache(u64_phy_addr, p_vir_addr, u32_size);
|
|
}
|
|
|
|
|
|
xmedia_u16 sample_comm_ive_calc_stride(xmedia_u32 u32width, xmedia_u8 u8align)
|
|
{
|
|
return (u32width + (u8align - u32width % u8align) % u8align);
|
|
}
|
|
|
|
static xmedia_s32 sample_ive_init(xmedia_void)
|
|
{
|
|
xmedia_s32 s32_ret;
|
|
|
|
xmedia_sys_exit();
|
|
|
|
sample_sys_config sys_conifg = { 0 };
|
|
s32_ret = xmedia_sys_init(&sys_conifg.sys_conf);
|
|
if (XMEDIA_SUCCESS != s32_ret)
|
|
{
|
|
SAMPLE_PRT("xmedia_sys_init fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
|
|
xmedia_void sample_comm_ive_check_ive_mpi_init(xmedia_void)
|
|
{
|
|
if (XMEDIA_FALSE == g_b_mpi_init)
|
|
{
|
|
if (sample_ive_init())
|
|
{
|
|
SAMPLE_PRT("Ive mpi init failed!\n");
|
|
exit(-1);
|
|
}
|
|
g_b_mpi_init = XMEDIA_TRUE;
|
|
}
|
|
}
|
|
xmedia_s32 sample_comm_ive_ive_mpi_exit(xmedia_void)
|
|
{
|
|
g_b_mpi_init = XMEDIA_FALSE;
|
|
if (xmedia_sys_exit())
|
|
{
|
|
SAMPLE_PRT("Sys exit failed!\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
xmedia_s32 sample_comm_vgs_fill_rect(xmedia_video_frame_info* pst_frm_info, sample_rect_array_s* pst_rect, xmedia_u32 u32_color)
|
|
{
|
|
xmedia_s32 vgs_handle = -1;
|
|
xmedia_s32 s32_ret = XMEDIA_SUCCESS;
|
|
xmedia_u16 i;
|
|
xmedia_vgs_frame_info st_vgs_task;
|
|
xmedia_vgs_cover_attr st_vgs_add_cover;
|
|
|
|
if (0 == pst_rect->u16_num)
|
|
{
|
|
return s32_ret;
|
|
}
|
|
s32_ret = xmedia_vgs_create_job(&vgs_handle);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("xmedia_vgs_create_job fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
|
|
memcpy(&st_vgs_task.img_in, pst_frm_info, sizeof(xmedia_video_frame_info));
|
|
memcpy(&st_vgs_task.img_out, pst_frm_info, sizeof(xmedia_video_frame_info));
|
|
|
|
st_vgs_add_cover.cover_type = XMEDIA_VGS_COVER_TYPE_QUAD_RANGLE;
|
|
st_vgs_add_cover.color = u32_color;
|
|
for (i = 0; i < pst_rect->u16_num; i++)
|
|
{
|
|
st_vgs_add_cover.quadrangle.is_solid = XMEDIA_FALSE;
|
|
st_vgs_add_cover.quadrangle.thick = 2;
|
|
memcpy(st_vgs_add_cover.quadrangle.points, pst_rect->ast_rect[i].ast_point, sizeof(pst_rect->ast_rect[i].ast_point));
|
|
s32_ret = xmedia_vgs_add_task_cover(vgs_handle, &st_vgs_task, &st_vgs_add_cover,1);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("xmedia_vgs_add_task_cover fail,Error(%#x)\n", s32_ret);
|
|
xmedia_vgs_cancel_job(vgs_handle);
|
|
return s32_ret;
|
|
}
|
|
}
|
|
|
|
s32_ret = xmedia_vgs_submit_job(vgs_handle);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("XMEDIA_API_VGS_EndJob fail,Error(%#x)\n", s32_ret);
|
|
xmedia_vgs_cancel_job(vgs_handle);
|
|
return s32_ret;
|
|
}
|
|
|
|
return s32_ret;
|
|
|
|
}
|
|
|
|
xmedia_s32 sample_comm_ive_read_file(xmedia_ive_image_s* pst_img, FILE* pfp)
|
|
{
|
|
xmedia_u16 y;
|
|
xmedia_u8* p_u8;
|
|
xmedia_u16 height;
|
|
xmedia_u16 width;
|
|
xmedia_u16 loop;
|
|
xmedia_s32 s32_ret;
|
|
|
|
(xmedia_void)fgetc(pfp);
|
|
if (feof(pfp))
|
|
{
|
|
SAMPLE_PRT("end of file!\n");
|
|
s32_ret = fseek(pfp, 0 , SEEK_SET );
|
|
if (0 != s32_ret)
|
|
{
|
|
SAMPLE_PRT("fseek failed!\n");
|
|
return s32_ret;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
s32_ret = fseek(pfp, -1 , SEEK_CUR );
|
|
if (0 != s32_ret)
|
|
{
|
|
SAMPLE_PRT("fseek failed!\n");
|
|
return s32_ret;
|
|
}
|
|
}
|
|
|
|
height = pst_img->u32height;
|
|
width = pst_img->u32width;
|
|
|
|
switch (pst_img->en_type)
|
|
{
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C1:
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( 1 != fread(p_u8, width, 1, pfp))
|
|
{
|
|
SAMPLE_PRT("Read file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0];
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV420SP:
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( 1 != fread(p_u8, width, 1, pfp))
|
|
{
|
|
SAMPLE_PRT("Read file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0];
|
|
}
|
|
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[1];
|
|
for (y = 0; y < height / 2; y++)
|
|
{
|
|
if ( 1 != fread(p_u8, width, 1, pfp))
|
|
{
|
|
SAMPLE_PRT("Read file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[1];
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV422SP:
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( 1 != fread(p_u8, width, 1, pfp))
|
|
{
|
|
SAMPLE_PRT("Read file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0];
|
|
}
|
|
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[1];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( 1 != fread(p_u8, width, 1, pfp))
|
|
{
|
|
SAMPLE_PRT("Read file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[1];
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C3_PACKAGE:
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( 1 != fread(p_u8, width * 3, 1, pfp))
|
|
{
|
|
SAMPLE_PRT("Read file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0] * 3;
|
|
}
|
|
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C3_PLANAR:
|
|
{
|
|
for (loop = 0; loop < 3; loop++)
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[loop];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( 1 != fread(p_u8, width, 1, pfp))
|
|
{
|
|
SAMPLE_PRT("Read file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[loop];
|
|
}
|
|
}
|
|
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S16C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_U16C1:
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for ( y = 0; y < height; y++ )
|
|
{
|
|
if ( sizeof(xmedia_u16) != fread(p_u8, width, sizeof(xmedia_u16), pfp) )
|
|
{
|
|
SAMPLE_PRT("Read file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0] * 2;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
xmedia_s32 sample_comm_ive_write_file(xmedia_ive_image_s* pst_img, FILE* pfp)
|
|
{
|
|
xmedia_u16 y;
|
|
xmedia_u8* p_u8;
|
|
xmedia_u16 height;
|
|
xmedia_u16 width;
|
|
|
|
height = pst_img->u32height;
|
|
width = pst_img->u32width;
|
|
|
|
switch (pst_img->en_type)
|
|
{
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_S8C1:
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( 1 != fwrite(p_u8, width, 1, pfp))
|
|
{
|
|
SAMPLE_PRT("Write file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0];
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV420SP:
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( width != fwrite(p_u8, 1, width, pfp))
|
|
{
|
|
SAMPLE_PRT("Write file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0];
|
|
}
|
|
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[1];
|
|
for (y = 0; y < height / 2; y++)
|
|
{
|
|
if ( width != fwrite(p_u8, 1, width, pfp))
|
|
{
|
|
SAMPLE_PRT("Write file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[1];
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV422SP:
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( width != fwrite(p_u8, 1, width, pfp))
|
|
{
|
|
SAMPLE_PRT("Write file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0];
|
|
}
|
|
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[1];
|
|
for (y = 0; y < height; y++)
|
|
{
|
|
if ( width != fwrite(p_u8, 1, width, pfp))
|
|
{
|
|
SAMPLE_PRT("Write file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[1];
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S16C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_U16C1:
|
|
{
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for ( y = 0; y < height; y++ )
|
|
{
|
|
if ( sizeof(xmedia_u16) != fwrite(p_u8, width, sizeof(xmedia_u16), pfp) )
|
|
{
|
|
SAMPLE_PRT("Write file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0] * 2;
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_U32C1:
|
|
{
|
|
|
|
p_u8 = (xmedia_u8 *)(xmedia_ulong)pst_img->au64viraddr[0];
|
|
for ( y = 0; y < height; y++ )
|
|
{
|
|
if ( width != fwrite(p_u8, sizeof(xmedia_u32), width, pfp) )
|
|
{
|
|
SAMPLE_PRT("Write file fail\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
p_u8 += pst_img->au32stride[0] * 4;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
xmedia_void sample_comm_ive_blob_to_rect(xmedia_ive_ccblob_s *pst_blob, sample_rect_array_s *pst_rect,
|
|
xmedia_u16 u16_rect_max_num,xmedia_u16 u16_area_thr_step,
|
|
xmedia_u32 u32_src_width, xmedia_u32 u32_src_height,
|
|
xmedia_u32 u32_dst_width,xmedia_u32 u32_dst_height)
|
|
{
|
|
xmedia_u16 u16_num;
|
|
xmedia_u16 i,j,k;
|
|
xmedia_u16 u16_thr= 0;
|
|
xmedia_bool b_valid;
|
|
|
|
if(pst_blob->u8_region_num > u16_rect_max_num)
|
|
{
|
|
u16_thr = pst_blob->u16_cur_area_thr;
|
|
do
|
|
{
|
|
u16_num = 0;
|
|
u16_thr += u16_area_thr_step;
|
|
for(i = 0;i < 254;i++)
|
|
{
|
|
if(pst_blob->ast_region[i].u32_area > u16_thr)
|
|
{
|
|
u16_num++;
|
|
}
|
|
}
|
|
}while(u16_num > u16_rect_max_num);
|
|
}
|
|
|
|
u16_num = 0;
|
|
|
|
for(i = 0;i < 254;i++)
|
|
{
|
|
if(pst_blob->ast_region[i].u32_area > u16_thr)
|
|
{
|
|
pst_rect->ast_rect[u16_num].ast_point[0].x = (xmedia_u32)((xmedia_float)pst_blob->ast_region[i].u16_left / (xmedia_float)u32_src_width * (xmedia_float)u32_dst_width) & (~1) ;
|
|
pst_rect->ast_rect[u16_num].ast_point[0].y = (xmedia_u32)((xmedia_float)pst_blob->ast_region[i].u16_top / (xmedia_float)u32_src_height * (xmedia_float)u32_dst_height) & (~1);
|
|
|
|
pst_rect->ast_rect[u16_num].ast_point[1].x = (xmedia_u32)((xmedia_float)pst_blob->ast_region[i].u16_right/ (xmedia_float)u32_src_width * (xmedia_float)u32_dst_width) & (~1);
|
|
pst_rect->ast_rect[u16_num].ast_point[1].y = (xmedia_u32)((xmedia_float)pst_blob->ast_region[i].u16_top / (xmedia_float)u32_src_height * (xmedia_float)u32_dst_height) & (~1);
|
|
|
|
pst_rect->ast_rect[u16_num].ast_point[2].x = (xmedia_u32)((xmedia_float)pst_blob->ast_region[i].u16_right / (xmedia_float)u32_src_width * (xmedia_float)u32_dst_width) & (~1);
|
|
pst_rect->ast_rect[u16_num].ast_point[2].y = (xmedia_u32)((xmedia_float)pst_blob->ast_region[i].u16_bottom / (xmedia_float)u32_src_height * (xmedia_float)u32_dst_height) & (~1);
|
|
|
|
pst_rect->ast_rect[u16_num].ast_point[3].x = (xmedia_u32)((xmedia_float)pst_blob->ast_region[i].u16_left / (xmedia_float)u32_src_width * (xmedia_float)u32_dst_width) & (~1);
|
|
pst_rect->ast_rect[u16_num].ast_point[3].y = (xmedia_u32)((xmedia_float)pst_blob->ast_region[i].u16_bottom / (xmedia_float)u32_src_height * (xmedia_float)u32_dst_height) & (~1);
|
|
|
|
b_valid = XMEDIA_TRUE;
|
|
for(j = 0; j < 3;j++)
|
|
{
|
|
for (k = j + 1; k < 4;k++)
|
|
{
|
|
if ((pst_rect->ast_rect[u16_num].ast_point[j].x == pst_rect->ast_rect[u16_num].ast_point[k].x)
|
|
&&(pst_rect->ast_rect[u16_num].ast_point[j].y == pst_rect->ast_rect[u16_num].ast_point[k].y))
|
|
{
|
|
b_valid = XMEDIA_FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (XMEDIA_TRUE == b_valid)
|
|
{
|
|
u16_num++;
|
|
}
|
|
}
|
|
}
|
|
|
|
pst_rect->u16_num = u16_num;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* function : Create ive image
|
|
******************************************************************************/
|
|
xmedia_s32 sample_comm_ive_create_image(xmedia_ive_image_s* pst_img, xmedia_ive_image_type_e en_type, xmedia_u32 u32width, xmedia_u32 u32height)
|
|
{
|
|
xmedia_u32 u32size = 0;
|
|
xmedia_s32 s32_ret;
|
|
if (NULL == pst_img)
|
|
{
|
|
SAMPLE_PRT("pst_img is null\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
pst_img->en_type = en_type;
|
|
pst_img->u32width = u32width;
|
|
pst_img->u32height = u32height;
|
|
pst_img->au32stride[0] = sample_comm_ive_calc_stride(pst_img->u32width, IVE_ALIGN);
|
|
|
|
switch (en_type)
|
|
{
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_S8C1:
|
|
{
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height;
|
|
s32_ret = sample_ive_sys_mmz_alloc(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV420SP:
|
|
{
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height * 3 / 2;
|
|
s32_ret = sample_ive_sys_mmz_alloc(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
pst_img->au32stride[1] = pst_img->au32stride[0];
|
|
pst_img->au64phyaddr[1] = pst_img->au64phyaddr[0] + pst_img->au32stride[0] * pst_img->u32height;
|
|
pst_img->au64viraddr[1] = pst_img->au64viraddr[0] + pst_img->au32stride[0] * pst_img->u32height;
|
|
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV422SP:
|
|
{
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height * 2;
|
|
s32_ret = sample_ive_sys_mmz_alloc(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
pst_img->au32stride[1] = pst_img->au32stride[0];
|
|
pst_img->au64phyaddr[1] = pst_img->au64phyaddr[0] + pst_img->au32stride[0] * pst_img->u32height;
|
|
pst_img->au64viraddr[1] = pst_img->au64viraddr[0] + pst_img->au32stride[0] * pst_img->u32height;
|
|
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV420P:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV422P:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S8C2_PACKAGE:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S8C2_PLANAR:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S16C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_U16C1:
|
|
{
|
|
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height * sizeof(xmedia_u16);
|
|
s32_ret = sample_ive_sys_mmz_alloc(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C3_PACKAGE:
|
|
{
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height * 3;
|
|
s32_ret = sample_ive_sys_mmz_alloc(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
pst_img->au64viraddr[1] = pst_img->au64viraddr[0] + 1;
|
|
pst_img->au64viraddr[2] = pst_img->au64viraddr[1] + 1;
|
|
pst_img->au64phyaddr[1] = pst_img->au64phyaddr[0] + 1;
|
|
pst_img->au64phyaddr[2] = pst_img->au64phyaddr[1] + 1;
|
|
pst_img->au32stride[1] = pst_img->au32stride[0];
|
|
pst_img->au32stride[2] = pst_img->au32stride[0];
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C3_PLANAR:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S32C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_U32C1:
|
|
{
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height * sizeof(xmedia_u32);
|
|
s32_ret = sample_ive_sys_mmz_alloc(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S64C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_U64C1:
|
|
{
|
|
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height * sizeof(xmedia_u64);
|
|
s32_ret = sample_ive_sys_mmz_alloc(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
/******************************************************************************
|
|
* function : Create memory info
|
|
******************************************************************************/
|
|
xmedia_s32 sample_comm_ive_create_mem_info(xmedia_ive_mem_info_s* pst_mem_info, xmedia_u32 u32size)
|
|
{
|
|
xmedia_s32 s32_ret;
|
|
|
|
if (NULL == pst_mem_info)
|
|
{
|
|
SAMPLE_PRT("pst_mem_info is null\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
pst_mem_info->u32size = u32size;
|
|
s32_ret = sample_ive_sys_mmz_alloc(&pst_mem_info->u64phyaddr, (xmedia_void**)&pst_mem_info->u64viraddr, NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
/******************************************************************************
|
|
* function : Create ive image by cached
|
|
******************************************************************************/
|
|
xmedia_s32 sample_comm_ive_create_image_by_cached(xmedia_ive_image_s* pst_img,
|
|
xmedia_ive_image_type_e en_type, xmedia_u32 u32width, xmedia_u32 u32height)
|
|
{
|
|
xmedia_u32 u32size = 0;
|
|
xmedia_s32 s32_ret;
|
|
if (NULL == pst_img)
|
|
{
|
|
SAMPLE_PRT("pst_img is null\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
pst_img->en_type = en_type;
|
|
pst_img->u32width = u32width;
|
|
pst_img->u32height = u32height;
|
|
pst_img->au32stride[0] = sample_comm_ive_calc_stride(pst_img->u32width, IVE_ALIGN);
|
|
|
|
switch (en_type)
|
|
{
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_S8C1:
|
|
{
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height;
|
|
s32_ret = sample_ive_sys_mmz_alloc_cached(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV420SP:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV422SP:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV420P:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_YUV422P:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S8C2_PACKAGE:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S8C2_PLANAR:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S16C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_U16C1:
|
|
{
|
|
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height * sizeof(xmedia_u16);
|
|
s32_ret = sample_ive_sys_mmz_alloc_cached(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C3_PACKAGE:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_U8C3_PLANAR:
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S32C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_U32C1:
|
|
{
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height * sizeof(xmedia_u32);
|
|
s32_ret = sample_ive_sys_mmz_alloc_cached(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
}
|
|
break;
|
|
case XMEDIA_IVE_IMAGE_TYPE_S64C1:
|
|
case XMEDIA_IVE_IMAGE_TYPE_U64C1:
|
|
{
|
|
|
|
u32size = pst_img->au32stride[0] * pst_img->u32height * sizeof(xmedia_u64);
|
|
s32_ret = sample_ive_sys_mmz_alloc_cached(&pst_img->au64phyaddr[0], (xmedia_void**)&pst_img->au64viraddr[0], NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return s32_ret;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
xmedia_s32 sample_comm_ive_create_data(xmedia_ive_data_s* pst_data,xmedia_u32 u32width, xmedia_u32 u32height)
|
|
{
|
|
xmedia_s32 s32_ret;
|
|
xmedia_u32 u32size;
|
|
|
|
if (NULL == pst_data)
|
|
{
|
|
SAMPLE_PRT("pst_data is null\n");
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
pst_data->u32width = u32width;
|
|
pst_data->u32height = u32height;
|
|
pst_data->u32stride = sample_comm_ive_calc_stride(pst_data->u32width, IVE_ALIGN);
|
|
u32size = pst_data->u32stride * pst_data->u32height;
|
|
s32_ret = sample_ive_sys_mmz_alloc(&pst_data->u64phyaddr, (xmedia_void**)&pst_data->u64viraddr, NULL, XMEDIA_NULL, u32size);
|
|
if (s32_ret != XMEDIA_SUCCESS)
|
|
{
|
|
SAMPLE_PRT("Mmz Alloc fail,Error(%#x)\n", s32_ret);
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
xmedia_s32 sample_ive_comm_sys_get_pic_size(pic_size_e enPicSize, xmedia_video_size* pst_size)
|
|
{
|
|
switch (enPicSize)
|
|
{
|
|
case PIC_CIF: /* 352 * 288 */
|
|
pst_size->width = 352;
|
|
pst_size->height = 288;
|
|
break;
|
|
|
|
case PIC_360P: /* 640 * 360 */
|
|
pst_size->width = 640;
|
|
pst_size->height = 360;
|
|
break;
|
|
|
|
case PIC_VGA: /* 640 * 480 */
|
|
pst_size->width = 640;
|
|
pst_size->height = 480;
|
|
break;
|
|
case PIC_640x360: /* 640 * 360 */
|
|
pst_size->width = 640;
|
|
pst_size->height = 360;
|
|
break;
|
|
|
|
case PIC_D1_PAL: /* 720 * 576 */
|
|
pst_size->width = 720;
|
|
pst_size->height = 576;
|
|
break;
|
|
|
|
case PIC_D1_NTSC: /* 720 * 480 */
|
|
pst_size->width = 720;
|
|
pst_size->height = 480;
|
|
break;
|
|
|
|
case PIC_720P: /* 1280 * 720 */
|
|
pst_size->width = 1280;
|
|
pst_size->height = 720;
|
|
break;
|
|
|
|
case PIC_1080P: /* 1920 * 1080 */
|
|
pst_size->width = 1920;
|
|
pst_size->height = 1080;
|
|
break;
|
|
|
|
case PIC_2304x1296: /* 2304 * 1296 */
|
|
pst_size->width = 2304;
|
|
pst_size->height = 1296;
|
|
break;
|
|
|
|
case PIC_2560x1440: /* 2560 * 1440 */
|
|
pst_size->width = 2560;
|
|
pst_size->height = 1440;
|
|
break;
|
|
|
|
case PIC_2592x1520:
|
|
pst_size->width = 2592;
|
|
pst_size->height = 1520;
|
|
break;
|
|
|
|
case PIC_2592x1944:
|
|
pst_size->width = 2592;
|
|
pst_size->height = 1944;
|
|
break;
|
|
|
|
case PIC_2592x1536:
|
|
pst_size->width = 2592;
|
|
pst_size->height = 1536;
|
|
break;
|
|
|
|
case PIC_2688x1520:
|
|
pst_size->width = 2688;
|
|
pst_size->height = 1520;
|
|
break;
|
|
|
|
case PIC_2716x1524:
|
|
pst_size->width = 2716;
|
|
pst_size->height = 1524;
|
|
break;
|
|
|
|
case PIC_3840x2160:
|
|
pst_size->width = 3840;
|
|
pst_size->height = 2160;
|
|
break;
|
|
|
|
case PIC_3000x3000:
|
|
pst_size->width = 3000;
|
|
pst_size->height = 3000;
|
|
break;
|
|
|
|
case PIC_4000x3000:
|
|
pst_size->width = 4000;
|
|
pst_size->height = 3000;
|
|
break;
|
|
|
|
case PIC_4096x2160:
|
|
pst_size->width = 4096;
|
|
pst_size->height = 2160;
|
|
break;
|
|
|
|
case PIC_7680x4320:
|
|
pst_size->width = 7680;
|
|
pst_size->height = 4320;
|
|
break;
|
|
case PIC_3840x8640:
|
|
pst_size->width = 3840;
|
|
pst_size->height = 8640;
|
|
break;
|
|
case PIC_2688x1536:
|
|
pst_size->width = 2688;
|
|
pst_size->height = 1536;
|
|
break;
|
|
case PIC_2688x1944:
|
|
pst_size->width = 2688;
|
|
pst_size->height = 1944;
|
|
break;
|
|
case PIC_2880x1620:
|
|
pst_size->width = 2880;
|
|
pst_size->height = 1620;
|
|
break;
|
|
case PIC_3072x1728:
|
|
pst_size->width = 3072;
|
|
pst_size->height = 1728;
|
|
break;
|
|
default:
|
|
return XMEDIA_FAILURE;
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* function : Dma frame info to ive image
|
|
******************************************************************************/
|
|
xmedia_s32 sample_comm_ive_dma_image(xmedia_video_frame_info *pst_frame_info,xmedia_ive_dst_image_s *pst_dst,xmedia_bool b_instant)
|
|
{
|
|
xmedia_s32 s32_ret;
|
|
xmedia_ive_handle h_ive_handle;
|
|
xmedia_ive_src_data_s st_src_data;
|
|
xmedia_ive_dst_data_s st_dst_data;
|
|
xmedia_ive_dma_ctrl_s st_ctrl = {XMEDIA_IVE_DMA_MODE_DIRECT_COPY,0};
|
|
xmedia_bool b_finish = XMEDIA_FALSE;
|
|
xmedia_bool b_block = XMEDIA_TRUE;
|
|
|
|
//fill src
|
|
//st_src_data.u64viraddr = pst_frame_info->stVFrame.u64viraddr[0];
|
|
//need test
|
|
st_src_data.u64phyaddr = pst_frame_info->frame.addr.y_phy_addr;
|
|
st_src_data.u32width = pst_frame_info->frame.width;
|
|
st_src_data.u32height = pst_frame_info->frame.height;
|
|
st_src_data.u32stride = pst_frame_info->frame.stride.y_stride;
|
|
|
|
//fill dst
|
|
//st_dst_data.u64viraddr = pst_dst->au64viraddr[0];
|
|
st_dst_data.u64phyaddr = pst_dst->au64phyaddr[0];
|
|
st_dst_data.u32width = pst_dst->u32width;
|
|
st_dst_data.u32height = pst_dst->u32height;
|
|
st_dst_data.u32stride = pst_dst->au32stride[0];
|
|
|
|
s32_ret = xmedia_ive_dma(&h_ive_handle,&st_src_data,&st_dst_data,&st_ctrl,b_instant);
|
|
SAMPLE_CHECK_EXPR_RET(XMEDIA_SUCCESS != s32_ret,s32_ret,"Error(%#x),xmedia_ive_dma failed!\n",s32_ret);
|
|
|
|
if (XMEDIA_TRUE == b_instant)
|
|
{
|
|
s32_ret = xmedia_ive_query(h_ive_handle,&b_finish,b_block);
|
|
while(ERR_CODE_IVE_QUERY_TIMEOUT == s32_ret)
|
|
{
|
|
usleep(100);
|
|
s32_ret = xmedia_ive_query(h_ive_handle,&b_finish,b_block);
|
|
}
|
|
SAMPLE_CHECK_EXPR_RET(XMEDIA_SUCCESS != s32_ret,s32_ret,"Error(%#x),xmedia_ive_query failed!\n",s32_ret);
|
|
}
|
|
|
|
return XMEDIA_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* function : Create memory info with cache
|
|
*/
|
|
xmedia_s32 sample_common_malloc_mem_cache(xmedia_u64 *phys_addr, void **virt_addr, xmedia_u32 size)
|
|
{
|
|
xmedia_s32 ret;
|
|
|
|
ret = sample_ive_sys_mmz_alloc_cached(phys_addr, virt_addr, (xmedia_char*)NULL, (xmedia_char*)XMEDIA_NULL, size);
|
|
SAMPLE_CHECK_EXPR_RET(ret != XMEDIA_SUCCESS, ret, "Error(%#x), MmzAlloc with cache failed!\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* function : free memory
|
|
*/
|
|
xmedia_s32 sample_common_free_mem(xmedia_u64 phys_addr, void *virt_addr)
|
|
{
|
|
xmedia_s32 ret;
|
|
|
|
ret = sample_ive_sys_mmz_free(phys_addr, virt_addr);
|
|
SAMPLE_CHECK_EXPR_RET(ret != XMEDIA_SUCCESS, ret, "Error(%#x), sample_ive_sys_mmz_free failed!\n", ret);
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
|