TDA4VM: tiovx convert

xin alex

Part Number: TDA4VM

Hi TI expert，

Now I do image process by openvx； the function of this is scale and color covert；

	obj->node = tivxVpacMscScaleNode(obj->graph,
				obj->mscIn, 
				obj->mscOutList[0].mscOut,
				obj->mscOutList[1].mscOut,
				obj->mscOutList[2].mscOut,
				NULL,
				NULL);
   obj->node1 = vxColorConvertNode(obj->graph, 
                obj->mscOutList[0].mscOut, obj->convertImg[0]);

image mscIn is 1280X960

/*scaler ratio 1/2*/
obj->mscOutList[0].w = 1280U;
obj->mscOutList[0].h = 960U;
obj->mscOutList[0].ratio = 1U;

/*scaler ratio 1/3*/
obj->mscOutList[1].w = 320U;
obj->mscOutList[1].h = 240U;
obj->mscOutList[1].ratio = 4U;

/*scaler ratio 1/4*/
obj->mscOutList[2].w = 320U;
obj->mscOutList[2].h = 240U;
obj->mscOutList[2].ratio = 4U;

obj->convertImg.w = 1280U;
obj->convertImg.h = 960U;

tivxVpacMscScaleNode output0 param is vxColorConvertNode input，vxColorConvertNode input and output param 1280X960

when after vxVerifyGraph process;

vxColorConvertNode input and output the param of vx_image is changed about valid_roi ；

1. Before vxVerifyGraph

vxColorConvertNode input and output param dump ：

mscOutList[0] valid_roi x [0 1280] y[0 960]
convertImg x [0 1280] y[0 960]

2. after vxVerifyGraph

vxColorConvertNode input and output param dump ：

mscOutList[0] valid_roi x [0 320] y[0 240]
convertImg x [0 320] y[0 240]

I do not change this param， and 320&240 param is my mscOutList[1] configuration；

Why are mscOutList[0] and convertImg changed after vxVerifyGraph

over 2 years ago

0 Brijesh Jadav over 2 years ago

TI__Guru**** 398250 points

Hi,

MSC node does not really update/use valid roi parameter, so i am really doubtful that this will have any effect. To confirm, can you also get image width and height attributes and confirmed it to be correct for the msc output0?

Regards,

Brijesh

0 xin alex over 2 years ago in reply to Brijesh Jadav

Intellectual 506 points

Hi Ti expert，

The input image buff of MSC is created By myself， and load image data By SD card。 width and height attributes are fixed by code (1280X960).

My code is As flow:


#include <TI/tivx.h>
#include <TI/tivx_task.h>
#include <TI/j7.h>
#include <TI/j7_imaging_aewb.h>
#include <tivx_utils_graph_perf.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <assert.h>
#include "HAT_AD_cType.h"

#include "vx_internal.h"
#include "vx_reference.h"
#include "vx_pyramid.h"
#include "HAT_vxImgFileProcess.h"

static void scale_set_coeff(tivx_vpac_msc_coefficients_t *coeff, uint32_t interpolation);
static void scale_set_output_params(tivx_vpac_msc_output_params_t *params,
    uint32_t interpolation, uint32_t iw, uint32_t ih, uint32_t ow, uint32_t oh);

#define COLORBAR_PRT(...)  printf("[PYR]");printf(__VA_ARGS__)
#define PYR_DBG_PRT(...)  printf("[PYR]");printf(__VA_ARGS__)
#define PYR_ERR_PRT(...)  printf("[PYR]");printf(__VA_ARGS__)




#define MSC_SCALER_MAX		(5U)

typedef struct {
	vx_uint32      enable;
	vx_uint32      ratio;
	vx_uint32 		w;
	vx_uint32 		h;
	vx_uint32 		fmt;
	vx_image   mscOut;
} hat_scaler_out_t;



typedef struct {
    vx_context context;
    vx_graph   graph;
    vx_graph   graph1;
	vx_node    node;
	vx_node    node1;
	vx_node    node2;
	vx_node    node3;
	
	vx_uint32  w;
	vx_uint32  h;
	vx_image   mscIn;
	hat_scaler_out_t   mscOutList[MSC_SCALER_MAX];
	tivx_vpac_msc_output_params_t outParam[MSC_SCALER_MAX];
	vx_user_data_object coeff_obj;	
	vx_user_data_object outParam_obj[MSC_SCALER_MAX];		
	vx_user_data_object crop_obj[MSC_SCALER_MAX];	
    tivx_vpac_msc_crop_params_t crop[MSC_SCALER_MAX];
	vx_image  convertImg[5U];
} hat_scaler_obj_t;

#define SUPPORT_CONVERT_FUNC


hat_scaler_obj_t gUyvyHdl = {0};


#define TIVX_KERNEL_PYRAMID_SOURCE_NAME     "com.ti.test_kernels.pyramid_source"

VX_API_ENTRY vx_node VX_API_CALL tivxPyramidSourceNode(vx_graph graph,
                                      vx_pyramid           output)
{
    vx_reference prms[] = {
            (vx_reference)output
    };
    vx_node node = tivxCreateNodeByKernelName(graph,
                                           TIVX_KERNEL_PYRAMID_SOURCE_NAME,
                                           prms,
                                           dimof(prms));
    return node;
}
void show_image_attributes(vx_image image);

#define  SCALAR_ALG_MDOE		(VX_INTERPOLATION_BILINEAR)
INT32 graph_scaler_imgInit(hat_scaler_obj_t* obj)
{	
    vx_enum space = VX_COLOR_SPACE_BT709;

    vx_status status = VX_SUCCESS;
	vx_uint32 i = 0U;
	tivx_vpac_msc_coefficients_t coeffs;

	PYR_DBG_PRT("graph_scaler_imgInit  Start!\n");
	
	obj->w = 1280U;
	obj->h = 960U;
	
	obj->mscIn = vxCreateImage(obj->context, obj->w, obj->h, VX_DF_IMAGE_NV12);
	status = vxGetStatus((vx_reference)obj->mscIn);
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("vxCreateImage Fail %d\n", status);
		return status;
	}

	/*scaler ratio 1/2*/
	obj->mscOutList[0].w  = 1280U;
	obj->mscOutList[0].h  = 960U;
	obj->mscOutList[0].ratio = 1U;
#if 1
	/*scaler ratio 1/3*/
	obj->mscOutList[1].w  = 320U; 
	obj->mscOutList[1].h  = 240U;
	obj->mscOutList[1].ratio = 4U;
#else
	/*scaler ratio 1/3*/
	obj->mscOutList[1].w  = 416U; 
	obj->mscOutList[1].h  = 224U;
	obj->mscOutList[1].ratio = 3U;

#endif
	/*scaler ratio 1/4*/
	obj->mscOutList[2].w  = 320U; 
	obj->mscOutList[2].h  = 240U;
	obj->mscOutList[2].ratio = 4U;

	/*scaler ratio 1/5*/
	obj->mscOutList[3].w  = 256U; 
	obj->mscOutList[3].h  = 192U;	
	obj->mscOutList[3].ratio = 5U;

	/*scaler ratio 1/6*/
	obj->mscOutList[4].w  = 212U; 
	obj->mscOutList[4].h  = 160U;
	obj->mscOutList[4].ratio = 6U;

	for(i = 0; i < 5U; i++)
	{
		obj->crop[i].crop_width   =  obj->mscOutList[i].w * obj->mscOutList[i].ratio;
		obj->crop[i].crop_height  =  obj->mscOutList[i].h * obj->mscOutList[i].ratio;
		obj->crop[i].crop_start_x =  (obj->w - obj->crop[i].crop_width) / 2;
		obj->crop[i].crop_start_y =  (obj->h - obj->crop[i].crop_height) / 2;
	}


	for(i = 0; i < 5U; i++)
	{
		obj->mscOutList[i].mscOut = vxCreateImage(obj->context, obj->mscOutList[i].w, obj->mscOutList[i].h, 
									VX_DF_IMAGE_NV12);
		status = vxGetStatus((vx_reference)obj->mscOutList[i].mscOut);
		if(status != VX_SUCCESS)
		{
			PYR_DBG_PRT("vxCreateImage Fail %d idx %d\n", status, i);
			return status;
		}
		
#ifdef SUPPORT_CONVERT_FUNC
		obj->convertImg[i] = vxCreateImage(obj->context, obj->mscOutList[i].w, obj->mscOutList[i].h, 
									VX_DF_IMAGE_RGB);
		status = vxGetStatus((vx_reference)obj->mscOutList[i].mscOut);
		if(status != VX_SUCCESS)
		{
			PYR_DBG_PRT("vxCreateImage Fail %d idx %d\n", status, i);
			return status;
		}
		vxSetImageAttribute(obj->mscOutList[i].mscOut, VX_IMAGE_SPACE, &space, sizeof(space));
		vxSetImageAttribute(obj->mscOutList[i].mscOut, VX_IMAGE_SPACE, &space, sizeof(space));
#endif


		/*output param config*/
		tivx_vpac_msc_output_params_init(&obj->outParam[i]);
		scale_set_output_params(&obj->outParam[i],SCALAR_ALG_MDOE,
			 					obj->w, obj->h, obj->mscOutList[i].w, 
			 					obj->mscOutList[i].h);

		obj->outParam_obj[i] = vxCreateUserDataObject(obj->context,
						  "tivx_vpac_msc_output_params_t",
						  sizeof(tivx_vpac_msc_output_params_t), NULL);


		status = vxCopyUserDataObject(obj->outParam_obj[i], 0,
							  sizeof(tivx_vpac_msc_output_params_t),
							  &obj->outParam[i],
							  VX_WRITE_ONLY,
							  VX_MEMORY_TYPE_HOST);
		if(VX_SUCCESS != status)
		{
			PYR_DBG_PRT("Output obj error %d \n", status);
			break;
		}

		/*source image crop param config*/
		obj->crop_obj[i] = vxCreateUserDataObject(obj->context,
						  "tivx_vpac_msc_crop_params_t",
						  sizeof(tivx_vpac_msc_crop_params_t), NULL);


		status = vxCopyUserDataObject(obj->crop_obj[i], 0,
							  sizeof(tivx_vpac_msc_crop_params_t),
							  &obj->crop[i],
							  VX_WRITE_ONLY,
							  VX_MEMORY_TYPE_HOST);
		if(VX_SUCCESS != status)
		{
			PYR_DBG_PRT("crop_obj obj error %d \n", status);
			break;
		}



		PYR_DBG_PRT("imgOut[%d] coff w %d h %d crop start[%d %d] roi[%d %d]\n",
						i, obj->mscOutList[i].w, obj->mscOutList[i].h,
						obj->crop[i].crop_start_x, obj->crop[i].crop_start_y,
						obj->crop[i].crop_width, obj->crop[i].crop_height);
	}

	scale_set_coeff(&coeffs, SCALAR_ALG_MDOE);
	
	/* Set Coefficients */
	obj->coeff_obj = vxCreateUserDataObject(obj->context,
									   "tivx_vpac_msc_coefficients_t",
									   sizeof(tivx_vpac_msc_coefficients_t),
									   NULL);
	
	if(status == VX_SUCCESS)
	{
	  status = vxCopyUserDataObject(obj->coeff_obj, 0,
						  sizeof(tivx_vpac_msc_coefficients_t),
						  &coeffs,
						  VX_WRITE_ONLY,
						  VX_MEMORY_TYPE_HOST);
	}

	PYR_DBG_PRT("graph_scaler_imgInit  Done sts %d !\n", status);

	return status;
}

INT32 graph_scaler_init(hat_scaler_obj_t* obj)
{
    vx_status status = VX_SUCCESS;
	
	PYR_DBG_PRT("graph_scaler_init Start \n");
	obj->context = vxCreateContext();
    status = vxGetStatus((vx_reference)obj->context);
    if(status == VX_SUCCESS)
	{
        tivxHwaLoadKernels(obj->context);
        tivxImagingLoadKernels(obj->context);
    }
	else
	{
		PYR_DBG_PRT("vxCreateContext Fail %d\n", status);
		return status;
	}
	
	obj->graph = vxCreateGraph(obj->context);
    status = vxGetStatus((vx_reference)obj->graph);
    if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("vxCreateGraph Fail %d\n", status);
		return status;
    }
	
#ifdef SUPPORT_CONVERT_FUNC
	obj->graph1 = vxCreateGraph(obj->context);
	status = vxGetStatus((vx_reference)obj->graph1);
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("vxCreateGraph graph1 Fail %d\n", status);
		return status;
	}
#endif
	status = graph_scaler_imgInit(obj);
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("graph_scaler_imgInit Fail %d\n", status);
		return status;
	}

	obj->node = tivxVpacMscScaleNode(obj->graph,
				obj->mscIn, 
				obj->mscOutList[0].mscOut,
				obj->mscOutList[1].mscOut,
				obj->mscOutList[2].mscOut,
				NULL,
				NULL);


	status = vxGetStatus((vx_reference)obj->node);
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("tivxVpacMscPyramidNode Fail %d\n", status);
		return status;
	}	



#ifdef SUPPORT_CONVERT_FUNC
	obj->node1 = vxColorConvertNode(obj->graph, obj->mscOutList[0].mscOut, obj->convertImg[0]);
	status = vxGetStatus((vx_reference)obj->node1);
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("tivxVpacMscPyramidNode node1 Fail %d\n", status);
		return status;
	}	

	obj->node2 = vxColorConvertNode(obj->graph, obj->mscOutList[1].mscOut, obj->convertImg[1]);
	status = vxGetStatus((vx_reference)obj->node1);
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("tivxVpacMscPyramidNode node1 Fail %d\n", status);
		return status;
	}	

	obj->node3 = vxColorConvertNode(obj->graph, obj->mscOutList[2].mscOut, obj->convertImg[2]);
	status = vxGetStatus((vx_reference)obj->node1);
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("tivxVpac0MscPyramidNode node1 Fail %d\n", status);
		return status;
	}		

	
	PYR_DBG_PRT("obj->node %d \n", obj->node->obj_desc[0]->num_in_nodes);
	PYR_DBG_PRT("obj->node %d \n", obj->node1->obj_desc[0]->num_in_nodes);

#endif
	status = vxSetNodeTarget(obj->node, VX_TARGET_STRING, TIVX_TARGET_VPAC_MSC1);
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("vxSetNodeTarget Fail %d\n", status);
		return status;
	}
	
	return status;
}



vx_status tivx_utils_graph_perf_print(vx_graph graph);

INT32 graph_scaler_process(hat_scaler_obj_t * obj)
{
    vx_status status = VX_SUCCESS;
	img_colorBar_info_s colorBarInfo = {0};
	CHAR savePath[128] = {0};
    vx_reference refs[5] = {0};
    vx_reference output_refs[5] = {0};

	(VOID)colorBarInfo;
	colorBarInfo.pAddr = NULL;
	colorBarInfo.fmt   =  2;
	colorBarInfo.w     =  640;
	colorBarInfo.h     =  480;
	colorBarInfo.pitch =  640;
	colorBarInfo.colorBarNum =  6;
	
	PYR_DBG_PRT("graph_scaler_process Start \n");
	PYR_DBG_PRT("img_colorBarCreateByVx Start \n");


	status = HAT_imgRead(obj->mscIn, "/run/media/mmcblk1p1/src.yuv");
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("HAT_imgRead Fail %d\n", status);
		return status;
	}
(void)colorBarInfo;

    tivx_obj_desc_image_t *obj_desc = NULL;
    obj_desc = (tivx_obj_desc_image_t *)obj->mscOutList[0].mscOut->base.obj_desc;

	PYR_DBG_PRT("vxVerifyGraph roi mscOutList x [%d %d] y[%d %d]\n",
		obj_desc->valid_roi.start_x, obj_desc->valid_roi.end_x,
		obj_desc->valid_roi.start_y, obj_desc->valid_roi.end_y);

    obj_desc = (tivx_obj_desc_image_t *)obj->convertImg[0]->base.obj_desc;

	PYR_DBG_PRT("vxVerifyGraph roi convertImg x [%d %d] y[%d %d]\n",
		obj_desc->valid_roi.start_x, obj_desc->valid_roi.end_x,
		obj_desc->valid_roi.start_y, obj_desc->valid_roi.end_y);

	PYR_DBG_PRT("vxVerifyGraph Start \n");
	status = vxVerifyGraph(obj->graph);
	if(status != VX_SUCCESS)
	{
		PYR_DBG_PRT("vxVerifyGraph Fail %d\n", status);
		return status;
	}


    (void)output_refs;
    (void)refs;



    obj_desc = (tivx_obj_desc_image_t *)obj->mscOutList[0].mscOut->base.obj_desc;
	PYR_DBG_PRT("roi mscOutList x [%d %d] y[%d %d]\n",
		obj_desc->valid_roi.start_x, obj_desc->valid_roi.end_x,
		obj_desc->valid_roi.start_y, obj_desc->valid_roi.end_y);

    obj_desc = (tivx_obj_desc_image_t *)obj->mscOutList[1].mscOut->base.obj_desc;
	PYR_DBG_PRT("roi mscOutList x [%d %d] y[%d %d]\n",
		obj_desc->valid_roi.start_x, obj_desc->valid_roi.end_x,
		obj_desc->valid_roi.start_y, obj_desc->valid_roi.end_y);

    obj_desc = (tivx_obj_desc_image_t *)obj->mscOutList[2].mscOut->base.obj_desc;
	PYR_DBG_PRT("roi mscOutList x [%d %d] y[%d %d]\n",
		obj_desc->valid_roi.start_x, obj_desc->valid_roi.end_x,
		obj_desc->valid_roi.start_y, obj_desc->valid_roi.end_y);
	


    obj_desc = (tivx_obj_desc_image_t *)obj->convertImg[0]->base.obj_desc;

	PYR_DBG_PRT("roi convertImg x [%d %d] y[%d %d]\n",
		obj_desc->valid_roi.start_x, obj_desc->valid_roi.end_x,
		obj_desc->valid_roi.start_y, obj_desc->valid_roi.end_y);

	PYR_DBG_PRT("obj->node1111 %d %d %d %d\n", obj->node->obj_desc[0]->num_in_nodes,
		obj->node->obj_desc[0]->base.obj_desc_id,
		obj->node->obj_desc[0]->out_node_id[0], obj->node->obj_desc[0]->num_out_nodes);
	PYR_DBG_PRT("obj->node1111 %d %d \n", obj->node1->obj_desc[0]->num_in_nodes,
		obj->node1->obj_desc[0]->base.obj_desc_id);
	
	PYR_DBG_PRT("obj->node1111 id %d \n", obj->node1->obj_desc[0]->in_node_id[0]);
	PYR_DBG_PRT("vxProcessGraph Start \n");
	status = vxProcessGraph(obj->graph);
	if(status != VX_SUCCESS)
	{
		return status;
	}
	tivx_utils_graph_perf_print(obj->graph);

	img_dumpInfo(obj->mscOutList[0].mscOut, "Lvl0");
	img_dumpInfo(obj->mscOutList[1].mscOut, "Lvl1");
	img_dumpInfo(obj->mscOutList[2].mscOut, "Lvl2");
	img_dumpInfo(obj->mscOutList[3].mscOut, "Lvl3");
	img_dumpInfo(obj->mscOutList[4].mscOut, "Lvl4");

	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_src.bin");
	img_Write(obj->mscIn, savePath);


	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_0.bin");
	img_Write(obj->mscOutList[0].mscOut, savePath);

	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_1.bin");
	img_Write(obj->mscOutList[1].mscOut, savePath);

	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_2.bin");
	img_Write(obj->mscOutList[2].mscOut, savePath);


	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_3.bin");
	img_Write(obj->mscOutList[3].mscOut, savePath);

	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_4.bin");
	img_Write(obj->mscOutList[4].mscOut, savePath);

	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_0rgb.bin");
	img_Write(obj->convertImg[0], savePath);


	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_1rgb.bin");
	img_Write(obj->convertImg[1], savePath);

	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_2rgb.bin");
	img_Write(obj->convertImg[2], savePath);


	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_3rgb.bin");
	img_Write(obj->convertImg[3], savePath);


	memset(savePath, 0, sizeof(savePath));
	sprintf(savePath, "/run/media/mmcblk1p1/%s", "scaler_4rgb.bin");
	img_Write(obj->convertImg[4], savePath);


	PYR_DBG_PRT("vxProcessGraph done!!! \n");

	return status;
}

INT32 graph_scaler_deinit(hat_scaler_obj_t* obj)
{
    vx_status status = VX_SUCCESS;

	(VOID)status;
	(VOID)obj;
	return status;
}



INT32 HAT_pyrProcessInit( VOID )
{
	INT32 ret = 0;
	if (vx_true_e != tivxIsTargetEnabled(TIVX_TARGET_VPAC_MSC1))
	{
		PYR_ERR_PRT("tivxIsTargetEnabled init fail %d \n", ret);
		return -2;
	}
	
	ret = graph_scaler_init(&gUyvyHdl);
	if(OK != ret)
	{
		PYR_ERR_PRT("Scaler init fail %d \n", ret);
		return -1;
	}

	ret = graph_scaler_process(&gUyvyHdl);
	if(OK != ret)
	{
		PYR_ERR_PRT("graph_scaler_process fail %d \n", ret);
		return -1;
	}
	
	return OK;
}





static void scale_set_coeff(tivx_vpac_msc_coefficients_t *coeff, uint32_t interpolation)
{
    uint32_t i;
    uint32_t idx;
    uint32_t weight;

    idx = 0;
    coeff->single_phase[0][idx ++] = 0;
    coeff->single_phase[0][idx ++] = 0;
    coeff->single_phase[0][idx ++] = 256;
    coeff->single_phase[0][idx ++] = 0;
    coeff->single_phase[0][idx ++] = 0;
    idx = 0;
    coeff->single_phase[1][idx ++] = 0;
    coeff->single_phase[1][idx ++] = 0;
    coeff->single_phase[1][idx ++] = 256;
    coeff->single_phase[1][idx ++] = 0;
    coeff->single_phase[1][idx ++] = 0;

    if (VX_INTERPOLATION_BILINEAR == interpolation)
    {
        idx = 0;
        for(i=0; i<32; i++)
        {
            weight = i<<2;
            coeff->multi_phase[0][idx ++] = 0;
            coeff->multi_phase[0][idx ++] = 0;
            coeff->multi_phase[0][idx ++] = 256-weight;
            coeff->multi_phase[0][idx ++] = weight;
            coeff->multi_phase[0][idx ++] = 0;
        }
        idx = 0;
        for(i=0; i<32; i++)
        {
            weight = (i+32)<<2;
            coeff->multi_phase[1][idx ++] = 0;
            coeff->multi_phase[1][idx ++] = 0;
            coeff->multi_phase[1][idx ++] = 256-weight;
            coeff->multi_phase[1][idx ++] = weight;
            coeff->multi_phase[1][idx ++] = 0;
        }
        idx = 0;
        for(i=0; i<32; i++)
        {
            weight = i<<2;
            coeff->multi_phase[2][idx ++] = 0;
            coeff->multi_phase[2][idx ++] = 0;
            coeff->multi_phase[2][idx ++] = 256-weight;
            coeff->multi_phase[2][idx ++] = weight;
            coeff->multi_phase[2][idx ++] = 0;
        }
        idx = 0;
        for(i=0; i<32; i++)
        {
            weight = (i+32)<<2;
            coeff->multi_phase[3][idx ++] = 0;
            coeff->multi_phase[3][idx ++] = 0;
            coeff->multi_phase[3][idx ++] = 256-weight;
            coeff->multi_phase[3][idx ++] = weight;
            coeff->multi_phase[3][idx ++] = 0;
        }
    }
    else /* STR_VX_INTERPOLATION_NEAREST_NEIGHBOR */
    {
        idx = 0;
        for(i=0; i<32; i++)
        {
            coeff->multi_phase[0][idx ++] = 0;
            coeff->multi_phase[0][idx ++] = 0;
            coeff->multi_phase[0][idx ++] = 256;
            coeff->multi_phase[0][idx ++] = 0;
            coeff->multi_phase[0][idx ++] = 0;
        }
        idx = 0;
        for(i=0; i<32; i++)
        {
            coeff->multi_phase[1][idx ++] = 0;
            coeff->multi_phase[1][idx ++] = 0;
            coeff->multi_phase[1][idx ++] = 0;
            coeff->multi_phase[1][idx ++] = 256;
            coeff->multi_phase[1][idx ++] = 0;
        }
        idx = 0;
        for(i=0; i<32; i++)
        {
            coeff->multi_phase[2][idx ++] = 0;
            coeff->multi_phase[2][idx ++] = 0;
            coeff->multi_phase[2][idx ++] = 256;
            coeff->multi_phase[2][idx ++] = 0;
            coeff->multi_phase[2][idx ++] = 0;
        }
        idx = 0;
        for(i=0; i<32; i++)
        {
            coeff->multi_phase[3][idx ++] = 0;
            coeff->multi_phase[3][idx ++] = 0;
            coeff->multi_phase[3][idx ++] = 0;
            coeff->multi_phase[3][idx ++] = 256;
            coeff->multi_phase[3][idx ++] = 0;
        }
    }
}



static void scale_set_output_params(tivx_vpac_msc_output_params_t *params,
    uint32_t interpolation, uint32_t iw, uint32_t ih, uint32_t ow, uint32_t oh)
{


    params->signed_data = 0;
    params->filter_mode = 1; // Multi-phase scaling
    params->coef_shift = 8;
    params->saturation_mode = 0;
    params->offset_x = 0;
    params->offset_y = 0;
    //params->output_align_12bit =
    params->multi_phase.phase_mode = 0;
    params->multi_phase.horz_coef_sel = 0;
    params->multi_phase.vert_coef_sel = 0;

    if (VX_INTERPOLATION_BILINEAR == interpolation)
    {
        params->multi_phase.init_phase_x =
                    (((((float)iw/(float)ow) * 0.5f) - 0.5f) * 4096.0f) + 0.5f;



		
        params->multi_phase.init_phase_y =
                    (((((float)ih/(float)oh) * 0.5f) - 0.5f) * 4096.0f) + 0.5f;

		printf("init_phase_x %d init_phase_y %d \n", params->multi_phase.init_phase_x, params->multi_phase.init_phase_y);
		if(params->multi_phase.init_phase_x > 4095)
			params->multi_phase.init_phase_x = 4095;
		if(params->multi_phase.init_phase_y > 4095)
			params->multi_phase.init_phase_y = 4095;
    }
    else
    {
        params->multi_phase.init_phase_x = 0;

        params->multi_phase.init_phase_y = 0;
    }
}



vx_status tivx_utils_node_perf_print(vx_node node)
{
    vx_status status = (vx_status)VX_SUCCESS;
    vx_perf_t node_perf;
    vx_char *node_name;
    char target_name[TIVX_TARGET_MAX_NAME];

    if(node!=NULL)
    {
        status = vxQueryReference((vx_reference)node, (vx_enum)VX_REFERENCE_NAME, &node_name, sizeof(vx_char*));
        if(status==(vx_status)VX_SUCCESS)
        {
            status = vxQueryNode(node, (vx_enum)TIVX_NODE_TARGET_STRING, target_name, TIVX_TARGET_MAX_NAME);
            if(status==(vx_status)VX_SUCCESS)
            {
                status = vxQueryNode(node, (vx_enum)VX_NODE_PERFORMANCE, &node_perf, sizeof(vx_perf_t));
                if(status==(vx_status)VX_SUCCESS)
                {
                    printf(" NODE: %10s: %24s:\n",
                        target_name,
                        node_name);
                }

            }
        }
    }
    else
    {
        VX_PRINT(VX_ZONE_ERROR, "invalid node object\n");
        status = (vx_status)VX_FAILURE;
    }
    return status;
}


vx_status tivx_utils_graph_perf_print(vx_graph graph)
{
    vx_status status = (vx_status)VX_SUCCESS;
    uint32_t num_nodes, i;
    vx_perf_t graph_perf;
    vx_char *graph_name;

    status = vxQueryReference((vx_reference)graph, (vx_enum)VX_REFERENCE_NAME, &graph_name, sizeof(vx_char*));
    if(status==(vx_status)VX_SUCCESS)
    {
        status = vxQueryGraph(graph, (vx_enum)VX_GRAPH_PERFORMANCE, &graph_perf, sizeof(vx_perf_t));
        if(status==(vx_status)VX_SUCCESS)
        {
            status = vxQueryGraph(graph, (vx_enum)VX_GRAPH_NUMNODES, &num_nodes, sizeof(vx_uint32));
            if(status==(vx_status)VX_SUCCESS)
            {
                printf("GRAPH: %16s (#nodes = %3d, #executions = %6d)\n", graph_name, num_nodes, (uint32_t)graph_perf.num);

                for(i=0; i<num_nodes; i++)
                {
                    vx_node node = tivxGraphGetNode(graph, i);

                    tivx_utils_node_perf_print(node);
                }
                printf("\n");
            }
        }
    }

    return status;
}

My images infomations create By INT32 graph_scaler_imgInit(hat_scaler_obj_t* obj) API, see<insert code>

and My graph running By graph_scaler_process API,

Can you help me to check some errors about my code ？ I program my code by refering to ti basic demo。

0 Brijesh Jadav over 2 years ago in reply to xin alex

TI__Guru**** 398250 points

Hi,

As such, I don't see error in the attached code. Also not sure currently why valid roi is getting changed. I checked MSC code and color convert nodes, they are not updating this rectangle, so must be done somewhere in the framework and will require some more time to figure out.

Meanwhile, could you explain what exactly issue that you are facing? are you not getting correct output from MSC or from color convert node?

Regards,

Brijesh

0 xin alex over 2 years ago in reply to Brijesh Jadav

Intellectual 506 points

Hi ti expert，

Yes, I have some problems about this code。 Image RGB24 1 is the result of my code , But my expected image is Image 2 RGB24 As Flow:

0 Brijesh Jadav over 2 years ago in reply to xin alex

TI__Guru**** 398250 points

Hi Alex,

Can you try removing crop configuration from the attached code?

Regards,

Brijesh

0 xin alex over 2 years ago in reply to Brijesh Jadav

Intellectual 506 points

Hi ，

I create the object of crop, But I didn't run this configuration by tivxNodeSendCommand API

0 xin alex over 2 years ago in reply to Brijesh Jadav

Intellectual 506 points

Hi TI expert，

I found ROI changed By tivxAddKernelVpacMscScaleInitialize API,

This API configs input and output roi param By vx_status tivxKernelConfigValidRect(tivxKernelValidRectParams *prms);

tivxKernelConfigValidRect API compare input and output roi param and get the minimum roi data, then, set this minimum roi data to all my output image roi param. code as folw:

vx_status tivxKernelConfigValidRect(tivxKernelValidRectParams *prms)
{
    vx_status status = (vx_status)VX_SUCCESS;
    vx_rectangle_t out_rect, rect;
    vx_uint32 i;

    if (NULL == prms)
    {
        status = (vx_status)VX_FAILURE;
    }
    else
    {
        if ((prms->num_input_images >
                TIVX_KERNEL_COMMON_VALID_RECT_MAX_IMAGE) ||
            (prms->num_output_images >
                TIVX_KERNEL_COMMON_VALID_RECT_MAX_IMAGE))
        {
                status = (vx_status)VX_FAILURE;
        }

        for (i = 0; i < prms->num_input_images; i ++)
        {
            if (NULL == prms->in_img[i])
            {
                status = (vx_status)VX_FAILURE;
                break;
            }
        }
        for (i = 0; i < prms->num_output_images; i ++)
        {
            if (NULL == prms->out_img[i])
            {
                status = (vx_status)VX_FAILURE;
                break;
            }
        }
    }

    if ((vx_status)VX_SUCCESS == status)
    {
        out_rect.start_y = 0;
        out_rect.start_x = 0;
        out_rect.end_y = 0xFFFFFFFFU;
        out_rect.end_x = 0xFFFFFFFFU;

        for (i = 0; i < prms->num_input_images; i ++)
        {
            status = vxGetValidRegionImage(prms->in_img[i], &rect);

            if ((vx_status)VX_SUCCESS != status)
            {
                break;
            }
            else
            {
                if (rect.start_x > out_rect.start_x)
                {
                    out_rect.start_x = rect.start_x;
                }
                if (rect.start_y > out_rect.start_y)
                {
                    out_rect.start_y = rect.start_y;
                }

                if (rect.end_x < out_rect.end_x)
                {
                    out_rect.end_x = rect.end_x;
                }
                if (rect.end_y < out_rect.end_y)
                {
                    out_rect.end_y = rect.end_y;
                }

            }
        }
        for (i = 0; (i < prms->num_output_images) && ((vx_status)VX_SUCCESS == status); i ++)
        {
            status = vxGetValidRegionImage(prms->out_img[i], &rect);

            if ((vx_status)VX_SUCCESS != status)
            {
                break;
            }
            else
            {			
                if (rect.start_x > out_rect.start_x)
                {
                    out_rect.start_x = rect.start_x;
                }
                if (rect.start_y > out_rect.start_y)
                {
                    out_rect.start_y = rect.start_y;
                }

                if (rect.end_x < out_rect.end_x)
                {
                    out_rect.end_x = rect.end_x;
                }
                if (rect.end_y < out_rect.end_y)
                {
                    out_rect.end_y = rect.end_y;
                }				
				
            }
        }
    }

    if ((vx_status)VX_SUCCESS == status)
    {
        if ((vx_enum)VX_BORDER_UNDEFINED == prms->border_mode)
        {
            out_rect.start_x += prms->left_pad;
            out_rect.start_y += prms->top_pad;
            out_rect.end_x -= prms->right_pad;
            out_rect.end_y -= prms->bot_pad;
        }

        for (i = 0; i < prms->num_output_images; i ++)
        {
  
            status = vxSetImageValidRectangle(prms->out_img[i], &out_rect);

            if ((vx_status)VX_SUCCESS != status)
            {
                break;
            }
        }

    }
    return (status);
}

Why does tiopevx tivxAddKernelVpacMscScaleInitialize API Chages this param ？

0 Brijesh Jadav over 2 years ago in reply to xin alex

TI__Guru**** 398250 points

Hi Alex,

Yes, this does not look correct. It should not change valid roi to minimum of all. Can you please try comment out call to this API?

Regards,

Brijesh

0 xin alex over 2 years ago in reply to Brijesh Jadav

Intellectual 506 points

Hi Ti expert，

Yes, I tried to comment out call to this API and the result of convert image is normal

+1 Brijesh Jadav over 2 years ago in reply to xin alex

TI__Guru**** 398250 points

Hi Alex,

ok, i have raised this issue and will try get it fixed in the next release.

Please close the thread if you think this issue is resolved.

Regards,

Brijesh

Processors

Processors forum

TDA4VM: tiovx convert