This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

TDA4VM: TDA4VM: How to use different coefficients in MSC

Part Number: TDA4VM

Hello, TI expert.

I was previously using Nearest neighbor with coefficient to resize MSC.
However, to use DOF, I found that I need to use a pyramid coefficient to make it work properly (TIVX_VPAC_MSC_CMD_SET_COEFF).
If I use TIVX_VPAC_MSC_CMD_SET_COEFF to set the coefficient of the MSC to use DOF, the problem occurs because the MSC does not use the nearest neighbor when resizing.

Is there a good way to solve this situation?

Thanks,

best regards.

  • Hi,

    Sorry, did not get the exact question. What exactly problem are you seeing after changing MSC coefficients?  Coefficients can be changed and then you need to configure MSC scalar to make use of the new coefficients. 

    Regards,

    Brijesh

  • Hi Brijesh,

    In the existing MSC, multi_phase of tivx_vpac_msc_coefficients_t struct variable was set to NN resizer coefficient.
    However, in order to use DOF normally, I had to set the pyramid coefficient in pyramid_node to TIVX_VPAC_MSC_CMD_SET_COEFF to check the normal behavior.
    Since I use both MSC and DOF, when I set TIVX_VPAC_MSC_CMD_SET_COEFF for DOF, the multi_phase of tivx_vpac_msc_coefficients_t struct variable is changing the NN resizer coefficient in the existing MSC.
    Let me know if you need more information.

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    ok, as i understand, you are MSC at two places, one for generating pyramid for DOF processing and the other for scaling operation. For the scaling operation, you require NN coefficients, but pyramid generation, you require different coefficients. Please confirm if this is correct understanding. 

    Yes, this is possible. Scalar supports multiple sets of coefficients and for each scaling operation, we can select the coefficients. so you can configure coefficients set 0 to NN coefficients and probably set1 for the other coefficients and then scalar can choose set0 or set1 coefficients. 

    Regards,

    Brijesh

  • Hi Brijesh,

    You are correct in your understanding.
    You said you can set0, set1 the coefficient of the scaler, can you give me a code example of how to do that?

    Regards,

    Hyeonseong

  • Hi,

    As we can see in below structure, there are multiple sets of coefficients that we can set using the same control command

    typedef struct {
    /*! 2 Sets of Single phase coefficient set 0, signed 10-bit */
    int32_t single_phase[TIVX_VPAC_MSC_MAX_SP_COEFF_SET][TIVX_VPAC_MSC_MAX_TAP];
    /*! 4 Sets of Multi phase coefficient, signed 10-bit */
    int32_t multi_phase[TIVX_VPAC_MSC_MAX_MP_COEFF_SET]
    [TIVX_VPAC_MSC_MAX_TAP*TIVX_VPAC_MSC_32_PHASE_COEFF];

    } tivx_vpac_msc_coefficients_t; 

    and then depending on the phase mode, we can select one of the scaling coefficients in the phase_params_t structure, as highlighted below. 

    typedef struct {
    /*! Multi-phase Mode, 0: 64 phases, 1: 32 phases */
    uint32_t phase_mode;
    /*! Multi-phase horizontal coefficient set selection
    * if (phase_mode == 0)
    * 0: 32 phase coefficient sets 0 & 1
    * 2: 32 phase coefficient sets 2 & 3
    * 1&3 : reserved
    * else
    * 32 phase coefficient set [Range (0-3)]
    */
    uint32_t horz_coef_sel;
    /*! Multi-phase vertical coefficient set selection
    * if (phase_mode == 0)
    * 0: 32 phase coefficient sets 0 & 1
    * 2: 32 phase coefficient sets 2 & 3
    * 1&3 : reserved
    * else
    * 32 phase coefficient set [Range (0-3)]
    */
    uint32_t vert_coef_sel;
    /*! Multi-phase initial horizontal resize phase (U12Q12):
    * Used to align center tap if filter to appropriate input for first output [Range (0-4095, or TIVX_VPAC_MSC_AUTOCOMPUTE)]
    * \see tivx_vpac_msc_output_params_t::offset_x
    * \note Using TIVX_VPAC_MSC_AUTOCOMPUTE aligns center of output to match center of input cropped region for each output */
    uint32_t init_phase_x;
    /*! Multi-phase initial vertical resize phase (U12Q12):
    * Used to align center tap if filter to appropriate input for first output [Range (0-4095, or TIVX_VPAC_MSC_AUTOCOMPUTE)]
    * \see tivx_vpac_msc_output_params_t::offset_y
    * \note Using TIVX_VPAC_MSC_AUTOCOMPUTE aligns center of output to match center of input cropped region for each output */
    uint32_t init_phase_y;
    } tivx_vpac_msc_multi_phase_params_t;

    Regards,

    Brijesh

  • Hi,

    As shown in the attached image, I want to use nn resizer coefficient for scaler node 0,1 and pyramid node for pyramid coefficient.
    And currently, to set the pyramid coefficient to the pyramid node, I am using tivxNodeSendCommand in the prologue of ovx graph.
    For our use case, we are using it like this. Is it possible to solve it in our usecase with the multiple sets of coefficients method you mentioned?
    If it can be solved, how should we configure it with tivx_vpac_msc_multi_phase_params_t to solve it? I've looked through the TI sample code but didn't find any code that uses tivx_vpac_msc_multi_phase_params_t.
    Currently we are using tivx_vpac_msc_coefficients_t to control the msc.

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    As i said, you can set the two sets of the scaling coefficients either in core0, core1 or in pyramid node. or you can set same set coefficients sets in all of them and then change the scaling parameters to use appropriate set in each node. This is possible and supported in the SDK.

     

    Regards,

    Brijesh

  • Hi,

    tivx_vpac_msc_coefficients_t msc_pym_coeff = {};
    
    // resize : Nearest neighbor
    int32_t coeff_value[TIVX_VPAC_MSC_MAX_MP_COEFF_SET][TIVX_VPAC_MSC_MAX_TAP] = {
        {0, 0, 256, 0, 0},
        {0, 0, 0, 256, 0},
        {0, 0, 256, 0, 0},
        {0, 0, 0, 256, 0},
    };
    
    for (uint32_t set_idx = 0; set_idx < TIVX_VPAC_MSC_MAX_MP_COEFF_SET; set_idx++) {
        for (uint32_t phase_idx = 0; phase_idx < TIVX_VPAC_MSC_32_PHASE_COEFF; phase_idx++) {
            memcpy(&(msc_pym_coeff.multi_phase[0][phase_idx * TIVX_VPAC_MSC_MAX_TAP]), &coeff_value[0][0], sizeof(int32_t) * TIVX_VPAC_MSC_MAX_TAP);
            memcpy(&(msc_pym_coeff.multi_phase[1][phase_idx * TIVX_VPAC_MSC_MAX_TAP]), &coeff_value[1][0], sizeof(int32_t) * TIVX_VPAC_MSC_MAX_TAP);
        }
    }
    
    int32_t gmsc_32_phase_gaussian_filter[] {
                    15,  63,  100, 63, 15,
                    14,  61,  100, 65, 16,
                    13,  59,  100, 67, 17,
                    12,  58,  99, 69, 18,
                    11,  56,  99, 71, 19,
                    11,  54,  99, 72, 20,
                    10,  52,  99, 74, 21,
                    10,  50,  98, 76, 22,
                    9,  49,  97, 78, 23,
                    9,  47,  97, 79, 24,
                    8,  45,  96, 81, 26,
                    8,  44,  95, 82, 27,
                    7,  42,  94, 84, 29,
                    6,  41,  93, 86, 30,
                    6,  39,  92, 88, 31,
                    6,  36,  92, 89, 33,
                    5,  34,  91, 91, 35,
                    5,  33,  90, 92, 36,
                    5,  32,  88, 93, 38,
                    4,  31,  86, 94, 41,
                    4,  29,  85, 95, 43,
                    4,  27,  84, 97, 44,
                    4,  26,  82, 98, 46,
                    3,  25,  81, 99, 48,
                    3,  24,  79, 100, 50,
                    3,  23,  77, 101, 52,
                    2,  22,  76, 102, 54,
                    2,  21,  75, 102, 56,
                    2,  20,  73, 103, 58,
                    2,  19,  72, 104, 59,
                    2,  18,  69, 105, 62,
                    2,  17,  68, 105, 64
                };
    
    for (uint32_t i = 0; i < (32u * 5u); i++) {
        // coeff->multi_phase[0][i] = gmsc_32_phase_gaussian_filter[i];
        // coeff->multi_phase[1][i] = gmsc_32_phase_gaussian_filter[i];
        msc_pym_coeff.multi_phase[2][i] = gmsc_32_phase_gaussian_filter[i];
        msc_pym_coeff.multi_phase[3][i] = gmsc_32_phase_gaussian_filter[i];
    }

    I set the NN resizer coefficients on indices 0,1 in MSC_PYM_COEFF and GMS_C_32_PHASE_GAUSSIAN_FILTER on indices 2,3.

    pyramid_coeff_ = vxCreateUserDataObject(context, "tivx_vpac_msc_coefficients_t", sizeof(tivx_vpac_msc_coefficients_t), &msc_pym_coeff);
    status = vxGetStatus((vx_reference)pyramid_coeff_);
    if (status != VX_SUCCESS) {
        return status;
    }
    vxSetReferenceName((vx_reference)pyramid_coeff_, "pyramid_coeff");
    
    tivx_vpac_msc_output_params_t output_params[1];
    tivx_vpac_msc_output_params_init(&output_params[0]);
    
    output_params[0].signed_data = 0;
    output_params[0].filter_mode = 1; // Multi-phase scaling
    output_params[0].coef_shift = 8;
    output_params[0].saturation_mode = 0;
    output_params[0].offset_x = 0;
    output_params[0].offset_y = 0;
    //output_params[0].output_align_12bit =
    output_params[0].multi_phase.phase_mode = 0;
    output_params[0].multi_phase.horz_coef_sel = 2;
    output_params[0].multi_phase.vert_coef_sel = 2;
    // output_params[0].multi_phase.init_phase_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
    // output_params[0].multi_phase.init_phase_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
    output_params[0].multi_phase.init_phase_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
    output_params[0].multi_phase.init_phase_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
    
    /* Set Output params */
    for (int32_t cnt = 0; cnt < 1; cnt++) {
        output_obj[cnt] = vxCreateUserDataObject(context,
                          "tivx_vpac_msc_output_params_t",
                          sizeof(tivx_vpac_msc_output_params_t), NULL),
                          (enum vx_type_e)VX_TYPE_USER_DATA_OBJECT;
    
        vxCopyUserDataObject(output_obj[cnt], 0,
                             sizeof(tivx_vpac_msc_output_params_t), &output_params[cnt], VX_WRITE_ONLY,
                             VX_MEMORY_TYPE_HOST);
    
        output_refs[cnt] = (vx_reference)output_obj[cnt];
    }

    -> Is it correct that if I set output_params[0].multi_phase.phase_mode = 0 as above, it will be set to 2,3 of msc_pym_coeff?

    vx_reference refs[1] = {(vx_reference)pyramid_coeff_};
    status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_COEFF, refs, 5u);		
    
    status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs, 1u);	

    -> TIVX_VPAC_MSC_CMD_SET_COEFF to tivxNodeSendCommand and then TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS to tivxNodeSendCommand.
    Let me know if you have any issues with the example code I wrote.

    Regards,

    Hyeonseong

  • Hi,

    With the above settings, the following message error occurs on the target board.

    6490.310621 s: VX_ZONE_ERROR:[ownContextSendControlCmd:682] Command ack message returned failure cmd_status: -1
    6490.310632 s: VX_ZONE_ERROR:[ownContextSendControlCmd:719] tivxEventWait() failed.

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    I dont understand what you are trying to do in below code. Are you trying to copy first set with only middle coefficients set to 256 and second set with only 3rd coefficient set to 256? 

    for (uint32_t set_idx = 0; set_idx < TIVX_VPAC_MSC_MAX_MP_COEFF_SET; set_idx++) {
        for (uint32_t phase_idx = 0; phase_idx < TIVX_VPAC_MSC_32_PHASE_COEFF; phase_idx++) {
            memcpy(&(msc_pym_coeff.multi_phase[0][phase_idx * TIVX_VPAC_MSC_MAX_TAP]), &coeff_value[0][0], sizeof(int32_t) * TIVX_VPAC_MSC_MAX_TAP);
            memcpy(&(msc_pym_coeff.multi_phase[1][phase_idx * TIVX_VPAC_MSC_MAX_TAP]), &coeff_value[1][0], sizeof(int32_t) * TIVX_VPAC_MSC_MAX_TAP);
        }
    }

    Also below config means you are using 64phase ?

    output_params[0].multi_phase.phase_mode = 0; /*! Multi-phase Mode, 0: 64 phases, 1: 32 phases */

    6490.310621 s: VX_ZONE_ERROR:[ownContextSendControlCmd:682] Command ack message returned failure cmd_status: -1
    6490.310632 s: VX_ZONE_ERROR:[ownContextSendControlCmd:719] tivxEventWait() failed.

    For which command is it returning error? Is it for set_ceoff or set_output_params? Are both of these commands supported in the node that you are using? 

    Regards,

    Brijesh

  • Hi Brijesh,

    for (uint32_t set_idx = 0; set_idx < TIVX_VPAC_MSC_MAX_MP_COEFF_SET; set_idx++) {
        for (uint32_t phase_idx = 0; phase_idx < TIVX_VPAC_MSC_32_PHASE_COEFF; phase_idx++) {
            memcpy(&(msc_pym_coeff.multi_phase[0][phase_idx * TIVX_VPAC_MSC_MAX_TAP]), &coeff_value[0][0], sizeof(int32_t) * TIVX_VPAC_MSC_MAX_TAP);
            memcpy(&(msc_pym_coeff.multi_phase[1][phase_idx * TIVX_VPAC_MSC_MAX_TAP]), &coeff_value[1][0], sizeof(int32_t) * TIVX_VPAC_MSC_MAX_TAP);
        }
    }

    It means the same role as the conditional below in the tivx_vpac_msc_coefficients_params_init function.

    else if((vx_enum)VX_INTERPOLATION_NEAREST_NEIGHBOR == interpolation)
        {
            idx = 0;
            for(i = 0; i < 32u; 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 < 32u; 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 < 32u; 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 < 32u; 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;
            }
        }

    I was testing the code and sent it to the wrong place.
    i used output_params[0].multi_phase.phase_mode = 1;
            output_params[0].signed_data = 1;
            output_params[0].filter_mode = 1; // Multi-phase scaling
            output_params[0].coef_shift = 8;
            output_params[0].saturation_mode = 0;
            output_params[0].offset_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
            output_params[0].offset_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
            output_params[0].output_align_12bit = 0;
            output_params[0].multi_phase.phase_mode = 1;
            output_params[0].multi_phase.horz_coef_sel = 2;
            output_params[0].multi_phase.vert_coef_sel = 2;
            output_params[0].multi_phase.init_phase_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
            output_params[0].multi_phase.init_phase_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
    
    The error command occurs when calling 
    status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs, 5u);.

    Regards,

    Hyeonseong

  • In addition

    Can Gaussian Filter for Pyramid only be used for single phase filters?

    2 additional sets of 5-tap Gaussian filter coefficients (single-phase) dedicated for Pyramid (Octave) generation. Do I need to use both set0 and set1 to do Pyramid generation?
    Or is it still possible to use NN resizer for set0 and Gaussian filter for set1 which is what I want to use?

  • Hi,

    Can Gaussian Filter for Pyramid only be used for single phase filters?

    Well, i dont know the exact coefficients to be used in this case, but i guess you can use it.

    The error command occurs when calling 

    How many levels of pyramid are you using in your code? Because pyramid node is expecting the output parameters for each pyramid level. 

    So can you make output_refs to be array of references and then probably set the same reference and pass to TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS command, like below?

    /* Set Output params */
    for (int32_t cnt = 0; cnt < 1; cnt++) {
        output_obj[cnt] = vxCreateUserDataObject(context,
                          "tivx_vpac_msc_output_params_t",
                          sizeof(tivx_vpac_msc_output_params_t), NULL),
                          (enum vx_type_e)VX_TYPE_USER_DATA_OBJECT;
    
        vxCopyUserDataObject(output_obj[cnt], 0,
                             sizeof(tivx_vpac_msc_output_params_t), &output_params[cnt], VX_WRITE_ONLY,
                             VX_MEMORY_TYPE_HOST);
    
        output_refs[cnt] = (vx_reference)output_obj[cnt];
    }
    
    for (int32_t cnt = 1; cnt < num_pyr_levels; cnt ++)
    {
        output_refs[cnt] = output_refs[0];
    }
    
    status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs, num_pyr_levels);
    

    Regards,

    Brijesh

  • Hi,

    vx_reference output_refs[5];
    vx_user_data_object output_obj[5];
    
    int32_t pyramid_level = 4;
    vx_pyramid pyr_exemplar = vxCreatePyramid(context, pyramid_level, VX_SCALE_PYRAMID_HALF, width, height, VX_DF_IMAGE_U8);
    
    tivx_vpac_msc_output_params_t output_params[5];
    tivx_vpac_msc_output_params_init(&output_params[0]);
    
    output_params[0].signed_data = 0;
    output_params[0].filter_mode = 1; // Multi-phase scaling
    output_params[0].coef_shift = 8;
    output_params[0].saturation_mode = 0;
    output_params[0].offset_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
    output_params[0].offset_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
    output_params[0].output_align_12bit = 0;
    output_params[0].multi_phase.phase_mode = 1;
    output_params[0].multi_phase.horz_coef_sel = 2;
    output_params[0].multi_phase.vert_coef_sel = 2;
    output_params[0].multi_phase.init_phase_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
    output_params[0].multi_phase.init_phase_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
    
    /* Set Output params */
    for (int32_t cnt = 0; cnt < 5; cnt++) {
        output_obj[cnt] = vxCreateUserDataObject(context,
                          "tivx_vpac_msc_output_params_t",
                          sizeof(tivx_vpac_msc_output_params_t), NULL),
                          (enum vx_type_e)VX_TYPE_USER_DATA_OBJECT;
    
        vxCopyUserDataObject(output_obj[cnt], 0,
                             sizeof(tivx_vpac_msc_output_params_t), &output_params[0], VX_WRITE_ONLY,
                             VX_MEMORY_TYPE_HOST);
    
        output_refs[cnt] = (vx_reference)output_obj[cnt];
    }
    
    status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_COEFF, refs, 5u);
    
    status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs, 4u);

    This was the code I was using.

    Should TIVX_VPAC_MSC_CMD_SET_COEFF be 4u instead of 5u in tivxNodeSendCommand?

    tivx_vpac_msc_output_params_t output_params[5];
    tivx_vpac_msc_output_params_init(&output_params[0]);
    
    output_params[0].signed_data = 0;
    output_params[0].filter_mode = 1; // Multi-phase scaling
    output_params[0].coef_shift = 8;
    output_params[0].saturation_mode = 0;
    output_params[0].offset_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
    output_params[0].offset_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
    output_params[0].output_align_12bit = 0;
    output_params[0].multi_phase.phase_mode = 1;
    output_params[0].multi_phase.horz_coef_sel = 2;
    output_params[0].multi_phase.vert_coef_sel = 2;
    output_params[0].multi_phase.init_phase_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
    output_params[0].multi_phase.init_phase_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
    
    /* Set Output params */
    for (int32_t cnt = 0; cnt < 1; cnt++) {
        output_obj[cnt] = vxCreateUserDataObject(context,
                          "tivx_vpac_msc_output_params_t",
                          sizeof(tivx_vpac_msc_output_params_t), NULL),
                          (enum vx_type_e)VX_TYPE_USER_DATA_OBJECT;
    
        vxCopyUserDataObject(output_obj[cnt], 0,
                             sizeof(tivx_vpac_msc_output_params_t), &output_params[0], VX_WRITE_ONLY,
                             VX_MEMORY_TYPE_HOST);
    
        output_refs[cnt] = (vx_reference)output_obj[cnt];
    }
    
    for (int32_t cnt = 1; cnt < pyramid_level; cnt ++) {
        output_refs[cnt] = output_refs[0];
    }
    
    status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_COEFF, refs, 5u);
    status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs, 4u);

    I modified the pyramid level as shown in the code above, but the result is the same error message.

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    Should TIVX_VPAC_MSC_CMD_SET_COEFF be 4u instead of 5u in tivxNodeSendCommand?

    no this is not required. 

    I modified the pyramid level as shown in the code above, but the result is the same error message.

    Do you mean you still see the same error for TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS control command? Is it possible to connect CCS and see where MSC is returning the error? or can we add some debug prints and see where its returning the error? 

    Can we add some debug prints in tivxVpacMscPmdSetOutputParamsCmd API in tiovx\kernels_j7\hwa\vpac_msc\vx_vpac_msc_pyramid_target.c file and see where it is returning error? 

    Regards,

    Brijesh

  • Hi Brijesh

    I'd like to share with you an error encountered in tiovx\kernels_j7\hwa\vpac_msc\vx_vpac_msc_pyramid_target.c.

      6110.859445 s:  VX_ZONE_ERROR:[ownContextSendControlCmd:682] Command ack message returned failure cmd_status: -1
      6110.859456 s:  VX_ZONE_ERROR:[ownContextSendControlCmd:719] tivxEventWait() failed.
    [MCU2_0]   6110.859257 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1790] Failed to Set Output Params
    [MCU2_0]   6110.859331 s:  VX_ZONE_ERROR:[ownTargetNodeDescNodeControl:1052] SendCommand Failed
    [MCU2_0]   6110.902496 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1009] Failed to set params
    [MCU2_0]   6110.941674 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1009] Failed to set params
    [MCU2_0]   6110.978358 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1009] Failed to set params
    

    tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs, 4u);
    then that error will not occur.

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    I think Init Phase AutoCompute is not supported for the pyramid node, so can you please change

    output_params[0].multi_phase.init_phase_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
    output_params[0].multi_phase.init_phase_y = TIVX_VPAC_MSC_AUTOCOMPUTE;

    to 

    output_params[0].multi_phase.init_phase_x = 0;
    output_params[0].multi_phase.init_phase_y = 0;

    ?

    This could be failing because value of TIVX_VPAC_MSC_AUTOCOMPUTE is 0xFFFFFFFFU, it is directly set in horzAccInit/vertAccInit and driver does not allow more than 4095 init value for these variables. 

    So can you please set them to 0x0?

    Regards,

    Brijesh

  • Hi

    Now you won't get the same error message as before.
    However, I still get the error message tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs, 4u);
    with or without the call, the result of the DOF output is the same.

            tivx_vpac_msc_output_params_t output_params[5];
            tivx_vpac_msc_output_params_init(&output_params[0]);
    
            output_params[0].signed_data = 0;
            output_params[0].filter_mode = 1; // Multi-phase scaling
            output_params[0].coef_shift = 8;
            output_params[0].saturation_mode = 0;
            output_params[0].offset_x = 0;
            output_params[0].offset_y = 0;
            output_params[0].output_align_12bit = 0;
            output_params[0].multi_phase.phase_mode = 1;
            output_params[0].multi_phase.horz_coef_sel = 2;
            output_params[0].multi_phase.vert_coef_sel = 2;
            output_params[0].multi_phase.init_phase_x = 0;
            output_params[0].multi_phase.init_phase_y = 0;
            
            int32_t pyramid_level_ = 4;
    
            /* Set Output params */
            for (int32_t cnt = 0; cnt < pyramid_level_; cnt++) {
                output_obj_[cnt] = vxCreateUserDataObject(context,
                                   "tivx_vpac_msc_output_params_t",
                                   sizeof(tivx_vpac_msc_output_params_t), NULL),
                                   (enum vx_type_e)VX_TYPE_USER_DATA_OBJECT;
    
                vxCopyUserDataObject(output_obj_[cnt], 0,
                                     sizeof(tivx_vpac_msc_output_params_t), &output_params[0], VX_WRITE_ONLY,
                                     VX_MEMORY_TYPE_HOST);
    
                output_refs_[cnt] = (vx_reference)output_obj_[cnt];
            }
            
            
    if (pyramid_node_ != nullptr && output_refs_ != nullptr) {
                for (int32_t i = 0; i < pyramid_level_; i++) {
                    refs[i] = (vx_reference)output_refs_[i];
                }
                status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, refs, pyramid_level_);
            }

    What more can I do?

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    Since you are changing pyramid node, you should see now the change in the pyramid output and so DOF output. All outputs of pyramid node now should use scalar coefficients 2 and since this coefficients are different, there should be change in the output. 

    Which MSC instance are you using for Pyramid node? We can check in the register if coefficients are being configured correctly and are being selected correctly in the scalar.. 

    Regards,

    Brijesh

  • Hi Brijesh,

    What does an MSC instance mean? Will the code below help?

            pyramid_node_ = tivxVpacMscPyramidNode(graph, input_image_, pyramid_reference_);
    
            status = vxGetStatus((vx_reference)pyramid_node_);
            if (status != VX_SUCCESS) {
                return status;
            }
            status |= vxSetNodeTarget(pyramid_node_, VX_TARGET_STRING, TIVX_TARGET_VPAC_MSC2);
            status |= vxSetReferenceName((vx_reference)pyramid_node_, "pyramid_node");

    Additionally, it seems to work for the set0, set1 settings of the output param in the MSC node.
    However, when I applied it in the same way on a pyramid node, I found that it didn't work.

    Regards,

    Hyeonseong

  • ok, i see you are using TIVX_TARGET_VPAC_MSC2, which second instance of MSC. 

    It means it will use scalar from index9. 

    In this case, after running pyramid node for a frame, can you please get below register value and share?

    (0x0F00000 + 0x1c0010 + 0x120)

    (0x0F00000 + 0x1c0010 + 0x124)

    (0x0F00000 + 0x1c0010 + 0x128)

    (0x0F00000 + 0x1c0010 + 0x12C)

    (0x0F00000 + 0x1c0010 + 0x130)

    Regards,

    Brijesh

  • Can you tell me how I can print the address value of the register?

  • Hi,

    root@j7-evm:~# devmem2 0x10C0130
    /dev/mem opened.
    Memory mapped at address 0xffffb89bd000.
    Read at address  0x010C0130 (0xffffb89bd130): 0x00000000
    
    root@j7-evm:~# devmem2 0x10C0134
    /dev/mem opened.
    Memory mapped at address 0xffff9f88c000.
    Read at address  0x010C0134 (0xffff9f88c134): 0x00000000
    /dev/mem opened.
    Memory mapped at address 0xffffb9cb0000.
    Read at address  0x010C0138 (0xffffb9cb0138): 0x00000000
    devmem2 0x10C013c
    /dev/mem opened.
    Memory mapped at address 0xffffaa9a3000.
    Read at address  0x010C013C (0xffffaa9a313c): 0x00000000
    root@j7-evm:~# devmem2 0x10C0140
    /dev/mem opened.
    Memory mapped at address 0xffffa73d9000.
    Read at address  0x010C0140 (0xffffa73d9140): 0x00000000

    Or should i use CCS to read that address value?

    Regards,

    Hyeonseong

  • At the end of the process function (tivxVpacMscPmdProcess) for the pyramid node, can you please print the values of these registers, something like below?

    VX_PRINT(VX_ZONE_ERROR, "(0x0F00000 + 0x1c0010 + 0x120) = 0x%x\n", *(volatile uint32_t *)((0x0F00000 + 0x1c0010 + 0x120)));

    Regards,

    Brijesh

  • Hi,

    The output looks like this

    [MCU2_0]  22478.725328 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F00000 + 0x1c0010 + 0x120) = 0x0
    [MCU2_0]  22478.725399 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F00000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  22478.725458 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F00000 + 0x1c0010 + 0x128) = 0x0
    [MCU2_0]  22478.725511 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F00000 + 0x1c0010 + 0x12c) = 0x0
    [MCU2_0]  22478.725565 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F00000 + 0x1c0010 + 0x130) = 0x0
    

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    Somehow it is still using same coefficients only, let me check the driver code and see if there is any issue in it.

    Regards,

    Brijesh

  • Hi,

    It looks like base address is incorrect, can you please check again with below line?

    VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x120) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x120)));

    VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x124) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x124)));

    VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x128) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x128)));

    VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x12C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x12C)));

    VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x130) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x130)));

    Regards,

    Brijesh

  • Hi,

    It seems to output the value of the address we want.

    [MCU2_0]    200.596617 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]    200.596674 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]    200.596728 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]    200.596785 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1123] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]    200.596841 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1125] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    Surprisingly, it is not using multi-phase scaling coefficients. It seems to be still using single phase coefficients. But before that, can you please confirm that one of the pyramid level size is 240x128?

    Regards,

    Brijesh

  • Hi Brijesh.

    To generate the pyramid image, I'm putting the output of msc, vx_image at 1920x1024, as input.

    Is there any other way to replace the vx_image in the nv12 image format with a vx_pyramid type?

    Changing the value of filter_mode in tivx_vpac_msc_output_params_t output_params does not seem to change the value of the register.

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    No, Pyramid type contains multiple images (vx_image), whereas vx_image is single image.. 

    Can you please do one more experiment? In the API Vhwa_m2mMscProcessReq, in the file ti-processor-sdk-rtos-j721e-evm-08_06_00_12\pdk_jacinto_08_06_00_31\packages\ti\drv\vhwa\src\drv\vhwa_m2mMscApi.c, can you please comment out below part of the code and see if it helps?

    Essentially, this code does not apply/change the configuration if the last handle was same as the current one. By commenting out this code, it will always apply the configuration for the current handle. 

                if ((instObj->lastHndlObj == qObj->hObj) &&
                    (0u == hObj->isCfgUpdated))
                {
                    /* Update MSC Height Dependent config */
                    retVal = Vhwa_m2mMscSetFrameSize(qObj, comObj, 0U);
    
                    if (FVID2_SOK == retVal)
                    {
                        /** Set the addresses, Submit the TR
                         *  Start the pipeline */
                        retVal = Vhwa_m2mMscSubmitRequest(instObj, qObj,
                                                    comObj, 0U);
                    }
                }
                else
    

    Lets see if the output changes for DOF with this change.

    Regards,

    Brijesh 

  • Hi Brijesh

    MSC doesn't seem to work properly if I just comment out the code below. I am attaching the output image.

    /* Update MSC Height Dependent config */
    retVal = Vhwa_m2mMscSetFrameSize(qObj, comObj, 0U);
                    
                    
    [MCU2_0]   1431.383436 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1110] #######################################
    [MCU2_0]   1431.383509 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]   1431.383584 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   1431.383671 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]   1431.383743 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]   1431.383799 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]   1431.383850 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1128] #######################################
    [MCU2_0]   1431.432400 s:  VX_ZONE_ERROR:[tivxVpacMscScaleProcess:838] Failed to Get Processed Request
    [MCU2_0]   1431.434549 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1110]                 

    When I also commented out the Vhwa_m2mMscSubmitRequest, the pipeline doesn't seem to create. It runs for 1 frame and then stops.

    Additionally, I call tivxNodeSendCommand with TIVX_VPAC_MSC_CMD_SET_CROP_PARAMS every frame in the pipeline, could this be a problem?

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    No, it should not be. We are just configuring MSC on every frame submission now. It should not have caused any issue. If you ignore this error of ""Failed to get prcessedRequest" in both the nodes, can you check if then it works fine?

    Regards,

    Brijesh

  • Hi Brijesh

    When you say both nodes, do you mean running on TIVX_TARGET_VPAC_MSC1 or TIVX_TARGET_VPAC_MSC2 for testing?

    If what I'm saying is correct, both MSC1 and MSC2 are not producing normal results.

    output  of TIVX_TARGET_VPAC_MSC1
    - The resulting image is not generated properly.

    [MCU2_0]   3641.619594 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1110] #######################################
    [MCU2_0]   3641.619710 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x220003
    [MCU2_0]   3641.619780 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0xc60240
    [MCU2_0]   3641.619849 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x600200
    [MCU2_0]   3641.619907 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x18001800
    [MCU2_0]   3641.619963 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x4000400
    
    [MCU2_0]   3641.620018 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x00) = 0x201088
    [MCU2_0]   3641.620073 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1118] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   3641.620128 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x08) = 0x8000f0
    [MCU2_0]   3641.620189 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1120] (0x0F000000 + 0x1c0010 + 0x0C) = 0x20002000
    [MCU2_0]   3641.620247 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x10) = 0x8000800
    [MCU2_0]   3641.620302 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1128] #######################################
    

    output  of TIVX_TARGET_VPAC_MSC2

    - Image color conversion is not working correctly.

    [MCU2_0]   4076.218090 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]   4076.218164 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   4076.218250 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]   4076.218323 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]   4076.218397 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    
    [MCU2_0]   4076.218453 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x00) = 0x220003
    [MCU2_0]   4076.218508 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1118] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   4076.218562 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]   4076.218621 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1120] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]   4076.218679 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    Brijesh is currently out of office, and will follow-up once he is back in office later this week.

    regards

    Suman

  • Hyeonseong,

    Sorry for the late reply.

    When you say, not producing correct result, do you mean the error "Failed to get prcessedRequest"? or you dont see correct output due to coefficient? 

    Also when you use MSC1, please refer to below registers

    [MCU2_0]   3641.620018 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x00) = 0x201088
    [MCU2_0]   3641.620073 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1118] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   3641.620128 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x08) = 0x8000f0
    [MCU2_0]   3641.620189 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1120] (0x0F000000 + 0x1c0010 + 0x0C) = 0x20002000
    [MCU2_0]   3641.620247 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x10) = 0x8000800

    according to above registers

    - you are using single phase coefficients for both horizontal and vertical scaling.

    - for horizontal scaling you are using coefficient set 0

    - for vertical scaling, you are using coefficient set 1

    and when you use MSC2, please refer to below registers

    [MCU2_0]   4076.218090 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]   4076.218164 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   4076.218250 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]   4076.218323 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]   4076.218397 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800

    according to above registers

    - you are using single phase coefficients for both horizontal and vertical scaling.

    - for horizontal scaling you are using coefficient set 0

    - for vertical scaling, you are using coefficient set 1

    It looks like you are still using single phase coefficients only for the both the above cases. Can you please change it to use multi-phase coefficients?

    Regards,

    Brijesh

  • Hi, Brijesh

    I'm using multiple phase factors and other configurations as shown below.

    tivx_vpac_msc_output_params_t output_params[5];
    tivx_vpac_msc_output_params_init(&output_params[0]);
    
    output_params[0].signed_data = 0;
    output_params[0].filter_mode = 1; // Multi-phase scaling
    output_params[0].coef_shift = 8;
    output_params[0].saturation_mode = 0;
    output_params[0].offset_x = 0;
    output_params[0].offset_y = 0;
    output_params[0].output_align_12bit = 0;
    
    output_params[0].multi_phase.phase_mode = 1;
    output_params[0].multi_phase.horz_coef_sel = 2;
    output_params[0].multi_phase.vert_coef_sel = 2;
    output_params[0].multi_phase.init_phase_x = 0;
    output_params[0].multi_phase.init_phase_y = 0;
    
    /* Set Output params */
    for (int32_t cnt = 0; cnt < pyramid_level_; cnt++) {
        output_obj_[cnt] = vxCreateUserDataObject(context,
                           "tivx_vpac_msc_output_params_t",
                           sizeof(tivx_vpac_msc_output_params_t), NULL),
                           (enum vx_type_e)VX_TYPE_USER_DATA_OBJECT;
    
        vxCopyUserDataObject(output_obj_[cnt], 0,
                             sizeof(tivx_vpac_msc_output_params_t), &output_params[0], VX_WRITE_ONLY,
                             VX_MEMORY_TYPE_HOST);
    
        output_refs_[cnt] = (vx_reference)output_obj_[cnt];
    }

    When I print sc_cfg from tivxVpacMscScaleSetOutputParamsCmd() in the vx_vpac_msc_multi_scale_output_target.c file, phaseMode is set to 1, as shown below.

    [MCU2_0]   8932.979778 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1456] sc_cfg->phaseMode = 1
    [MCU2_0]   8932.979834 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1457] sc_cfg->enable = 1
    [MCU2_0]   8932.979889 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1458] sc_cfg->inRoi.cropStartX = 0
    [MCU2_0]   8932.979947 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1459] sc_cfg->inRoi.cropStartY = 28
    [MCU2_0]   8932.980013 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1460] sc_cfg->inRoi.cropWidth = 1920
    [MCU2_0]   8932.980073 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1461] sc_cfg->inRoi.cropHeight = 1024
    [MCU2_0]   8932.980134 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1462] sc_cfg->outWidth = 1920
    [MCU2_0]   8932.980190 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1463] sc_cfg->outHeight = 1024
    [MCU2_0]   8932.980247 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1464] sc_cfg->horzAccInit = 0
    [MCU2_0]   8932.980303 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1465] sc_cfg->vertAccInit = 0
    [MCU2_0]   8932.980359 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1466] sc_cfg->filtMode = 1
    [MCU2_0]   8932.980415 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1467] sc_cfg->phaseMode = 1
    [MCU2_0]   8932.980473 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1468] sc_cfg->hsSpCoeffSel = 0
    [MCU2_0]   8932.980529 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1469] sc_cfg->vsSpCoeffSel = 0
    [MCU2_0]   8932.980586 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1470] sc_cfg->hsMpCoeffSel = 0
    [MCU2_0]   8932.980644 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1471] sc_cfg->vsMpCoeffSel = 0
    [MCU2_0]   8932.980702 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1472] sc_cfg->coeffShift = 8
    [MCU2_0]   8932.980759 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1473] sc_cfg->isSignedData = 0
    [MCU2_0]   8932.980817 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1474] sc_cfg->isEnableFiltSatMode = 0
    [MCU2_0]   8932.980875 s:  VX_ZONE_ERROR:[tivxVpacMscScaleSetOutputParamsCmd:1475] sc_cfg->isInterleaveFormat = 0
    [MCU2_0]   8933.382488 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1110] #######################################
    [MCU2_0]   8933.382564 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]   8933.382649 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   8933.382730 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]   8933.382814 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]   8933.382875 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]   8933.382934 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x00) = 0x220003
    [MCU2_0]   8933.383006 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1118] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   8933.383066 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]   8933.383133 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1120] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]   8933.383195 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    [MCU2_0]   8933.383251 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1128] #######################################
    [MCU2_0]   8933.438103 s:  VX_ZONE_ERROR:[tivxVpacMscScaleProcess:838] Failed to Get Processed Request
    [MCU2_0]   8933.443825 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1110] #######################################
    [MCU2_0]   8933.443901 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]   8933.443974 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   8933.444034 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]   8933.444093 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]   8933.444154 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]   8933.444216 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x00) = 0x220003
    [MCU2_0]   8933.444275 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1118] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   8933.444335 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]   8933.444396 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1120] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]   8933.444456 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    [MCU2_0]   8933.444512 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1128] #######################################
    [MCU2_0]   8933.480566 s:  VX_ZONE_ERROR:[tivxVpacMscScaleProcess:838] Failed to Get Processed Request
    [MCU2_0]   8933.486371 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1110] #######################################
    [MCU2_0]   8933.486451 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]   8933.486518 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   8933.486579 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]   8933.486638 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]   8933.486698 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]   8934.406426 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1110] #######################################
    [MCU2_0]   8934.406505 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]   8934.406578 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   8934.406653 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]   8934.406716 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]   8934.406777 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]   8934.406838 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x00) = 0x220003
    [MCU2_0]   8934.406897 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1118] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   8934.407055 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]   8934.407128 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1120] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]   8934.407188 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    

    Failed to get processedRequest" message still appears.

    I set the filter_mode and phase_mode to 1, but maybe I'm changing those values somewhere else?

    The horz_coef_sel and vert_coef_sel are printing as 0 when they should be printing as 2.

    Regards,

    Hyeonseong

  • Hi, Brijesh

    I did the following, and in the end, the register value did not change.

    23461.345082 s:  VX_ZONE_ERROR:[send_command:1033] out_param->signed_data = 0
    23461.345087 s:  VX_ZONE_ERROR:[send_command:1034] out_param->filter_mode = 1
    23461.345093 s:  VX_ZONE_ERROR:[send_command:1035] out_param->coef_shift = 8
    23461.345098 s:  VX_ZONE_ERROR:[send_command:1036] out_param->saturation_mode = 0
    23461.345104 s:  VX_ZONE_ERROR:[send_command:1037] out_param->offset_x = 0
    23461.345109 s:  VX_ZONE_ERROR:[send_command:1038] out_param->offset_y = 0
    23461.345115 s:  VX_ZONE_ERROR:[send_command:1039] out_param->output_align_12bit = 0
    23461.345120 s:  VX_ZONE_ERROR:[send_command:1040] out_param->multi_phase.phase_mode = 1
    23461.345126 s:  VX_ZONE_ERROR:[send_command:1041] out_param->multi_phase.horz_coef_sel = 2
    23461.345131 s:  VX_ZONE_ERROR:[send_command:1042] out_param->multi_phase.vert_coef_sel = 2
    23461.345136 s:  VX_ZONE_ERROR:[send_command:1043] out_param->multi_phase.init_phase_x = 0
    23461.345142 s:  VX_ZONE_ERROR:[send_command:1044] out_param->multi_phase.init_phase_y = 0
    
    -> tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs_, 4u) prints output_refs before the function.
    
    
    [MCU2_0]  23461.345499 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1786] sc_cfg->enable = 1
    [MCU2_0]  23461.345557 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1787] sc_cfg->inRoi.cropStartX = 0
    [MCU2_0]  23461.345614 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1788] sc_cfg->inRoi.cropStartY = 0
    [MCU2_0]  23461.345671 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1789] sc_cfg->inRoi.cropWidth = 1920
    [MCU2_0]  23461.345729 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1790] sc_cfg->inRoi.cropHeight = 1024
    [MCU2_0]  23461.345786 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1791] sc_cfg->outWidth = 1920
    [MCU2_0]  23461.345841 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1792] sc_cfg->outHeight = 1024
    [MCU2_0]  23461.345896 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1793] sc_cfg->horzAccInit = 0
    [MCU2_0]  23461.345949 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1794] sc_cfg->vertAccInit = 0
    [MCU2_0]  23461.346003 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1795] sc_cfg->filtMode = 1
    [MCU2_0]  23461.346058 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1796] sc_cfg->phaseMode = 1
    [MCU2_0]  23461.346112 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1797] sc_cfg->hsSpCoeffSel = 1
    [MCU2_0]  23461.346167 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1798] sc_cfg->vsSpCoeffSel = 1
    [MCU2_0]  23461.346221 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1799] sc_cfg->hsMpCoeffSel = 2
    [MCU2_0]  23461.346276 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1800] sc_cfg->vsMpCoeffSel = 2
    [MCU2_0]  23461.346330 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1801] sc_cfg->coeffShift = 8
    [MCU2_0]  23461.346384 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1802] sc_cfg->isSignedData = 0
    [MCU2_0]  23461.346440 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1803] sc_cfg->isEnableFiltSatMode = 0
    [MCU2_0]  23461.346503 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1804] sc_cfg->isInterleaveFormat = 0
    
    -> Print sc_cfg after tivxVpacMscPmdCopyOutPrmsToScCfg call in tivxVpacMscPmdSetOutputParamsCmd()

    However, the "Failed to Get processed Request" error still occurs, and the value of the MSC register does not change to the desired value.

    [MCU2_0]  23461.395827 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1110] #######################################
    [MCU2_0]  23461.395938 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]  23461.396028 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  23461.396096 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]  23461.396156 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]  23461.396214 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]  23461.396272 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]  23461.396335 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1118] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]  23461.396405 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]  23461.396483 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1120] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]  23461.396543 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    [MCU2_0]  23461.396598 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1128] #######################################
    [MCU2_0]  23461.440218 s:  VX_ZONE_ERROR:[tivxVpacMscScaleProcess:838] Failed to Get Processed Request
    [MCU2_0]  23461.445964 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1110] #######################################
    [MCU2_0]  23461.446042 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]  23461.446102 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  23461.446159 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]  23461.446217 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]  23461.446274 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]  23461.446332 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]  23461.446388 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1118] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]  23461.446445 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]  23461.446516 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1120] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]  23461.446579 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    [MCU2_0]  23461.446634 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1128] #######################################
    [MCU2_0]  23461.483048 s:  VX_ZONE_ERROR:[tivxVpacMscScaleProcess:838] Failed to Get Processed Request
    

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    This is strange, Is it possible to share this example to check it on EVM? I want to try it out on EVM and see why registers are not getting updated? or any other example i can use to reproduce this on EVM?

    Regards,

    Brijesh

  • Hi

    Should I provide an ovx graph example code with msc code that reproduces the above issue? Or can you tell me what form of code you'd like to receive?

    Regards,

    Hyeonseong

  • Yes, that would be helpful.

  • Hi Hyeonseong,

    I think i know why we are not seeing correct registers and why it is using single phase coefficients only for pyramid node.

    In this API tivxVpacMscPmdSetOutputParamsCmd, in the file ti-processor-sdk-rtos-j721e-evm-08_06_00_12\tiovx\kernels_j7\hwa\vpac_msc\vx_vpac_msc_pyramid_target.c, can you please make below small change, rebuild SDK and then try out?

    Change from

            else
            {
                VX_PRINT(VX_ZONE_ERROR, "Null User Data Object\n");
                status = (vx_status)VX_ERROR_INVALID_PARAMETERS;
            }
    
    
            if ((vx_status)VX_SUCCESS == status)
            {
                break;
            }
    

    to

            else
            {
                VX_PRINT(VX_ZONE_ERROR, "Null User Data Object\n");
                status = (vx_status)VX_ERROR_INVALID_PARAMETERS;
            }
    
    
            if ((vx_status)VX_SUCCESS != status)
            {
                break;
            }
    

    There was a typo in error checking, because of which, the multi-phase coefficients was set only for the first pyramid level and rest all were still using single phase. With the above change, you should see all levels using multi-phase coefficients. 

    Regards,

    Brijesh

  • Hi Brijesh,

    I applied the code below and ran it in target, but the result doesn't seem to have changed.

            else
            {
                VX_PRINT(VX_ZONE_ERROR, "Null User Data Object\n");
                status = (vx_status)VX_ERROR_INVALID_PARAMETERS;
            }
    
    
            if ((vx_status)VX_SUCCESS != status)
            {
                break;
            }

    output

    [MCU2_0]  33098.900701 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1193] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]  33098.900764 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1194] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  33098.900823 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1195] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]  33098.900901 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1196] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]  33098.900962 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1197] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]  33098.901018 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1199] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]  33098.901072 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1200] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]  33098.901126 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1201] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]  33098.901182 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1202] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]  33215.322878 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1203] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    -> output : not commented Vhwa_m2mMscSetFrameSize()
    
    [MCU2_0]  33463.081594 s:  VX_ZONE_ERROR:[tivxVpacMscScaleProcess:838] Failed to Get Processed Request
    [MCU2_0]  33463.086437 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1192] #######################################
    [MCU2_0]  33463.086515 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1193] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]  33463.086581 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1194] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  33463.086639 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1195] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]  33463.086701 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1196] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]  33463.086776 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1197] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]  33463.086838 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1199] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]  33463.086894 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1200] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]  33463.086952 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1201] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]  33463.087011 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1202] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]  33463.087068 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1203] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    -> -> output : comment Vhwa_m2mMscSetFrameSize()

    I've tested this, shouldn't there be a problem with this?

    print statements before and after the Fvid2_control() call as follows.in tivxVpacMscPmdSetOutputParamsCmd

    if ((vx_status)VX_SUCCESS == status)
        {
            for (cnt = 0u; cnt < msc_obj->num_pmd_levels; cnt ++)
            {
                if (NULL != usr_data_obj[cnt])
                {
                ss_idx = cnt / ss_info->num_levels;
    
                /* Scaler index within subset pyramid can be calculated
                    * by just modulo operation. */
                sc_idx = cnt % ss_info->num_levels;
    
                /* Now map scaler index to scaler config index */
                sc_idx = ss_info->sc_map_idx[sc_idx];
    
                sc_cfg = &msc_obj->msc_prms[ss_idx].mscCfg.scCfg[sc_idx];
                
                VX_PRINT(VX_ZONE_ERROR, "################## before Fvid2_control #####################\n");    
                VX_PRINT(VX_ZONE_ERROR, "ss_idx = %d sc_idx = %d\n", ss_idx, sc_idx);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->enable = %d\n", sc_cfg->enable);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropStartX = %d\n", sc_cfg->inRoi.cropStartX);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropStartY = %d\n", sc_cfg->inRoi.cropStartY);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropWidth = %d\n", sc_cfg->inRoi.cropWidth);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropHeight = %d\n", sc_cfg->inRoi.cropHeight);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->outWidth = %d\n", sc_cfg->outWidth);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->outHeight = %d\n", sc_cfg->outHeight);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->horzAccInit = %d\n", sc_cfg->horzAccInit);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->vertAccInit = %d\n", sc_cfg->vertAccInit);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->filtMode = %d\n", sc_cfg->filtMode);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->phaseMode = %d\n", sc_cfg->phaseMode);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->hsSpCoeffSel = %d\n", sc_cfg->hsSpCoeffSel);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->vsSpCoeffSel = %d\n", sc_cfg->vsSpCoeffSel);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->hsMpCoeffSel = %d\n", sc_cfg->hsMpCoeffSel);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->vsMpCoeffSel = %d\n", sc_cfg->vsMpCoeffSel);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->coeffShift = %d\n", sc_cfg->coeffShift);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->isSignedData = %d\n", sc_cfg->isSignedData);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->isEnableFiltSatMode = %d\n", sc_cfg->isEnableFiltSatMode);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->isInterleaveFormat = %d\n", sc_cfg->isInterleaveFormat);
    
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x120) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x120)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x124) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x124)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x128) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x128)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x12C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x12C)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x130) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x130)));
    
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x00) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x00)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x04) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x04)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x08) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x08)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x0C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x0C)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x10) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x10)));
    
                // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x170) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x170)));
                // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x174) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x174)));
                // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x1F0) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x1F0)));
                // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x1F4) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x1F4)));
                
                VX_PRINT(VX_ZONE_ERROR, "#######################################\n");    
                }
            }
            status = Fvid2_control(msc_obj->handle,
                VHWA_M2M_IOCTL_MSC_SET_PARAMS, &msc_obj->msc_prms, NULL);
            for (cnt = 0u; cnt < msc_obj->num_pmd_levels; cnt ++)
            {
                if (NULL != usr_data_obj[cnt])
                {
                ss_idx = cnt / ss_info->num_levels;
    
                /* Scaler index within subset pyramid can be calculated
                    * by just modulo operation. */
                sc_idx = cnt % ss_info->num_levels;
    
                /* Now map scaler index to scaler config index */
                sc_idx = ss_info->sc_map_idx[sc_idx];
    
                sc_cfg = &msc_obj->msc_prms[ss_idx].mscCfg.scCfg[sc_idx];
                
                VX_PRINT(VX_ZONE_ERROR, "################## after Fvid2_control #####################\n");    
                VX_PRINT(VX_ZONE_ERROR, "ss_idx = %d sc_idx = %d\n", ss_idx, sc_idx);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->enable = %d\n", sc_cfg->enable);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropStartX = %d\n", sc_cfg->inRoi.cropStartX);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropStartY = %d\n", sc_cfg->inRoi.cropStartY);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropWidth = %d\n", sc_cfg->inRoi.cropWidth);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropHeight = %d\n", sc_cfg->inRoi.cropHeight);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->outWidth = %d\n", sc_cfg->outWidth);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->outHeight = %d\n", sc_cfg->outHeight);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->horzAccInit = %d\n", sc_cfg->horzAccInit);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->vertAccInit = %d\n", sc_cfg->vertAccInit);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->filtMode = %d\n", sc_cfg->filtMode);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->phaseMode = %d\n", sc_cfg->phaseMode);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->hsSpCoeffSel = %d\n", sc_cfg->hsSpCoeffSel);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->vsSpCoeffSel = %d\n", sc_cfg->vsSpCoeffSel);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->hsMpCoeffSel = %d\n", sc_cfg->hsMpCoeffSel);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->vsMpCoeffSel = %d\n", sc_cfg->vsMpCoeffSel);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->coeffShift = %d\n", sc_cfg->coeffShift);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->isSignedData = %d\n", sc_cfg->isSignedData);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->isEnableFiltSatMode = %d\n", sc_cfg->isEnableFiltSatMode);
                VX_PRINT(VX_ZONE_ERROR, "sc_cfg->isInterleaveFormat = %d\n", sc_cfg->isInterleaveFormat);
    
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x120) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x120)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x124) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x124)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x128) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x128)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x12C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x12C)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x130) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x130)));
    
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x00) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x00)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x04) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x04)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x08) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x08)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x0C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x0C)));
                VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x10) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x10)));
    
                // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x170) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x170)));
                // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x174) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x174)));
                // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x1F0) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x1F0)));
                // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x1F4) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x1F4)));
                
                VX_PRINT(VX_ZONE_ERROR, "#######################################\n");    
                }
            }
            if (FVID2_SOK != status)
            {
                VX_PRINT(VX_ZONE_ERROR, "Failed to Set Output Params\n");
                status = (vx_status)VX_FAILURE;
            }
        }

    The output print looks like this

    [MCU2_0]   9166.812846 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1848] ################## before Fvid2_control #####################
    [MCU2_0]   9166.812917 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1849] ss_idx = 0 sc_idx = 9
    [MCU2_0]   9166.812971 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1850] sc_cfg->enable = 1
    [MCU2_0]   9166.813025 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1851] sc_cfg->inRoi.cropStartX = 0
    [MCU2_0]   9166.813081 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1852] sc_cfg->inRoi.cropStartY = 0
    [MCU2_0]   9166.813138 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1853] sc_cfg->inRoi.cropWidth = 1920
    [MCU2_0]   9166.813194 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1854] sc_cfg->inRoi.cropHeight = 1024
    [MCU2_0]   9166.813250 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1855] sc_cfg->outWidth = 1920
    [MCU2_0]   9166.813305 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1856] sc_cfg->outHeight = 1024
    [MCU2_0]   9166.813359 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1857] sc_cfg->horzAccInit = 0
    [MCU2_0]   9166.813413 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1858] sc_cfg->vertAccInit = 0
    [MCU2_0]   9166.813466 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1859] sc_cfg->filtMode = 1
    [MCU2_0]   9166.813519 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1860] sc_cfg->phaseMode = 1
    [MCU2_0]   9166.813573 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1861] sc_cfg->hsSpCoeffSel = 1
    [MCU2_0]   9166.813627 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1862] sc_cfg->vsSpCoeffSel = 1
    [MCU2_0]   9166.813682 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1863] sc_cfg->hsMpCoeffSel = 2
    [MCU2_0]   9166.813736 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1864] sc_cfg->vsMpCoeffSel = 2
    [MCU2_0]   9166.813791 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1865] sc_cfg->coeffShift = 8
    [MCU2_0]   9166.813852 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1866] sc_cfg->isSignedData = 0
    [MCU2_0]   9166.813907 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1867] sc_cfg->isEnableFiltSatMode = 0
    [MCU2_0]   9166.813964 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1868] sc_cfg->isInterleaveFormat = 0
    [MCU2_0]   9166.814022 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1870] (0x0F000000 + 0x1c0010 + 0x120) = 0x200000
    [MCU2_0]   9166.814082 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1871] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   9166.814141 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1872] (0x0F000000 + 0x1c0010 + 0x128) = 0x0
    [MCU2_0]   9166.814200 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1873] (0x0F000000 + 0x1c0010 + 0x12C) = 0x0
    [MCU2_0]   9166.814259 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1874] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]   9166.814318 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1876] (0x0F000000 + 0x1c0010 + 0x00) = 0x200000
    [MCU2_0]   9166.814378 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1877] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   9166.814437 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1878] (0x0F000000 + 0x1c0010 + 0x08) = 0x0
    [MCU2_0]   9166.814496 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1879] (0x0F000000 + 0x1c0010 + 0x0C) = 0x0
    [MCU2_0]   9166.814554 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1880] (0x0F000000 + 0x1c0010 + 0x10) = 0x0
    [MCU2_0]   9166.814608 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1894] #######################################
    [MCU2_0]   9166.814663 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1848] ################## before Fvid2_control #####################
    [MCU2_0]   9166.814732 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1849] ss_idx = 0 sc_idx = 8
    [MCU2_0]   9166.814785 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1850] sc_cfg->enable = 1
    [MCU2_0]   9166.814842 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1851] sc_cfg->inRoi.cropStartX = 0
    [MCU2_0]   9166.814898 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1852] sc_cfg->inRoi.cropStartY = 0
    [MCU2_0]   9166.814953 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1853] sc_cfg->inRoi.cropWidth = 1920
    [MCU2_0]   9166.815009 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1854] sc_cfg->inRoi.cropHeight = 1024
    [MCU2_0]   9166.815065 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1855] sc_cfg->outWidth = 960
    [MCU2_0]   9166.815118 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1856] sc_cfg->outHeight = 512
    [MCU2_0]   9166.815172 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1857] sc_cfg->horzAccInit = 2048
    [MCU2_0]   9166.815226 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1858] sc_cfg->vertAccInit = 2048
    [MCU2_0]   9166.815281 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1859] sc_cfg->filtMode = 0
    [MCU2_0]   9166.815333 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1860] sc_cfg->phaseMode = 0
    [MCU2_0]   9166.815387 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1861] sc_cfg->hsSpCoeffSel = 1
    [MCU2_0]   9166.815440 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1862] sc_cfg->vsSpCoeffSel = 1
    [MCU2_0]   9166.815494 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1863] sc_cfg->hsMpCoeffSel = 0
    [MCU2_0]   9166.815548 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1864] sc_cfg->vsMpCoeffSel = 0
    [MCU2_0]   9166.815603 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1865] sc_cfg->coeffShift = 8
    [MCU2_0]   9166.815657 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1866] sc_cfg->isSignedData = 0
    [MCU2_0]   9166.815711 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1867] sc_cfg->isEnableFiltSatMode = 0
    [MCU2_0]   9166.815769 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1868] sc_cfg->isInterleaveFormat = 0
    [MCU2_0]   9166.815831 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1870] (0x0F000000 + 0x1c0010 + 0x120) = 0x200000
    [MCU2_0]   9166.815892 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1871] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   9166.815951 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1872] (0x0F000000 + 0x1c0010 + 0x128) = 0x0
    [MCU2_0]   9166.816009 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1873] (0x0F000000 + 0x1c0010 + 0x12C) = 0x0
    [MCU2_0]   9166.816068 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1874] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]   9166.816126 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1876] (0x0F000000 + 0x1c0010 + 0x00) = 0x200000
    [MCU2_0]   9166.816187 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1877] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   9166.816244 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1878] (0x0F000000 + 0x1c0010 + 0x08) = 0x0
    [MCU2_0]   9166.816302 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1879] (0x0F000000 + 0x1c0010 + 0x0C) = 0x0
    [MCU2_0]   9166.816361 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1880] (0x0F000000 + 0x1c0010 + 0x10) = 0x0
    [MCU2_0]   9166.816415 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1894] #######################################
    [MCU2_0]   9166.816470 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1848] ################## before Fvid2_control #####################
    [MCU2_0]   9166.816539 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1849] ss_idx = 1 sc_idx = 9
    [MCU2_0]   9166.816593 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1850] sc_cfg->enable = 1
    [MCU2_0]   9166.816646 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1851] sc_cfg->inRoi.cropStartX = 0
    [MCU2_0]   9166.816702 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1852] sc_cfg->inRoi.cropStartY = 0
    [MCU2_0]   9166.816758 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1853] sc_cfg->inRoi.cropWidth = 960
    [MCU2_0]   9166.816817 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1854] sc_cfg->inRoi.cropHeight = 512
    [MCU2_0]   9166.816873 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1855] sc_cfg->outWidth = 480
    [MCU2_0]   9166.816927 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1856] sc_cfg->outHeight = 256
    [MCU2_0]   9166.816980 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1857] sc_cfg->horzAccInit = 2048
    [MCU2_0]   9166.817035 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1858] sc_cfg->vertAccInit = 2048
    [MCU2_0]   9166.817090 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1859] sc_cfg->filtMode = 0
    [MCU2_0]   9166.817142 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1860] sc_cfg->phaseMode = 0
    [MCU2_0]   9166.817195 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1861] sc_cfg->hsSpCoeffSel = 1
    [MCU2_0]   9166.817249 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1862] sc_cfg->vsSpCoeffSel = 1
    [MCU2_0]   9166.817303 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1863] sc_cfg->hsMpCoeffSel = 0
    [MCU2_0]   9166.817358 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1864] sc_cfg->vsMpCoeffSel = 0
    [MCU2_0]   9166.817413 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1865] sc_cfg->coeffShift = 8
    [MCU2_0]   9166.817468 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1866] sc_cfg->isSignedData = 0
    [MCU2_0]   9166.817523 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1867] sc_cfg->isEnableFiltSatMode = 0
    [MCU2_0]   9166.817579 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1868] sc_cfg->isInterleaveFormat = 0
    [MCU2_0]   9166.817636 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1870] (0x0F000000 + 0x1c0010 + 0x120) = 0x200000
    [MCU2_0]   9166.817695 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1871] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   9166.817753 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1872] (0x0F000000 + 0x1c0010 + 0x128) = 0x0
    [MCU2_0]   9166.817810 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1873] (0x0F000000 + 0x1c0010 + 0x12C) = 0x0
    [MCU2_0]   9166.817873 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1874] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]   9166.817933 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1876] (0x0F000000 + 0x1c0010 + 0x00) = 0x200000
    [MCU2_0]   9166.817992 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1877] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   9166.818050 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1878] (0x0F000000 + 0x1c0010 + 0x08) = 0x0
    [MCU2_0]   9166.818109 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1879] (0x0F000000 + 0x1c0010 + 0x0C) = 0x0
    [MCU2_0]   9166.818167 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1880] (0x0F000000 + 0x1c0010 + 0x10) = 0x0
    [MCU2_0]   9166.818221 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1894] #######################################
    [MCU2_0]   9166.818276 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1848] ################## before Fvid2_control #####################
    [MCU2_0]   9166.818345 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1849] ss_idx = 1 sc_idx = 8
    [MCU2_0]   9166.818398 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1850] sc_cfg->enable = 0
    [MCU2_0]   9166.818450 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1851] sc_cfg->inRoi.cropStartX = 0
    [MCU2_0]   9166.818505 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1852] sc_cfg->inRoi.cropStartY = 0
    [MCU2_0]   9166.818560 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1853] sc_cfg->inRoi.cropWidth = 0
    [MCU2_0]   9166.818616 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1854] sc_cfg->inRoi.cropHeight = 0
    [MCU2_0]   9166.818670 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1855] sc_cfg->outWidth = 0
    [MCU2_0]   9166.818723 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1856] sc_cfg->outHeight = 0
    [MCU2_0]   9166.818776 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1857] sc_cfg->horzAccInit = 0
    [MCU2_0]   9166.818833 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1858] sc_cfg->vertAccInit = 0
    [MCU2_0]   9166.818889 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1859] sc_cfg->filtMode = 0
    [MCU2_0]   9166.818944 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1860] sc_cfg->phaseMode = 0
    [MCU2_0]   9166.818999 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1861] sc_cfg->hsSpCoeffSel = 0
    [MCU2_0]   9166.819053 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1862] sc_cfg->vsSpCoeffSel = 0
    [MCU2_0]   9166.819107 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1863] sc_cfg->hsMpCoeffSel = 0
    [MCU2_0]   9166.819161 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1864] sc_cfg->vsMpCoeffSel = 0
    [MCU2_0]   9166.819216 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1865] sc_cfg->coeffShift = 8
    [MCU2_0]   9166.819270 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1866] sc_cfg->isSignedData = 0
    [MCU2_0]   9166.819325 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1867] sc_cfg->isEnableFiltSatMode = 0
    [MCU2_0]   9166.819382 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1868] sc_cfg->isInterleaveFormat = 0
    [MCU2_0]   9166.819439 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1870] (0x0F000000 + 0x1c0010 + 0x120) = 0x200000
    [MCU2_0]   9166.819499 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1871] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   9166.819558 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1872] (0x0F000000 + 0x1c0010 + 0x128) = 0x0
    [MCU2_0]   9166.819617 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1873] (0x0F000000 + 0x1c0010 + 0x12C) = 0x0
    [MCU2_0]   9166.819675 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1874] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]   9166.819734 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1876] (0x0F000000 + 0x1c0010 + 0x00) = 0x200000
    [MCU2_0]   9166.819794 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1877] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   9166.819858 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1878] (0x0F000000 + 0x1c0010 + 0x08) = 0x0
    [MCU2_0]   9166.819919 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1879] (0x0F000000 + 0x1c0010 + 0x0C) = 0x0
    [MCU2_0]   9166.819977 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1880] (0x0F000000 + 0x1c0010 + 0x10) = 0x0
    [MCU2_0]   9166.820032 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1894] #######################################
    [MCU2_0]   9166.820234 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1914] ################## after Fvid2_control #####################
    [MCU2_0]   9166.820316 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1915] ss_idx = 0 sc_idx = 9
    [MCU2_0]   9166.820372 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1916] sc_cfg->enable = 1
    [MCU2_0]   9166.820425 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1917] sc_cfg->inRoi.cropStartX = 0
    [MCU2_0]   9166.820480 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1918] sc_cfg->inRoi.cropStartY = 0
    [MCU2_0]   9166.820537 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1919] sc_cfg->inRoi.cropWidth = 1920
    [MCU2_0]   9166.820593 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1920] sc_cfg->inRoi.cropHeight = 1024
    [MCU2_0]   9166.820651 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1921] sc_cfg->outWidth = 1920
    [MCU2_0]   9166.820705 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1922] sc_cfg->outHeight = 1024
    [MCU2_0]   9166.820760 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1923] sc_cfg->horzAccInit = 0
    [MCU2_0]   9166.820825 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1924] sc_cfg->vertAccInit = 0
    [MCU2_0]   9166.820883 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1925] sc_cfg->filtMode = 1
    [MCU2_0]   9166.820937 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1926] sc_cfg->phaseMode = 1
    [MCU2_0]   9166.820991 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1927] sc_cfg->hsSpCoeffSel = 1
    [MCU2_0]   9166.821046 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1928] sc_cfg->vsSpCoeffSel = 1
    [MCU2_0]   9166.821101 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1929] sc_cfg->hsMpCoeffSel = 2
    [MCU2_0]   9166.821155 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1930] sc_cfg->vsMpCoeffSel = 2
    [MCU2_0]   9166.821210 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1931] sc_cfg->coeffShift = 8
    [MCU2_0]   9166.821264 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1932] sc_cfg->isSignedData = 0
    [MCU2_0]   9166.821318 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1933] sc_cfg->isEnableFiltSatMode = 0
    [MCU2_0]   9166.821375 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1934] sc_cfg->isInterleaveFormat = 0
    [MCU2_0]   9166.821432 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1936] (0x0F000000 + 0x1c0010 + 0x120) = 0x200000
    [MCU2_0]   9166.821493 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1937] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   9166.821552 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1938] (0x0F000000 + 0x1c0010 + 0x128) = 0x0
    [MCU2_0]   9166.821611 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1939] (0x0F000000 + 0x1c0010 + 0x12C) = 0x0
    [MCU2_0]   9166.821670 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1940] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]   9166.821728 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1942] (0x0F000000 + 0x1c0010 + 0x00) = 0x200000
    [MCU2_0]   9166.821789 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1943] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   9166.821856 s:  VX_ZONE_ERROR:[tivxVpacMscPmdSetOutputParamsCmd:1944] (0x0F000000 + 0x1c0010 + 0x08) = 0x0
    
    [MCU2_0]   9167.879966 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1111] (0x0F000000 + 0x1c0010 + 0x120) = 0x201088
    [MCU2_0]   9167.880033 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1112] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]   9167.880097 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1113] (0x0F000000 + 0x1c0010 + 0x128) = 0x8000f0
    [MCU2_0]   9167.880163 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1114] (0x0F000000 + 0x1c0010 + 0x12C) = 0x20002000
    [MCU2_0]   9167.880221 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1115] (0x0F000000 + 0x1c0010 + 0x130) = 0x8000800
    [MCU2_0]   9167.880279 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1117] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]   9167.880336 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1118] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]   9167.880392 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1119] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]   9167.880450 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1120] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]   9167.880510 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1121] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    For ss_idx = 0 sc_idx = 8 / ss_idx = 1 sc_idx = 9 / ss_idx = 1 sc_idx = 8, filterMode, phaseMode, hsMpCoeffSel, vsMpCoeffSel are not applied as multi phase. Could this be the problem? Perhaps all levels of pyramid level 4 are not set to multi phase.

    Regards,

    Hyeonseong

  • Hi Brijesh,

    Here is the code to generate and set the DOF, let me know if you need anything else.

    oz_vx_svnet3_ffc_post_process_node_agent.cpp

    - oz_vx_svnet3_ffc_post_process_node_agent.hpp

    #ifndef __OZ_VX_SVNET3_FFC_POST_PROCESS_NODE_AGENT_HPP__
    #define __OZ_VX_SVNET3_FFC_POST_PROCESS_NODE_AGENT_HPP__
    
    #include "oz_svnet_common/svnet_common.h"
    #include "oz_vx_svnet_kernels/tivx_svnet_nodes.h"
    #include "oz_tiovx_node_agents/oz_vx_node_agent.hpp"
    #include "oz_vx_svnet_kernels/tivx_svnet.h"
    
    namespace sv {
    namespace oz {
    
    /**
     * @brief OZ OpenVX SVNET FFC post process node agent class
     *
     */
    class OzVxSvnet3FfcPostProcessNodeAgent : public OzVxNodeAgent {
    public:
        OzVxSvnet3FfcPostProcessNodeAgent(const std::string& name = "oz_svnet3_ffc_post_process_node");
        virtual ~OzVxSvnet3FfcPostProcessNodeAgent();
    
        /**
         * The enumeration to present the parameter index.
         */
    public:
        enum ParamIdx {
            kInCreateParamsIdx     = 0,
            kInImage               = 29,
            kMaxParamIdx           = 30 // 13 + 16 + 1
        };
    
    public:
    
        /**
         * @brief Initalize post process member variables. read lbf tidl config.
         *
         * @param context The reference to the implementation context.
         * @param in_params Post process parameter in json format.
         * @param out_params Not use it.
         * @param buffer_queue_depth Required when using pipeline mode.
         * @return vx_status
         */
        virtual vx_status init_node(const vx_context context, const nlohmann::json& in_params, const nlohmann::json& out_params, int32_t buffer_queue_depth = 1);
    
        /**
         * @brief Release the post process objects created in agent.
         *
         * @return vx_status
         */
        virtual vx_status deinit_node();
    
    public:
        /**
         * @brief Create a node object, post objects output.
         *
         * @param context The reference to the implementation context.
         * @param graph The OpenVX graph variable.
         * @param prms[] Arrary of in_vehicle_status, post output objects.
         * @return vx_status
         */
        vx_status create_node(const vx_context context, const vx_graph graph, vx_reference prms[]);
    
    public:
    
    
        /**
         * @brief Set the pipeline parameters object
         *
         * @return vx_status
         */
        vx_status set_pipeline_parameters(void);
    
        enum CommandId {
            kSetMSCCoeff = 0,
            kSetMSCOutputParam = 1
        };
    
        vx_status send_command(CommandId cmd);
    
    private:
        // for dof
        vx_image input_image_;
    
        vx_status create_dof_node(const vx_context context, const vx_graph graph);
    
        int32_t pyramid_level_;
        vx_user_data_object pyramid_coeff_;
        vx_delay pyr_delay_;
        vx_pyramid pyramid_reference_;
        vx_pyramid pyramid_current_;
        vx_node pyramid_node_;
    
        vx_user_data_object dof_config_;
        vx_delay flow_vector_delay_;
        vx_image flow_vector_prev_;
        vx_image flow_vector_;
        vx_node dof_node_;
    
        vx_user_data_object bw_dof_config_;
        vx_delay bw_flow_vector_delay_;
        vx_image bw_flow_vector_prev_;
        vx_image bw_flow_vector_;
        vx_node bw_dof_node_;
    
        vx_kernel dump_kernel_;
        vx_node dump_node_;
    
        vx_reference output_refs_[4];
        vx_user_data_object output_obj_[4];
    };
    
    } // namespace oz
    } // namespace sv
    
    #endif
    

    Call set_msc_node_params() in the prologue function of the pipeline graph.

    vx_status SVOzVxGraphFfcVt::set_msc_node_params()
    {
        vx_status status = VX_SUCCESS;
    
        uint32_t num_of_core = 0;
    
        for (num_of_core = 0; num_of_core < max_num_of_msc_core_; ++num_of_core) {
            status = msc_node_agent_[num_of_core].send_command(TIVX_VPAC_MSC_CMD_SET_COEFF);
            APP_ASSERT(status == VX_SUCCESS);
    
            msc_node_agent_[num_of_core].send_command(TIVX_VPAC_MSC_CMD_SET_CROP_PARAMS);
            APP_ASSERT(status == VX_SUCCESS);
        }
    
        if (en_opfe_dof_ == kEnTrue) {
            status = sv_post_node_agent_.send_command(OzVxSvnet3FfcPostProcessNodeAgent::kSetMSCCoeff);
    
            // printf("msc_node_agent_[0].send_command(TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS)\n");
            // status = msc_node_agent_[0].send_command(TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS);
            // printf("msc_node_agent_[1].send_command(TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS)\n");
            // status = msc_node_agent_[1].send_command(TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS);
            printf("sv_post_node_agent_.send_command(OzVxSvnet3FfcPostProcessNodeAgent::kSetMSCOutputParam)\n");
            status = sv_post_node_agent_.send_command(OzVxSvnet3FfcPostProcessNodeAgent::kSetMSCOutputParam);
        }
    
        return status;
    }

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    But why do you require to map the user data object and assign its pointer, in below code?

                vx_map_id map_id = 0;
                void* data_ptr = nullptr;
                vxMapUserDataObject(output_obj_[cnt], 0, sizeof(tivx_vpac_msc_output_params_t), &map_id, &data_ptr, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0);
    
                tivx_vpac_msc_output_params_t* out_param = (tivx_vpac_msc_output_params_t*)data_ptr;
    
                output_refs_[cnt] = (vx_reference)output_obj_[cnt];
    
                status = vxUnmapUserDataObject(output_obj_[cnt], map_id);
    

    Instead of this, can you create first data object and then copy contents into it, as show below?

                output_params.signed_data = 0;
                output_params.filter_mode = 1; // Multi-phase scaling
                output_params.coef_shift = 8;
                output_params.saturation_mode = 0;
                output_params.offset_x = 0;
                output_params.offset_y = 0;
                output_params.output_align_12bit = 0;
    
                output_params.multi_phase.phase_mode = 1;
                output_params.multi_phase.horz_coef_sel = 2;
                output_params.multi_phase.vert_coef_sel = 2;
                output_params.multi_phase.init_phase_x = 0;
                output_params.multi_phase.init_phase_y = 0;
                
                /* Set Output params */
                for (int32_t cnt = 0; cnt < levels; cnt++) {
                    output_obj_[cnt] = vxCreateUserDataObject(context,
                                       "tivx_vpac_msc_output_params_t",
                                       sizeof(tivx_vpac_msc_output_params_t), NULL);
    
                    vxCopyUserDataObject(output_obj_[cnt], 0,
                                         sizeof(tivx_vpac_msc_output_params_t), &output_params, VX_WRITE_ONLY,
                                         VX_MEMORY_TYPE_HOST);
    
                    output_refs_[cnt] = (vx_reference)output_obj_[cnt];
                }
                
                tivxNodeSendCommand(node, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs_, levels);
    

    As we can see from the register dump from the earlier post, filterMode and coefficients set are not correctly selected for all pyramid levels, which means these objects are not correctly allocated or passes to the node. Can you please check this implementation? 

    Regards,

    Brijesh

  • Hi Brijesh,

    Q) But why do you require to map the user data object and assign its pointer, in below code?

    -> I added that code to make sure the output_params variables are set in the output_obj_. I put it there for debugging purposes.

    If I call vxCreateUserDataObject() like below, can I avoid the vxCopyUserDataObject() you mentioned?

    output_obj_[cnt] = vxCreateUserDataObject(context,
                                   "tivx_vpac_msc_output_params_t",
                                   sizeof(tivx_vpac_msc_output_params_t), &output_params[0]);

    Q) As we can see from the register dump from the earlier post, filterMode and coefficients set are not correctly selected for all pyramid levels, which means these objects are not correctly allocated or passes to the node. Can you please check this implementation? 

    -> When I printed out the output_refs from tivxNodeSendCommand, I saw that it was set as below. Does this answer your question?

     37949.623356 s:  VX_ZONE_ERROR:[send_command:1031] #################### tivxNodeSendCommand ###################
     37949.623367 s:  VX_ZONE_ERROR:[send_command:1032] out_param = 0xffff68f20000 output_obj_[0] = 0x2f1dd78
     37949.623374 s:  VX_ZONE_ERROR:[send_command:1033] out_param->signed_data = 0
     37949.623380 s:  VX_ZONE_ERROR:[send_command:1034] out_param->filter_mode = 1
     37949.623385 s:  VX_ZONE_ERROR:[send_command:1035] out_param->coef_shift = 8
     37949.623390 s:  VX_ZONE_ERROR:[send_command:1036] out_param->saturation_mode = 0
     37949.623396 s:  VX_ZONE_ERROR:[send_command:1037] out_param->offset_x = 0
     37949.623401 s:  VX_ZONE_ERROR:[send_command:1038] out_param->offset_y = 0
     37949.623407 s:  VX_ZONE_ERROR:[send_command:1039] out_param->output_align_12bit = 0
     37949.623412 s:  VX_ZONE_ERROR:[send_command:1040] out_param->multi_phase.phase_mode = 1
     37949.623418 s:  VX_ZONE_ERROR:[send_command:1041] out_param->multi_phase.horz_coef_sel = 2
     37949.623423 s:  VX_ZONE_ERROR:[send_command:1042] out_param->multi_phase.vert_coef_sel = 2
     37949.623450 s:  VX_ZONE_ERROR:[send_command:1043] out_param->multi_phase.init_phase_x = 0
     37949.623456 s:  VX_ZONE_ERROR:[send_command:1044] out_param->multi_phase.init_phase_y = 0
     37949.623461 s:  VX_ZONE_ERROR:[send_command:1045] #################### tivxNodeSendCommand ###################n 37949.623466 s:  VX_ZONE_ERROR:[send_command:1031] #################### tivxNodeSendCommand ###################
     37949.623473 s:  VX_ZONE_ERROR:[send_command:1032] out_param = 0xffff68f1f000 output_obj_[1] = 0x2f1df98
     37949.623478 s:  VX_ZONE_ERROR:[send_command:1033] out_param->signed_data = 0
     37949.623484 s:  VX_ZONE_ERROR:[send_command:1034] out_param->filter_mode = 1
     37949.623489 s:  VX_ZONE_ERROR:[send_command:1035] out_param->coef_shift = 8
     37949.623494 s:  VX_ZONE_ERROR:[send_command:1036] out_param->saturation_mode = 0
     37949.623499 s:  VX_ZONE_ERROR:[send_command:1037] out_param->offset_x = 0
     37949.623504 s:  VX_ZONE_ERROR:[send_command:1038] out_param->offset_y = 0
     37949.623509 s:  VX_ZONE_ERROR:[send_command:1039] out_param->output_align_12bit = 0
     37949.623515 s:  VX_ZONE_ERROR:[send_command:1040] out_param->multi_phase.phase_mode = 1
     37949.623520 s:  VX_ZONE_ERROR:[send_command:1041] out_param->multi_phase.horz_coef_sel = 2
     37949.623525 s:  VX_ZONE_ERROR:[send_command:1042] out_param->multi_phase.vert_coef_sel = 2
     37949.623530 s:  VX_ZONE_ERROR:[send_command:1043] out_param->multi_phase.init_phase_x = 0
     37949.623535 s:  VX_ZONE_ERROR:[send_command:1044] out_param->multi_phase.init_phase_y = 0
     37949.623540 s:  VX_ZONE_ERROR:[send_command:1045] #################### tivxNodeSendCommand ###################n 37949.623544 s:  VX_ZONE_ERROR:[send_command:1031] #################### tivxNodeSendCommand ###################
     37949.623551 s:  VX_ZONE_ERROR:[send_command:1032] out_param = 0xffff68f1e000 output_obj_[2] = 0x2f1e1b8
     37949.623557 s:  VX_ZONE_ERROR:[send_command:1033] out_param->signed_data = 0
     37949.623562 s:  VX_ZONE_ERROR:[send_command:1034] out_param->filter_mode = 1
     37949.623567 s:  VX_ZONE_ERROR:[send_command:1035] out_param->coef_shift = 8
     37949.623572 s:  VX_ZONE_ERROR:[send_command:1036] out_param->saturation_mode = 0
     37949.623577 s:  VX_ZONE_ERROR:[send_command:1037] out_param->offset_x = 0
     37949.623582 s:  VX_ZONE_ERROR:[send_command:1038] out_param->offset_y = 0
     37949.623587 s:  VX_ZONE_ERROR:[send_command:1039] out_param->output_align_12bit = 0
     37949.623592 s:  VX_ZONE_ERROR:[send_command:1040] out_param->multi_phase.phase_mode = 1
     37949.623598 s:  VX_ZONE_ERROR:[send_command:1041] out_param->multi_phase.horz_coef_sel = 2
     37949.623603 s:  VX_ZONE_ERROR:[send_command:1042] out_param->multi_phase.vert_coef_sel = 2
     37949.623608 s:  VX_ZONE_ERROR:[send_command:1043] out_param->multi_phase.init_phase_x = 0
     37949.623613 s:  VX_ZONE_ERROR:[send_command:1044] out_param->multi_phase.init_phase_y = 0
     37949.623618 s:  VX_ZONE_ERROR:[send_command:1045] #################### tivxNodeSendCommand ###################n 37949.623622 s:  VX_ZONE_ERROR:[send_command:1031] #################### tivxNodeSendCommand ###################
     37949.956569 s:  VX_ZONE_ERROR:[send_command:1032] out_param = 0xffff68f1d000 output_obj_[3] = 0x2f1e3d8
     37949.956586 s:  VX_ZONE_ERROR:[send_command:1033] out_param->signed_data = 0
     37949.956592 s:  VX_ZONE_ERROR:[send_command:1034] out_param->filter_mode = 1
     37949.956597 s:  VX_ZONE_ERROR:[send_command:1035] out_param->coef_shift = 8
     37949.956602 s:  VX_ZONE_ERROR:[send_command:1036] out_param->saturation_mode = 0
     37949.956608 s:  VX_ZONE_ERROR:[send_command:1037] out_param->offset_x = 0
     37949.956613 s:  VX_ZONE_ERROR:[send_command:1038] out_param->offset_y = 0
     37949.956618 s:  VX_ZONE_ERROR:[send_command:1039] out_param->output_align_12bit = 0
     37949.956624 s:  VX_ZONE_ERROR:[send_command:1040] out_param->multi_phase.phase_mode = 1
     37949.956629 s:  VX_ZONE_ERROR:[send_command:1041] out_param->multi_phase.horz_coef_sel = 2
     37949.956634 s:  VX_ZONE_ERROR:[send_command:1042] out_param->multi_phase.vert_coef_sel = 2
     37949.956639 s:  VX_ZONE_ERROR:[send_command:1043] out_param->multi_phase.init_phase_x = 0
     37949.956645 s:  VX_ZONE_ERROR:[send_command:1044] out_param->multi_phase.init_phase_y = 0
    

    When I modified the tivxVpacMscPmdProcess function as below and tested it, I saw the register value changed. Could you please refer to this code?

    static vx_status VX_CALLBACK tivxVpacMscPmdProcess(
           tivx_target_kernel_instance kernel,
           tivx_obj_desc_t *obj_desc[],
           uint16_t num_params, void *priv_arg)
    {
        vx_status                 status = (vx_status)VX_SUCCESS;
        int32_t                   fvid2_status = FVID2_SOK;
        uint32_t                  size;
        uint32_t                  out_cnt;
        uint32_t                  plane_cnt;
        uint32_t                  in_idx, sc_idx, out_img_idx;
        uint32_t                  oct_cnt;
        Fvid2_Frame              *frm = NULL;
        tivx_obj_desc_image_t    *in_img_desc;
        tivx_obj_desc_image_t    *img_desc;
        tivx_obj_desc_pyramid_t  *out_pmd_desc;
        tivxVpacMscPmdObj        *msc_obj = NULL;
        Fvid2_FrameList          *inFrmList;
        Fvid2_FrameList          *outFrmList;
        tivxVpacMscPmdSubSetInfo *ss_info;
        uint64_t                 cur_time;
        tivxVpacMscPmdInstObj    *inst_obj = NULL;
    
        if ((TIVX_KERNEL_VPAC_MSC_PYRAMID_MAX_PARAMS != num_params) ||
            ((NULL == obj_desc[TIVX_KERNEL_VPAC_MSC_PYRAMID_IN_IMG_IDX]) ||
            (NULL == obj_desc[TIVX_KERNEL_VPAC_MSC_PYRAMID_OUT_PMD_IDX])))
        {
            VX_PRINT(VX_ZONE_ERROR, "NULL Params check failed\n");
            status = (vx_status)VX_FAILURE;
        }
    
        if ((vx_status)VX_SUCCESS == status)
        {
            status = (vx_status)VX_FAILURE;
    
            status = tivxGetTargetKernelInstanceContext(kernel,
                (void **)&msc_obj, &size);
    
            if (((vx_status)VX_SUCCESS == status) && (NULL != msc_obj) &&
                (sizeof(tivxVpacMscPmdObj) == size))
            {
                in_img_desc = (tivx_obj_desc_image_t *)
                    obj_desc[TIVX_KERNEL_VPAC_MSC_PYRAMID_IN_IMG_IDX];
                out_pmd_desc = (tivx_obj_desc_pyramid_t *)
                    obj_desc[TIVX_KERNEL_VPAC_MSC_PYRAMID_OUT_PMD_IDX];
    
                /* Get the Image Descriptors from the Pyramid Object */
                tivxGetObjDescList(out_pmd_desc->obj_desc_id,
                    (tivx_obj_desc_t **)msc_obj->out_img_desc,
                    out_pmd_desc->num_levels);
    
                for (out_cnt = 0U; out_cnt < out_pmd_desc->num_levels; out_cnt ++)
                {
                    if (NULL == msc_obj->out_img_desc[out_cnt])
                    {
                        VX_PRINT(VX_ZONE_ERROR, "Null Descriptor for Output\n");
                        status = (vx_status)VX_FAILURE;
                        break;
                    }
                }
            }
            else
            {
                VX_PRINT(VX_ZONE_ERROR, "Invalid Target Instance Context\n");
                status = (vx_status)VX_ERROR_INVALID_NODE;
            }
        }
    
        if ((vx_status)VX_SUCCESS == status)
        {
            inFrmList = &msc_obj->inFrmList;
            outFrmList = &msc_obj->outFrmList;
    
            /* Number of input frames is fixed to 1 */
            inFrmList->numFrames = 1U;
    
            cur_time = tivxPlatformGetTimeInUsecs();
    
            for (oct_cnt = 0u; (oct_cnt < msc_obj->num_pmd_subsets) && (status == (vx_status)VX_SUCCESS); oct_cnt ++)
            {
                ss_info = &msc_obj->ss_info[oct_cnt];
    
                /* MSC Parameters requires to be set in the driver,
                 * if the number of octaves are more than 1.
                 * If it is only one, params are already set in the driver as
                 * part of create, so no need to set again. */
                if (1u < msc_obj->num_pmd_subsets)
                {
    
    for (int cnt = 0u; cnt < msc_obj->num_pmd_levels; cnt ++)
    {
    
        int ss_idx = cnt / ss_info->num_levels;
    
        /* Scaler index within subset pyramid can be calculated
            * by just modulo operation. */
        sc_idx = cnt % ss_info->num_levels;
    
        /* Now map scaler index to scaler config index */
        sc_idx = ss_info->sc_map_idx[sc_idx];
    
        Msc_ScConfig* sc_cfg = &msc_obj->msc_prms[ss_idx].mscCfg.scCfg[sc_idx];
        
        VX_PRINT(VX_ZONE_ERROR, "################## before Fvid2_control in process #####################\n");    
    //     VX_PRINT(VX_ZONE_ERROR, "ss_idx = %d sc_idx = %d\n", ss_idx, sc_idx);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->enable = %d\n", sc_cfg->enable);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropStartX = %d\n", sc_cfg->inRoi.cropStartX);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropStartY = %d\n", sc_cfg->inRoi.cropStartY);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropWidth = %d\n", sc_cfg->inRoi.cropWidth);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->inRoi.cropHeight = %d\n", sc_cfg->inRoi.cropHeight);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->outWidth = %d\n", sc_cfg->outWidth);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->outHeight = %d\n", sc_cfg->outHeight);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->horzAccInit = %d\n", sc_cfg->horzAccInit);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->vertAccInit = %d\n", sc_cfg->vertAccInit);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->filtMode = %d\n", sc_cfg->filtMode);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->phaseMode = %d\n", sc_cfg->phaseMode);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->hsSpCoeffSel = %d\n", sc_cfg->hsSpCoeffSel);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->vsSpCoeffSel = %d\n", sc_cfg->vsSpCoeffSel);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->hsMpCoeffSel = %d\n", sc_cfg->hsMpCoeffSel);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->vsMpCoeffSel = %d\n", sc_cfg->vsMpCoeffSel);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->coeffShift = %d\n", sc_cfg->coeffShift);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->isSignedData = %d\n", sc_cfg->isSignedData);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->isEnableFiltSatMode = %d\n", sc_cfg->isEnableFiltSatMode);
    //     VX_PRINT(VX_ZONE_ERROR, "sc_cfg->isInterleaveFormat = %d\n", sc_cfg->isInterleaveFormat);
    
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x120) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x120)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x124) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x124)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x128) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x128)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x12C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x12C)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x130) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x130)));
    
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x00) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x00)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x04) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x04)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x08) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x08)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x0C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x0C)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x10) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x10)));
    
        sc_cfg->filtMode = 1;
        sc_cfg->phaseMode = 1;
        sc_cfg->hsSpCoeffSel = 1;
        sc_cfg->vsSpCoeffSel = 1;
        sc_cfg->hsMpCoeffSel = 2;
        sc_cfg->vsMpCoeffSel = 2; 
    
    //     // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x170) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x170)));
    //     // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x174) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x174)));
    //     // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x1F0) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x1F0)));
    //     // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x1F4) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x1F4)));
        
        VX_PRINT(VX_ZONE_ERROR, "#######################################\n");    
    }
    
    
                    fvid2_status = Fvid2_control(msc_obj->handle,
                        VHWA_M2M_IOCTL_MSC_SET_PARAMS,
                        &msc_obj->msc_prms[oct_cnt], NULL);
    
    {
        VX_PRINT(VX_ZONE_ERROR, "################## after Fvid2_control in process #####################\n");    
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x120) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x120)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x124) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x124)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x128) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x128)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x12C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x12C)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x130) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x130)));
    
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x00) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x00)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x04) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x04)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x08) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x08)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x0C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x0C)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x10) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x10)));
        VX_PRINT(VX_ZONE_ERROR, "#######################################\n");    
    }
    
                    if (FVID2_SOK != fvid2_status)
                    {
                        VX_PRINT(VX_ZONE_ERROR, "Failed to set params\n");
                        status = (vx_status)VX_FAILURE;
                    }
                }
    
                if(status == (vx_status)VX_SUCCESS)
                {
                    frm = &msc_obj->inFrm;
                    /* For the first octave, input is from the actual input image */
                    if (0u == oct_cnt)
                    {
                        for (plane_cnt = 0u; plane_cnt < in_img_desc->planes;
                                plane_cnt ++)
                        {
                            frm->addr[plane_cnt] = tivxMemShared2PhysPtr(
                                in_img_desc->mem_ptr[plane_cnt].shared_ptr,
                                (int32_t)in_img_desc->mem_ptr[plane_cnt].mem_heap_region);
                        }
                    }
                    else
                    {
                        /* For the rest octaves, Use the last output
                         * from the previous octave, as an input */
                        in_idx = ss_info->input_idx;
                        img_desc = msc_obj->out_img_desc[in_idx];
                        for (plane_cnt = 0u; plane_cnt < img_desc->planes;
                                plane_cnt ++)
                        {
                            frm->addr[plane_cnt] = tivxMemShared2PhysPtr(
                                img_desc->mem_ptr[plane_cnt].shared_ptr,
                                (int32_t)img_desc->mem_ptr[plane_cnt].mem_heap_region);
                        }
                    }
    
                    outFrmList->numFrames = MSC_MAX_OUTPUT;
                    out_img_idx = ss_info->out_start_idx;
                    for (out_cnt = 0u; out_cnt < ss_info->num_levels; out_cnt ++)
                    {
                        img_desc = msc_obj->out_img_desc[out_img_idx];
                        sc_idx = ss_info->sc_map_idx[out_cnt];
                        frm = &msc_obj->outFrm[sc_idx];
    
                        for (plane_cnt = 0u; plane_cnt < img_desc->planes;
                                plane_cnt ++)
                        {
                            frm->addr[plane_cnt] = tivxMemShared2PhysPtr(
                                img_desc->mem_ptr[plane_cnt].shared_ptr,
                                (int32_t)img_desc->mem_ptr[plane_cnt].
                                mem_heap_region);
                        }
                        out_img_idx ++;
                    }
    
                    /* Submit MSC Request*/
                    fvid2_status = Fvid2_processRequest(msc_obj->handle, inFrmList,
                        outFrmList, FVID2_TIMEOUT_FOREVER);
                    if (FVID2_SOK != fvid2_status)
                    {
                        VX_PRINT(VX_ZONE_ERROR, "Failed to Submit Request\n");
                        status = (vx_status)VX_FAILURE;
                    }
    
                    if(status == (vx_status)VX_SUCCESS)
                    {
                        /* Wait for Frame Completion */
                        tivxEventWait(msc_obj->wait_for_compl, TIVX_EVENT_TIMEOUT_WAIT_FOREVER);
    
                        fvid2_status = Fvid2_getProcessedRequest(msc_obj->handle,
                            inFrmList, outFrmList, 0);
                        if (FVID2_SOK != fvid2_status)
                        {
                            VX_PRINT(VX_ZONE_ERROR, "Failed to Get Processed Request\n");
                            status = (vx_status)VX_FAILURE;
                        }
                    }
                }
            }
        }
    
        if ((vx_status)VX_SUCCESS == status)
        {
            cur_time = tivxPlatformGetTimeInUsecs() - cur_time;
    
            inst_obj = msc_obj->inst_obj;
    
            if ((vx_df_image)VX_DF_IMAGE_NV12 == in_img_desc->format)
            {
                size = in_img_desc->imagepatch_addr[0].dim_x*in_img_desc->imagepatch_addr[0].dim_y + \
                       in_img_desc->imagepatch_addr[0].dim_x*in_img_desc->imagepatch_addr[0].dim_y/2;
            }
            else
            {
                size = in_img_desc->imagepatch_addr[0].dim_x*in_img_desc->imagepatch_addr[0].dim_y;
            }
    
            appPerfStatsHwaUpdateLoad(inst_obj->hwa_perf_id,
                (uint32_t)cur_time,
                size /* pixels processed */
                );
        }
    
        VX_PRINT(VX_ZONE_ERROR, "#######################################\n");    
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x120) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x120)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x124) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x124)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x128) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x128)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x12C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x12C)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x130) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x130)));
    
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x00) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x00)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x04) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x04)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x08) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x08)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x0C) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x0C)));
        VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x10) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x10)));
    
        // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x170) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x170)));
        // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x174) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x174)));
        // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x1F0) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x1F0)));
        // VX_PRINT(VX_ZONE_ERROR, "(0x0F000000 + 0x1c0010 + 0x1F4) = 0x%x\n", *(volatile uint32_t *)((0x0F000000 + 0x1c0010 + 0x1F4)));
        
        VX_PRINT(VX_ZONE_ERROR, "#######################################\n\n");
    
        return (status);
    }
    

    output print

    [MCU2_0]  37950.026596 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1019] ################## before Fvid2_control in process #####################
    [MCU2_0]  37950.026702 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1041] (0x0F000000 + 0x1c0010 + 0x120) = 0x20002b
    [MCU2_0]  37950.026771 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1042] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  37950.026837 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1043] (0x0F000000 + 0x1c0010 + 0x128) = 0x4000780
    [MCU2_0]  37950.026895 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1044] (0x0F000000 + 0x1c0010 + 0x12C) = 0x10001000
    [MCU2_0]  37950.026963 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1045] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]  37950.027018 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1047] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]  37950.027074 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1048] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]  37950.027138 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1049] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]  37950.027206 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1050] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]  37950.027266 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1051] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    [MCU2_0]  37950.027331 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1065] #######################################
    [MCU2_0]  37950.027388 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1019] ################## before Fvid2_control in process #####################
    [MCU2_0]  37950.027455 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1041] (0x0F000000 + 0x1c0010 + 0x120) = 0x20002b
    [MCU2_0]  37950.027533 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1042] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  37950.027596 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1043] (0x0F000000 + 0x1c0010 + 0x128) = 0x4000780
    [MCU2_0]  37950.027656 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1044] (0x0F000000 + 0x1c0010 + 0x12C) = 0x10001000
    [MCU2_0]  37950.027711 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1045] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]  37950.027765 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1047] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]  37950.027820 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1048] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]  37950.027875 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1049] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]  37950.027930 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1050] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]  37950.027988 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1051] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    [MCU2_0]  37950.028040 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1065] #######################################
    [MCU2_0]  37950.028094 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1019] ################## before Fvid2_control in process #####################
    [MCU2_0]  37950.028164 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1041] (0x0F000000 + 0x1c0010 + 0x120) = 0x20002b
    [MCU2_0]  37950.028220 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1042] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  37950.028276 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1043] (0x0F000000 + 0x1c0010 + 0x128) = 0x4000780
    [MCU2_0]  37950.028342 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1044] (0x0F000000 + 0x1c0010 + 0x12C) = 0x10001000
    [MCU2_0]  37950.028399 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1045] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]  37950.028456 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1047] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]  37950.028514 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1048] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]  37950.028568 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1049] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]  37950.028625 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1050] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]  37950.028684 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1051] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    [MCU2_0]  37950.028737 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1065] #######################################
    [MCU2_0]  37950.028789 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1019] ################## before Fvid2_control in process #####################
    [MCU2_0]  37950.028854 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1041] (0x0F000000 + 0x1c0010 + 0x120) = 0x20002b
    [MCU2_0]  37950.028909 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1042] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  37950.028962 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1043] (0x0F000000 + 0x1c0010 + 0x128) = 0x4000780
    [MCU2_0]  37950.029018 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1044] (0x0F000000 + 0x1c0010 + 0x12C) = 0x10001000
    [MCU2_0]  37950.029073 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1045] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]  37950.029127 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1047] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]  37950.029182 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1048] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]  37950.029235 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1049] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]  37950.029291 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1050] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]  37950.029353 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1051] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    [MCU2_0]  37950.029406 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1065] #######################################
    [MCU2_0]  37950.029601 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1074] ################## after Fvid2_control in process #####################
    [MCU2_0]  37950.029683 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1075] (0x0F000000 + 0x1c0010 + 0x120) = 0x20002b
    [MCU2_0]  37950.029742 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1076] (0x0F000000 + 0x1c0010 + 0x124) = 0x0
    [MCU2_0]  37950.029796 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1077] (0x0F000000 + 0x1c0010 + 0x128) = 0x4000780
    [MCU2_0]  37950.029852 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1078] (0x0F000000 + 0x1c0010 + 0x12C) = 0x10001000
    [MCU2_0]  37950.029907 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1079] (0x0F000000 + 0x1c0010 + 0x130) = 0x0
    [MCU2_0]  37950.029961 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1081] (0x0F000000 + 0x1c0010 + 0x00) = 0x220001
    [MCU2_0]  37950.030017 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1082] (0x0F000000 + 0x1c0010 + 0x04) = 0x0
    [MCU2_0]  37950.030071 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1083] (0x0F000000 + 0x1c0010 + 0x08) = 0x1000380
    [MCU2_0]  37950.030127 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1084] (0x0F000000 + 0x1c0010 + 0x0C) = 0x21c02249
    [MCU2_0]  37950.030183 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1085] (0x0F000000 + 0x1c0010 + 0x10) = 0x8e00925
    [MCU2_0]  37950.030235 s:  VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1086] #######################################
    

    Regards,

    Hyeonseong

  • -> When I printed out the output_refs from tivxNodeSendCommand, I saw that it was set as below. Does this answer your question?

    But, can you check this in the send_command API, before calling tivxNodeSendCommand? I feel the references have changed in this API. Because of this, pyramid node is not getting correct references and so incorrect parameters.. 

    Regards,

    Brijesh

  • I've tried snapping those values with the code below, but could it be wrong?

    case kSetMSCOutputParam: {
            printf("kSetMSCOutputParam\n");
            if (pyramid_node_ != nullptr && output_refs_ != nullptr) {
                // for (int32_t i = 0; i < pyramid_level_; i++) {
                //     refs[i] = (vx_reference)output_refs_[i];
                // }
                //status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, refs, 4u);
    
                for (int32_t cnt = 0; cnt < 4; cnt++) {
                    vx_map_id map_id = 0;
                    void* data_ptr = nullptr;
    
                    vxMapUserDataObject((vx_user_data_object)output_refs_[cnt], 0, sizeof(tivx_vpac_msc_output_params_t), &map_id, &data_ptr, VX_READ_ONLY, VX_MEMORY_TYPE_HOST, 0);
    
                    tivx_vpac_msc_output_params_t* out_param = (tivx_vpac_msc_output_params_t*)data_ptr;
    
                    VX_PRINT(VX_ZONE_ERROR, "#################### tivxNodeSendCommand ###################\n");
                    VX_PRINT(VX_ZONE_ERROR, "out_param = %p output_obj_[%d] = %p \n", out_param, cnt, output_obj_[cnt]);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->signed_data = %d \n", out_param->signed_data);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->filter_mode = %d \n", out_param->filter_mode);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->coef_shift = %d \n", out_param->coef_shift);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->saturation_mode = %d \n", out_param->saturation_mode);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->offset_x = %d \n", out_param->offset_x);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->offset_y = %d \n", out_param->offset_y);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->output_align_12bit = %d \n", out_param->output_align_12bit);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->multi_phase.phase_mode = %d \n", out_param->multi_phase.phase_mode);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->multi_phase.horz_coef_sel = %d \n", out_param->multi_phase.horz_coef_sel);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->multi_phase.vert_coef_sel = %d \n", out_param->multi_phase.vert_coef_sel);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->multi_phase.init_phase_x = %d \n", out_param->multi_phase.init_phase_x);
                    VX_PRINT(VX_ZONE_ERROR, "out_param->multi_phase.init_phase_y = %d \n", out_param->multi_phase.init_phase_y);
                    VX_PRINT(VX_ZONE_ERROR, "#################### tivxNodeSendCommand ###################n");
    
                    //status = vxUnmapUserDataObject(output_refs_[cnt], map_id);
    
                    status = vxUnmapUserDataObject((vx_user_data_object)output_refs_[cnt], map_id);
                }
    
                status = tivxNodeSendCommand(pyramid_node_, 0u, TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS, output_refs_, 4u);
            }
            break;

    Regards,

    Hyeonseong

  • Hi Hyeonseong,

    Can you please make small change in this ioctl implementation, in the API tivxVpacMscPmdControl, in the file vx_vpac_msc_pyramid_target.c and see if it helps?

                case TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS:
                {
                    uint32_t cnt;
                    tivx_obj_desc_user_data_object_t *data_obj[TIVX_PYRAMID_MAX_LEVEL_OBJECTS];
                    
                    VX_PRINT(VX_ZONE_ERROR, "TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS: num_params = %d\n",
                        num_params);
                        
                    for (cnt = 0u; cnt < num_params; cnt ++)
                    {
                        data_obj[cnt] = (tivx_obj_desc_user_data_object_t *)obj_desc[cnt];
                    }
                    status = tivxVpacMscPmdSetOutputParamsCmd(msc_obj, data_obj);
                    break;
                }
    

    Regards,

    Brijesh

  • Hi Brijesh,

    when i use only NN resizer coefficient without DOF

    When I print the physical address of the MSC in tivxVpacMscScaleProcess, it is shown below.

    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:838] (0x0F000000 + 0x1c0010 + 0x0) = 0x220001
    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:839] (0x0F000000 + 0x1c0010 + 0x20) = 0x220001
    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:840] (0x0F000000 + 0x1c0010 + 0x40) = 0x220001
    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:841] (0x0F000000 + 0x1c0010 + 0x60) = 0x220001
    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:842] (0x0F000000 + 0x1c0010 + 0x80) = 0x220001

    tivxVpacMscScaleProcess’s output params

    • RESERVED = x

    • SIGNED_DATA = 0b0

    • COEF_SHIFT = 0b1000

    • UV_MODE = 0b1

    • SAT_MODE = 0b0

    • SP_VX_COEF_SEL = 0b0000

    • SP_VX_COEF_SRC = 0b0

    • SP_VS_COEF_SEL = 0b0000

    • SP_VX_COEF_SRC = 0b0

    • VS_COEF_SEL = 0b00

    • HS_COEF_SEL = 0b00

    • PHASE_MODE = 0b0

    • FILTER_MODE = 0b1

    Q) But I don't see any part in tivx_vpac_msc_output_params_t to set uv_mode, how can I set uv_mode in multi_phase mode?

    typedef struct {
        /*! Integer type of input and output frame data,
         *  0: Unsigned 12-bit, 1: Signed 12-bit */
        uint32_t  signed_data;
        /*! 0: Single Phase Filter (integer ratios: 1x, 1/2x, 1/4x);
         *  1: Multi-phase scaling filter */
        uint32_t  filter_mode;
        /*! Sets the fractional bit precision of the 10-bit filter
         *  coefficient [Range (5-9)] */
        uint32_t  coef_shift;
        /*! Filter output saturation mdoe,
         *   0: [0..4095] clipping;
         *   1: [-2048..2047] clip followed by + 2048 */
        uint32_t  saturation_mode;
        /*! Source X offset: used to align center tap if filter to appropriate input for first output [Range (0,1, or TIVX_VPAC_MSC_AUTOCOMPUTE)]
         *  \see tivx_vpac_msc_multi_phase_params_t::init_phase_x
         *  \note Using TIVX_VPAC_MSC_AUTOCOMPUTE aligns center of output to match center of input cropped region for each output */
        uint32_t  offset_x;
        /*! Source Y offset: used to align center tap if filter to appropriate input for first output [Range (0,1, or TIVX_VPAC_MSC_AUTOCOMPUTE))]
         *  \see tivx_vpac_msc_multi_phase_params_t::init_phase_y
         *  \note Using TIVX_VPAC_MSC_AUTOCOMPUTE aligns center of output to match center of input cropped region for each output */
        uint32_t  offset_y;
        /*! Optional: When input 16-bit unpacked, alignment of 12-bit pixel,
         *  0: LSB, 1:MSB */
        uint32_t  output_align_12bit;
    
        /*! Optional: When 'filter_mode' == 0: Single-phase */
        tivx_vpac_msc_single_phase_params_t single_phase;
        /*! Optional: When 'filter_mode' == 1: Multi-phase */
        tivx_vpac_msc_multi_phase_params_t  multi_phase;
    } tivx_vpac_msc_output_params_t;

    when i use NN resizer coefficient and Gaussian Filter coefficient with DOF

    And if I don't set pyramid_node to multi_phase (Not use TIVX_VPAC_MSC_CMD_SET_OUTPUT_PARAMS) and set pyramid_node with the existing TI code, the MSC physical address is as below.

    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:838] (0x0F000000 + 0x1c0010 + 0x0) = 0x220001
    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:839] (0x0F000000 + 0x1c0010 + 0x20) = 0x220001
    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:840] (0x0F000000 + 0x1c0010 + 0x40) = 0x220001
    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:841] (0x0F000000 + 0x1c0010 + 0x60) = 0x220001
    VX_ZONE_ERROR:[tivxVpacMscScaleProcess:842] (0x0F000000 + 0x1c0010 + 0x80) = 0x220001
    VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1164] ==================== before Fvid2_getProcessedRequest ====================
    VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1177] (0x0F000000 + 0x1c0010 + 0x120) = 0x201080
    VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1178] (0x0F000000 + 0x1c0010 + 0x100) = 0x201080
    VX_ZONE_ERROR:[tivxVpacMscPmdProcess:1179] ==================== after Fvid2_getProcessedRequest ====================

    Q) After all, how should I configure tivx_vpac_msc_output_params_t output_params if I want set0 to use an NN resizer and set1 to use a Gaussian Filter?
    Below are the parameter values I am using. 

    In MSC 

            tivx_vpac_msc_output_params_t output_params[5];
            tivx_vpac_msc_output_params_init(&output_params[0]);
    
            output_params[0].signed_data = 1;
            output_params[0].filter_mode = 1; // Multi-phase scaling
            output_params[0].coef_shift = 8;
            output_params[0].saturation_mode = 0;
            output_params[0].offset_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
            output_params[0].offset_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
            output_params[0].output_align_12bit = 0;
            output_params[0].multi_phase.phase_mode = 1;
            output_params[0].multi_phase.horz_coef_sel = 0;
            output_params[0].multi_phase.vert_coef_sel = 0;
            output_params[0].multi_phase.init_phase_x = TIVX_VPAC_MSC_AUTOCOMPUTE;
            output_params[0].multi_phase.init_phase_y = TIVX_VPAC_MSC_AUTOCOMPUTE;
    

    In Pyramid

            output_params[0].signed_data = 0;
            output_params[0].filter_mode = 1; // Multi-phase scaling
            output_params[0].coef_shift = 8;
            output_params[0].saturation_mode = 0;
            output_params[0].offset_x = 0;
            output_params[0].offset_y = 0;
            output_params[0].output_align_12bit = 0;
    
            output_params[0].multi_phase.phase_mode = 1;
            output_params[0].multi_phase.horz_coef_sel = 2;
            output_params[0].multi_phase.vert_coef_sel = 2;
            output_params[0].multi_phase.init_phase_x = 0;
            output_params[0].multi_phase.init_phase_y = 0;

    Regards,

    Hyeonseong