TDA4VM: How to crop the image on PSDK-8.2 ?

#include "hal_fmt_cnv_module.h"

vx_status hal_init_fmt_conv(vx_context context, FmtConvObj* fmtObj,CaptureObj *captureObj, vx_uint32 width, vx_uint32 height, vx_size num_ch,
                            vx_uint8 bufq_depth)
{
    vx_status status = VX_SUCCESS;
    vx_image  out_img;
    vx_image input_img;

    fmtObj->num_ch = num_ch;
    printf("[FMT-CONV-MODULE]: Num Channels %d WxH %dx%d\n", (int)(num_ch), width, height);

    vx_image input_img_raw;
    vx_uint32 inwidth, inheight;
    vx_rectangle_t rect;
    vx_df_image df;


    for (vx_int32 ch = 0; ch < num_ch; ch++)
    {
	    input_img_raw = (vx_image)vxGetObjectArrayItem((vx_object_array)captureObj->raw_image_arr[0], ch);

	    vxQueryImage(input_img_raw, VX_IMAGE_WIDTH, &inwidth, sizeof(vx_uint32));
	    vxQueryImage(input_img_raw, VX_IMAGE_HEIGHT, &inheight, sizeof(vx_uint32));
	    vxQueryImage(input_img_raw, VX_IMAGE_FORMAT, &df, sizeof(vx_df_image));

	    rect.start_x = 0;
	    rect.start_y = 300;
	    rect.end_x = inwidth;
	    rect.end_y = inheight;

	    printf("B4:ROI-Cap_%d: width =%d, height =%d, out format =  %d\n",ch, inwidth, inheight, df);
	    input_img = vxCreateImageFromROI(input_img_raw, &rect);
	    status  = vxGetStatus((vx_reference)input_img);
	    if (status == VX_SUCCESS)
	    {
        for (vx_int32 q = 0; q < bufq_depth; q++)
        {
		    fmtObj->in_arr[q] = vxCreateObjectArray(context, (vx_reference)input_img, fmtObj->num_ch);
		    status             = vxGetStatus((vx_reference)fmtObj->in_arr[q]);
		    if (status != VX_SUCCESS)
		    {
			    printf("[FMT-CONV-MODULE] Unable to create fmt input_image object array! \n");
			    break;
		    }
		    else
		    {
			    vx_char name[VX_MAX_REFERENCE_NAME];
			    snprintf(name, VX_MAX_REFERENCE_NAME, "fmt_in_arr_%d", q);
			    //vxSetReferenceName((vx_reference)fmtObj->in_arr, "fmtconv_in_arr");
			    vxSetReferenceName((vx_reference)fmtObj->in_arr[q], name);
		    }
	}
		    vxReleaseImage(&input_img_raw);
		    vxReleaseImage(&input_img);

	    }else{
		    printf("[FMT-CONV-MODULE] Unable to create input image template! \n");
	    }
    }

    out_img = vxCreateImage(context, width, height, fmtObj->color_format);
    status  = vxGetStatus((vx_reference)out_img);

    if (status == VX_SUCCESS)
    {
        for (vx_int32 q = 0; q < bufq_depth; q++)
        {
            fmtObj->out_arr[q] = vxCreateObjectArray(context, (vx_reference)out_img, fmtObj->num_ch);
            status             = vxGetStatus((vx_reference)fmtObj->out_arr[q]);
            if (status != VX_SUCCESS)
            {
                printf("[FMT-CONV-MODULE] Unable to create fmt image object array! \n");
                break;
            }
            else
            {
                vx_char name[VX_MAX_REFERENCE_NAME];

                snprintf(name, VX_MAX_REFERENCE_NAME, "fmt_arr_%d", q);

                vxSetReferenceName((vx_reference)fmtObj->out_arr[q], name);
            }
        }

        vxReleaseImage(&out_img);

        if (status == VX_SUCCESS)
        {
            tivx_display_m2m_params_init(&fmtObj->m2m_params);
            fmtObj->m2m_params.instId = 0u;
            /* Only one pipeline is supported */
            fmtObj->m2m_params.numPipe    = 1u;
            fmtObj->m2m_params.pipeId[0U] = 3u;
            fmtObj->m2m_params.overlayId  = 3u;

            fmtObj->m2m_obj = vxCreateUserDataObject(context, "tivx_display_m2m_params_t",
                                                     sizeof(tivx_display_m2m_params_t), &fmtObj->m2m_params);

            status = vxGetStatus((vx_reference)fmtObj->m2m_obj);
            if (status != VX_SUCCESS)
            {
                printf("[FMT-CONV-MODULE] Unable to create m2m object! \n");
            }
        }
    }
    else
    {
        printf("[FMT-CONV-MODULE] Unable to create output image template! \n");
    }

    return status;
}

void hal_deinit_fmt_conv(FmtConvObj* obj, vx_uint8 bufq_depth)
{
    vxReleaseUserDataObject(&obj->m2m_obj);
    for (vx_int32 q = 0; q < bufq_depth; q++)
    {
        vxReleaseObjectArray(&obj->in_arr[q]);
        //vxReleaseObjectArray(&obj->in_arr);
        vxReleaseObjectArray(&obj->out_arr[q]);
    }
}

void hal_delete_fmt_conv(FmtConvObj* obj)
{
    if (obj->node != NULL)
    {
        vxReleaseNode(&obj->node);
    }
}

vx_status hal_create_graph_fmt_conv(vx_graph graph, FmtConvObj* obj, vx_uint8 buff_idx)
{
    vx_status status = VX_SUCCESS;
    vx_image  input, output;
    vx_bool   replicate[] = {vx_false_e, vx_true_e, vx_true_e};

    if (obj->in_arr[buff_idx] != NULL)
    {
	    input = (vx_image)vxGetObjectArrayItem((vx_object_array)obj->in_arr[buff_idx], 0);
    }

    if (obj->out_arr[buff_idx] != NULL)
    {
        output = (vx_image)vxGetObjectArrayItem((vx_object_array)obj->out_arr[buff_idx], 0);
    }

    obj->node = tivxDisplayM2MNode(graph, obj->m2m_obj, input, output);
    status    = vxGetStatus((vx_reference)obj->node);

    if (status == VX_SUCCESS)
    {
        vxSetNodeTarget(obj->node, VX_TARGET_STRING, TIVX_TARGET_DISPLAY_M2M1);
        vxSetReferenceName((vx_reference)obj->node, "FmtConvNode");

        vxReplicateNode(graph, obj->node, replicate, 3);
    }
    else
    {
        printf("[FMT-CONV-MODULE] Unable to create scaler node! \n");
    }

    vxReleaseImage(&input);
    vxReleaseImage(&output);

    return status;
}