[fix] rotation/combinedOrientation modification in ivas_rend_crendProcessSplitBin()

    const int16_t output_frame  /* i  : output frame length               */

)

{

    int16_t i;

    int16_t i, j, sf;

    int16_t pos_idx;

    ivas_error error;

    float gain_lfe;

    float tmpLfeBuffer[L_FRAME48k];

    float tmpInputBuffer[MAX_OUTPUT_CHANNELS][L_FRAME48k];

    float *p_tmpInputBuffer[MAX_OUTPUT_CHANNELS];

    float tmpSplitBinBuffer[MAX_OUTPUT_CHANNELS][L_FRAME48k];

    IVAS_QUATERNION originalHeadRot[MAX_PARAM_SPATIAL_SUBFRAMES];

    MULTI_BIN_REND_POSE_DATA *pMultiBinPoseData;

    ivas_error error;

    COMBINED_ORIENTATION_DATA combinedOrientationDataLocal;

    COMBINED_ORIENTATION_HANDLE pCombinedOrientationDataLocal;

    pMultiBinPoseData = &st_ivas->splitBinRend.splitrend.multiBinPoseData;

    /* Save current head positions */

    for ( i = 0; i < MAX_PARAM_SPATIAL_SUBFRAMES; ++i )

    {

        originalHeadRot[i] = st_ivas->hHeadTrackData->Quaternions[i];

    }

    /* copy input */

    for ( i = 0; i < st_ivas->nchan_transport; ++i )

    {

        p_tmpInputBuffer[i] = tmpInputBuffer[i];

    }

    /* TODO tmu : partial duplication of ivas_binaural_add_LFE() for efficiency */

    /* copy LFE */

    /* save current head positions */

    pCombinedOrientationDataLocal = st_ivas->hCombinedOrientationData;

    combinedOrientationDataLocal = *pCombinedOrientationDataLocal;

    for ( sf = 1; sf < RENDERER_HEAD_POSITIONS_PER_FRAME; ++sf )

    {

        combinedOrientationDataLocal.Quaternions[sf] = combinedOrientationDataLocal.Quaternions[0];

        for ( i = 0; i < 3; i++ )

        {

            for ( j = 0; j < 3; j++ )

            {

                combinedOrientationDataLocal.Rmat[sf][i][j] = combinedOrientationDataLocal.Rmat[0][i][j];

            }

        }

    }

    /* copy LFE to tmpLfeBuffer and apply gain only once */

    mvr2r( output[st_ivas->hIntSetup.index_lfe[0]], tmpLfeBuffer, output_frame );

    gain_lfe = ( ( st_ivas->hCrendWrapper != NULL ) && ( st_ivas->hCrendWrapper->hHrtfCrend != NULL ) ) ? st_ivas->hCrendWrapper->hHrtfCrend->gain_lfe : GAIN_LFE;

    v_multc( tmpLfeBuffer, gain_lfe, tmpLfeBuffer, output_frame );

    for ( pos_idx = 0; pos_idx < pMultiBinPoseData->num_poses; ++pos_idx )

    {

        /* Update head positions */

        if ( pos_idx != 0 )

        IVAS_QUATERNION Quaternions_orig[RENDERER_HEAD_POSITIONS_PER_FRAME], Quaternions_abs;

        for ( i = 0; i < RENDERER_HEAD_POSITIONS_PER_FRAME; i++ )

        {

            for ( i = 0; i < MAX_PARAM_SPATIAL_SUBFRAMES; ++i )

            {

                if ( originalHeadRot[i].w == -3.0f )

                {

                    st_ivas->hHeadTrackData->Quaternions[i].w = -3.0f;

                    st_ivas->hHeadTrackData->Quaternions[i].x = originalHeadRot[i].x + pMultiBinPoseData->relative_head_poses[pos_idx][0];

                    st_ivas->hHeadTrackData->Quaternions[i].y = originalHeadRot[i].y + pMultiBinPoseData->relative_head_poses[pos_idx][1];

                    st_ivas->hHeadTrackData->Quaternions[i].z = originalHeadRot[i].z + pMultiBinPoseData->relative_head_poses[pos_idx][2];

                }

                else

                {

                    st_ivas->hHeadTrackData->Quaternions[i].w = -3.0f;

                    Quat2EulerDegree( originalHeadRot[i], /* TODO tmu : fix bug with ordering*/

                                      &st_ivas->hHeadTrackData->Quaternions[i].z,

                                      &st_ivas->hHeadTrackData->Quaternions[i].y,

                                      &st_ivas->hHeadTrackData->Quaternions[i].x );

                    st_ivas->hHeadTrackData->Quaternions[i].x += pMultiBinPoseData->relative_head_poses[pos_idx][0];

                    st_ivas->hHeadTrackData->Quaternions[i].y += pMultiBinPoseData->relative_head_poses[pos_idx][1];

                    st_ivas->hHeadTrackData->Quaternions[i].z += pMultiBinPoseData->relative_head_poses[pos_idx][2];

                }

            Quaternions_orig[i] = combinedOrientationDataLocal.Quaternions[i];

            Quaternions_abs.w = -3.0f;

            Quat2EulerDegree( combinedOrientationDataLocal.Quaternions[i], &Quaternions_abs.z, &Quaternions_abs.y, &Quaternions_abs.x ); /*order in Quat2Euler seems to be reversed ?*/

                st_ivas->hCombinedOrientationData->Quaternions[i] = st_ivas->hHeadTrackData->Quaternions[i];

            }

            Quaternions_abs.x += pMultiBinPoseData->relative_head_poses[pos_idx][0];

            Quaternions_abs.y += pMultiBinPoseData->relative_head_poses[pos_idx][1];

            Quaternions_abs.z += pMultiBinPoseData->relative_head_poses[pos_idx][2];

            combinedOrientationDataLocal.Quaternions[i] = Quaternions_abs;

            QuatToRotMat( combinedOrientationDataLocal.Quaternions[i], combinedOrientationDataLocal.Rmat[i] );

        }

        /* render inplace to first two channels of tmpInputBuffer */

        pCombinedOrientationDataLocal = &combinedOrientationDataLocal;

        if ( ( error = ivas_rend_crendProcess( st_ivas->hCrendWrapper,

                                               st_ivas->intern_config,

                                               st_ivas->hOutSetup.output_config,

                                               st_ivas->hDecoderConfig,

                                               st_ivas->hCombinedOrientationData,

                                               pCombinedOrientationDataLocal,

                                               &st_ivas->hIntSetup,

                                               st_ivas->hEFAPdata,

                                               p_tmpInputBuffer,

            /* overwrite rendered channels with input again for next iteration */

            mvr2r( output[i], tmpInputBuffer[i], output_frame );

        }

        /* restore original headrotation data */

        for ( i = 0; i < RENDERER_HEAD_POSITIONS_PER_FRAME; i++ )

        {

            combinedOrientationDataLocal.Quaternions[i] = Quaternions_orig[i];

        }

    }

    /* copy split binaural rendered signals to final output */

        mvr2r( tmpSplitBinBuffer[i], output[i], output_frame );

    }

    /* Restore original head rotation */

    for ( i = 0; i < MAX_PARAM_SPATIAL_SUBFRAMES; ++i )

    {

        st_ivas->hHeadTrackData->Quaternions[i] = originalHeadRot[i];

        st_ivas->hCombinedOrientationData->Quaternions[i] = originalHeadRot[i];

    }

    return IVAS_ERR_OK;

}

#endif