| /* |
| * Copyright (C) 2017 C-SKY Microsystems Co., Ltd. All rights reserved. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /****************************************************************************** |
| * @file csi_simd.h |
| * @brief CSI Single Instruction Multiple Data (SIMD) Header File for GCC. |
| * @version V1.0 |
| * @date 02. June 2017 |
| ******************************************************************************/ |
| |
| #ifndef _CSI_SIMD_H_ |
| #define _CSI_SIMD_H_ |
| |
| |
| /** |
| \brief Halfword packing instruction. Combines bits[15:0] of val1 with bits[31:16] |
| of val2 levitated with the val3. |
| \details Combine a halfword from one register with a halfword from another register. |
| The second argument can be left-shifted before extraction of the halfword. |
| \param [in] val1 first 16-bit operands |
| \param [in] val2 second 16-bit operands |
| \param [in] val3 value for left-shifting val2. Value range [0..31]. |
| \return the combination of halfwords. |
| \remark |
| res[15:0] = val1[15:0] \n |
| res[31:16] = val2[31:16] << val3 |
| */ |
| __ALWAYS_INLINE uint32_t __PKHBT(uint32_t val1, uint32_t val2, uint32_t val3) |
| { |
| return ((((int32_t)(val1) << 0) & (int32_t)0x0000FFFF) | (((int32_t)(val2) << val3) & (int32_t)0xFFFF0000)); |
| } |
| |
| /** |
| \brief Halfword packing instruction. Combines bits[31:16] of val1 with bits[15:0] |
| of val2 right-shifted with the val3. |
| \details Combine a halfword from one register with a halfword from another register. |
| The second argument can be right-shifted before extraction of the halfword. |
| \param [in] val1 first 16-bit operands |
| \param [in] val2 second 16-bit operands |
| \param [in] val3 value for right-shifting val2. Value range [1..32]. |
| \return the combination of halfwords. |
| \remark |
| res[15:0] = val2[15:0] >> val3 \n |
| res[31:16] = val1[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __PKHTB(uint32_t val1, uint32_t val2, uint32_t val3) |
| { |
| return ((((int32_t)(val1) << 0) & (int32_t)0xFFFF0000) | (((int32_t)(val2) >> val3) & (int32_t)0x0000FFFF)); |
| } |
| |
| /** |
| \brief Dual 16-bit signed saturate. |
| \details This function saturates a signed value. |
| \param [in] x two signed 16-bit values to be saturated. |
| \param [in] y bit position for saturation, an integral constant expression in the range 1 to 16. |
| \return the sum of the absolute differences of the following bytes, added to the accumulation value:\n |
| the signed saturation of the low halfword in val1, saturated to the bit position specified in |
| val2 and returned in the low halfword of the return value.\n |
| the signed saturation of the high halfword in val1, saturated to the bit position specified in |
| val2 and returned in the high halfword of the return value. |
| */ |
| __ALWAYS_INLINE uint32_t __SSAT16(int32_t x, const uint32_t y) |
| { |
| int32_t r = 0, s = 0; |
| |
| r = __SSAT((((int32_t)x << 16) >> 16), y) & (int32_t)0x0000FFFF; |
| s = __SSAT((((int32_t)x) >> 16), y) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned saturate. |
| \details This function enables you to saturate two signed 16-bit values to a selected unsigned range. |
| \param [in] x two signed 16-bit values to be saturated. |
| \param [in] y bit position for saturation, an integral constant expression in the range 1 to 16. |
| \return the saturation of the two signed 16-bit values, as non-negative values: |
| the saturation of the low halfword in val1, saturated to the bit position specified in |
| val2 and returned in the low halfword of the return value.\n |
| the saturation of the high halfword in val1, saturated to the bit position specified in |
| val2 and returned in the high halfword of the return value. |
| */ |
| __ALWAYS_INLINE uint32_t __USAT16(uint32_t x, const uint32_t y) |
| { |
| int32_t r = 0, s = 0; |
| |
| r = __IUSAT(((x << 16) >> 16), y) & 0x0000FFFF; |
| s = __IUSAT(((x) >> 16), y) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Quad 8-bit saturating addition. |
| \details This function enables you to perform four 8-bit integer additions, |
| saturating the results to the 8-bit signed integer range -2^7 <= x <= 2^7 - 1. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the saturated addition of the first byte of each operand in the first byte of the return value.\n |
| the saturated addition of the second byte of each operand in the second byte of the return value.\n |
| the saturated addition of the third byte of each operand in the third byte of the return value.\n |
| the saturated addition of the fourth byte of each operand in the fourth byte of the return value.\n |
| The returned results are saturated to the 8-bit signed integer range -2^7 <= x <= 2^7 - 1. |
| \remark |
| res[7:0] = val1[7:0] + val2[7:0] \n |
| res[15:8] = val1[15:8] + val2[15:8] \n |
| res[23:16] = val1[23:16] + val2[23:16] \n |
| res[31:24] = val1[31:24] + val2[31:24] |
| */ |
| __ALWAYS_INLINE uint32_t __QADD8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = __SSAT(((((int32_t)x << 24) >> 24) + (((int32_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF; |
| s = __SSAT(((((int32_t)x << 16) >> 24) + (((int32_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF; |
| t = __SSAT(((((int32_t)x << 8) >> 24) + (((int32_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF; |
| u = __SSAT(((((int32_t)x) >> 24) + (((int32_t)y) >> 24)), 8) & (int32_t)0x000000FF; |
| |
| return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); |
| } |
| |
| /** |
| \brief Quad 8-bit unsigned saturating addition. |
| \details This function enables you to perform four unsigned 8-bit integer additions, |
| saturating the results to the 8-bit unsigned integer range 0 < x < 2^8 - 1. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the saturated addition of the first byte of each operand in the first byte of the return value.\n |
| the saturated addition of the second byte of each operand in the second byte of the return value.\n |
| the saturated addition of the third byte of each operand in the third byte of the return value.\n |
| the saturated addition of the fourth byte of each operand in the fourth byte of the return value.\n |
| The returned results are saturated to the 8-bit signed integer range 0 <= x <= 2^8 - 1. |
| \remark |
| res[7:0] = val1[7:0] + val2[7:0] \n |
| res[15:8] = val1[15:8] + val2[15:8] \n |
| res[23:16] = val1[23:16] + val2[23:16] \n |
| res[31:24] = val1[31:24] + val2[31:24] |
| */ |
| __ALWAYS_INLINE uint32_t __UQADD8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = __IUSAT((((x << 24) >> 24) + ((y << 24) >> 24)), 8) & 0x000000FF; |
| s = __IUSAT((((x << 16) >> 24) + ((y << 16) >> 24)), 8) & 0x000000FF; |
| t = __IUSAT((((x << 8) >> 24) + ((y << 8) >> 24)), 8) & 0x000000FF; |
| u = __IUSAT((((x) >> 24) + ((y) >> 24)), 8) & 0x000000FF; |
| |
| return ((u << 24) | (t << 16) | (s << 8) | (r)); |
| } |
| |
| /** |
| \brief Quad 8-bit signed addition. |
| \details This function performs four 8-bit signed integer additions. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the addition of the first bytes from each operand, in the first byte of the return value.\n |
| the addition of the second bytes of each operand, in the second byte of the return value.\n |
| the addition of the third bytes of each operand, in the third byte of the return value.\n |
| the addition of the fourth bytes of each operand, in the fourth byte of the return value. |
| \remark |
| res[7:0] = val1[7:0] + val2[7:0] \n |
| res[15:8] = val1[15:8] + val2[15:8] \n |
| res[23:16] = val1[23:16] + val2[23:16] \n |
| res[31:24] = val1[31:24] + val2[31:24] |
| */ |
| __ALWAYS_INLINE uint32_t __SADD8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = ((((int32_t)x << 24) >> 24) + (((int32_t)y << 24) >> 24)) & (int32_t)0x000000FF; |
| s = ((((int32_t)x << 16) >> 24) + (((int32_t)y << 16) >> 24)) & (int32_t)0x000000FF; |
| t = ((((int32_t)x << 8) >> 24) + (((int32_t)y << 8) >> 24)) & (int32_t)0x000000FF; |
| u = ((((int32_t)x) >> 24) + (((int32_t)y) >> 24)) & (int32_t)0x000000FF; |
| |
| return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); |
| } |
| |
| /** |
| \brief Quad 8-bit unsigned addition. |
| \details This function performs four unsigned 8-bit integer additions. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the addition of the first bytes from each operand, in the first byte of the return value.\n |
| the addition of the second bytes of each operand, in the second byte of the return value.\n |
| the addition of the third bytes of each operand, in the third byte of the return value.\n |
| the addition of the fourth bytes of each operand, in the fourth byte of the return value. |
| \remark |
| res[7:0] = val1[7:0] + val2[7:0] \n |
| res[15:8] = val1[15:8] + val2[15:8] \n |
| res[23:16] = val1[23:16] + val2[23:16] \n |
| res[31:24] = val1[31:24] + val2[31:24] |
| */ |
| __ALWAYS_INLINE uint32_t __UADD8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = (((x << 24) >> 24) + ((y << 24) >> 24)) & 0x000000FF; |
| s = (((x << 16) >> 24) + ((y << 16) >> 24)) & 0x000000FF; |
| t = (((x << 8) >> 24) + ((y << 8) >> 24)) & 0x000000FF; |
| u = (((x) >> 24) + ((y) >> 24)) & 0x000000FF; |
| |
| return ((u << 24) | (t << 16) | (s << 8) | (r)); |
| } |
| |
| /** |
| \brief Quad 8-bit saturating subtract. |
| \details This function enables you to perform four 8-bit integer subtractions, |
| saturating the results to the 8-bit signed integer range -2^7 <= x <= 2^7 - 1. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the subtraction of the first byte of each operand in the first byte of the return value.\n |
| the subtraction of the second byte of each operand in the second byte of the return value.\n |
| the subtraction of the third byte of each operand in the third byte of the return value.\n |
| the subtraction of the fourth byte of each operand in the fourth byte of the return value.\n |
| The returned results are saturated to the 8-bit signed integer range -2^7 <= x <= 2^7 - 1. |
| \remark |
| res[7:0] = val1[7:0] - val2[7:0] \n |
| res[15:8] = val1[15:8] - val2[15:8] \n |
| res[23:16] = val1[23:16] - val2[23:16] \n |
| res[31:24] = val1[31:24] - val2[31:24] |
| */ |
| __ALWAYS_INLINE uint32_t __QSUB8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = __SSAT(((((int32_t)x << 24) >> 24) - (((int32_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF; |
| s = __SSAT(((((int32_t)x << 16) >> 24) - (((int32_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF; |
| t = __SSAT(((((int32_t)x << 8) >> 24) - (((int32_t)y << 8) >> 24)), 8) & (int32_t)0x000000FF; |
| u = __SSAT(((((int32_t)x) >> 24) - (((int32_t)y) >> 24)), 8) & (int32_t)0x000000FF; |
| |
| return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); |
| } |
| |
| /** |
| \brief Quad 8-bit unsigned saturating subtraction. |
| \details This function enables you to perform four unsigned 8-bit integer subtractions, |
| saturating the results to the 8-bit unsigned integer range 0 < x < 2^8 - 1. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the subtraction of the first byte of each operand in the first byte of the return value.\n |
| the subtraction of the second byte of each operand in the second byte of the return value.\n |
| the subtraction of the third byte of each operand in the third byte of the return value.\n |
| the subtraction of the fourth byte of each operand in the fourth byte of the return value.\n |
| The returned results are saturated to the 8-bit unsigned integer range 0 <= x <= 2^8 - 1. |
| \remark |
| res[7:0] = val1[7:0] - val2[7:0] \n |
| res[15:8] = val1[15:8] - val2[15:8] \n |
| res[23:16] = val1[23:16] - val2[23:16] \n |
| res[31:24] = val1[31:24] - val2[31:24] |
| */ |
| __ALWAYS_INLINE uint32_t __UQSUB8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = __IUSAT((((x << 24) >> 24) - ((y << 24) >> 24)), 8) & 0x000000FF; |
| s = __IUSAT((((x << 16) >> 24) - ((y << 16) >> 24)), 8) & 0x000000FF; |
| t = __IUSAT((((x << 8) >> 24) - ((y << 8) >> 24)), 8) & 0x000000FF; |
| u = __IUSAT((((x) >> 24) - ((y) >> 24)), 8) & 0x000000FF; |
| |
| return ((u << 24) | (t << 16) | (s << 8) | (r)); |
| } |
| |
| /** |
| \brief Quad 8-bit signed subtraction. |
| \details This function enables you to perform four 8-bit signed integer subtractions. |
| \param [in] x first four 8-bit operands of each subtraction. |
| \param [in] y second four 8-bit operands of each subtraction. |
| \return the subtraction of the first bytes from each operand, in the first byte of the return value.\n |
| the subtraction of the second bytes of each operand, in the second byte of the return value.\n |
| the subtraction of the third bytes of each operand, in the third byte of the return value.\n |
| the subtraction of the fourth bytes of each operand, in the fourth byte of the return value. |
| \remark |
| res[7:0] = val1[7:0] - val2[7:0] \n |
| res[15:8] = val1[15:8] - val2[15:8] \n |
| res[23:16] = val1[23:16] - val2[23:16] \n |
| res[31:24] = val1[31:24] - val2[31:24] |
| */ |
| __ALWAYS_INLINE uint32_t __SSUB8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = ((((int32_t)x << 24) >> 24) - (((int32_t)y << 24) >> 24)) & (int32_t)0x000000FF; |
| s = ((((int32_t)x << 16) >> 24) - (((int32_t)y << 16) >> 24)) & (int32_t)0x000000FF; |
| t = ((((int32_t)x << 8) >> 24) - (((int32_t)y << 8) >> 24)) & (int32_t)0x000000FF; |
| u = ((((int32_t)x) >> 24) - (((int32_t)y) >> 24)) & (int32_t)0x000000FF; |
| |
| return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); |
| } |
| |
| /** |
| \brief Quad 8-bit unsigned subtract. |
| \details This function enables you to perform four 8-bit unsigned integer subtractions. |
| \param [in] x first four 8-bit operands of each subtraction. |
| \param [in] y second four 8-bit operands of each subtraction. |
| \return the subtraction of the first bytes from each operand, in the first byte of the return value.\n |
| the subtraction of the second bytes of each operand, in the second byte of the return value.\n |
| the subtraction of the third bytes of each operand, in the third byte of the return value.\n |
| the subtraction of the fourth bytes of each operand, in the fourth byte of the return value. |
| \remark |
| res[7:0] = val1[7:0] - val2[7:0] \n |
| res[15:8] = val1[15:8] - val2[15:8] \n |
| res[23:16] = val1[23:16] - val2[23:16] \n |
| res[31:24] = val1[31:24] - val2[31:24] |
| */ |
| __ALWAYS_INLINE uint32_t __USUB8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = (((x << 24) >> 24) - ((y << 24) >> 24)) & 0x000000FF; |
| s = (((x << 16) >> 24) - ((y << 16) >> 24)) & 0x000000FF; |
| t = (((x << 8) >> 24) - ((y << 8) >> 24)) & 0x000000FF; |
| u = (((x) >> 24) - ((y) >> 24)) & 0x000000FF; |
| |
| return ((u << 24) | (t << 16) | (s << 8) | (r)); |
| } |
| |
| /** |
| \brief Unsigned sum of quad 8-bit unsigned absolute difference. |
| \details This function enables you to perform four unsigned 8-bit subtractions, and add the absolute values |
| of the differences together, returning the result as a single unsigned integer. |
| \param [in] x first four 8-bit operands of each subtraction. |
| \param [in] y second four 8-bit operands of each subtraction. |
| \return the subtraction of the first bytes from each operand, in the first byte of the return value.\n |
| the subtraction of the second bytes of each operand, in the second byte of the return value.\n |
| the subtraction of the third bytes of each operand, in the third byte of the return value.\n |
| the subtraction of the fourth bytes of each operand, in the fourth byte of the return value.\n |
| The sum is returned as a single unsigned integer. |
| \remark |
| absdiff1 = val1[7:0] - val2[7:0] \n |
| absdiff2 = val1[15:8] - val2[15:8] \n |
| absdiff3 = val1[23:16] - val2[23:16] \n |
| absdiff4 = val1[31:24] - val2[31:24] \n |
| res[31:0] = absdiff1 + absdiff2 + absdiff3 + absdiff4 |
| */ |
| __ALWAYS_INLINE uint32_t __USAD8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = (((x << 24) >> 24) - ((y << 24) >> 24)) & 0x000000FF; |
| s = (((x << 16) >> 24) - ((y << 16) >> 24)) & 0x000000FF; |
| t = (((x << 8) >> 24) - ((y << 8) >> 24)) & 0x000000FF; |
| u = (((x) >> 24) - ((y) >> 24)) & 0x000000FF; |
| |
| return (u + t + s + r); |
| } |
| |
| /** |
| \brief Unsigned sum of quad 8-bit unsigned absolute difference with 32-bit accumulate. |
| \details This function enables you to perform four unsigned 8-bit subtractions, and add the absolute values |
| of the differences to a 32-bit accumulate operand. |
| \param [in] x first four 8-bit operands of each subtraction. |
| \param [in] y second four 8-bit operands of each subtraction. |
| \param [in] sum accumulation value. |
| \return the sum of the absolute differences of the following bytes, added to the accumulation value: |
| the subtraction of the first bytes from each operand, in the first byte of the return value.\n |
| the subtraction of the second bytes of each operand, in the second byte of the return value.\n |
| the subtraction of the third bytes of each operand, in the third byte of the return value.\n |
| the subtraction of the fourth bytes of each operand, in the fourth byte of the return value. |
| \remark |
| absdiff1 = val1[7:0] - val2[7:0] \n |
| absdiff2 = val1[15:8] - val2[15:8] \n |
| absdiff3 = val1[23:16] - val2[23:16] \n |
| absdiff4 = val1[31:24] - val2[31:24] \n |
| sum = absdiff1 + absdiff2 + absdiff3 + absdiff4 \n |
| res[31:0] = sum[31:0] + val3[31:0] |
| */ |
| __ALWAYS_INLINE uint32_t __USADA8(uint32_t x, uint32_t y, uint32_t sum) |
| { |
| int32_t r, s, t, u; |
| |
| r = (abs(((x << 24) >> 24) - ((y << 24) >> 24))) & 0x000000FF; |
| s = (abs(((x << 16) >> 24) - ((y << 16) >> 24))) & 0x000000FF; |
| t = (abs(((x << 8) >> 24) - ((y << 8) >> 24))) & 0x000000FF; |
| u = (abs(((x) >> 24) - ((y) >> 24))) & 0x000000FF; |
| |
| return (u + t + s + r + sum); |
| } |
| |
| /** |
| \brief Dual 16-bit saturating addition. |
| \details This function enables you to perform two 16-bit integer arithmetic additions in parallel, |
| saturating the results to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1. |
| \param [in] x first two 16-bit summands. |
| \param [in] y second two 16-bit summands. |
| \return the saturated addition of the low halfwords, in the low halfword of the return value.\n |
| the saturated addition of the high halfwords, in the high halfword of the return value.\n |
| The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1. |
| \remark |
| res[15:0] = val1[15:0] + val2[15:0] \n |
| res[31:16] = val1[31:16] + val2[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __QADD16(uint32_t x, uint32_t y) |
| { |
| int32_t r = 0, s = 0; |
| |
| r = __SSAT(((((int32_t)x << 16) >> 16) + (((int32_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; |
| s = __SSAT(((((int32_t)x) >> 16) + (((int32_t)y) >> 16)), 16) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned saturating addition. |
| \details This function enables you to perform two unsigned 16-bit integer additions, saturating |
| the results to the 16-bit unsigned integer range 0 < x < 2^16 - 1. |
| \param [in] x first two 16-bit summands. |
| \param [in] y second two 16-bit summands. |
| \return the saturated addition of the low halfwords, in the low halfword of the return value.\n |
| the saturated addition of the high halfwords, in the high halfword of the return value.\n |
| The results are saturated to the 16-bit unsigned integer range 0 < x < 2^16 - 1. |
| \remark |
| res[15:0] = val1[15:0] + val2[15:0] \n |
| res[31:16] = val1[31:16] + val2[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __UQADD16(uint32_t x, uint32_t y) |
| { |
| int32_t r = 0, s = 0; |
| |
| r = __IUSAT((((x << 16) >> 16) + ((y << 16) >> 16)), 16) & 0x0000FFFF; |
| s = __IUSAT((((x) >> 16) + ((y) >> 16)), 16) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit signed addition. |
| \details This function enables you to perform two 16-bit signed integer additions. |
| \param [in] x first two 16-bit summands. |
| \param [in] y second two 16-bit summands. |
| \return the addition of the low halfwords in the low halfword of the return value.\n |
| the addition of the high halfwords in the high halfword of the return value. |
| \remark |
| res[15:0] = val1[15:0] + val2[15:0] \n |
| res[31:16] = val1[31:16] + val2[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __SADD16(uint32_t x, uint32_t y) |
| { |
| int32_t r = 0, s = 0; |
| |
| r = ((((int32_t)x << 16) >> 16) + (((int32_t)y << 16) >> 16)) & (int32_t)0x0000FFFF; |
| s = ((((int32_t)x) >> 16) + (((int32_t)y) >> 16)) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned addition |
| \details This function enables you to perform two 16-bit unsigned integer additions. |
| \param [in] x first two 16-bit summands for each addition. |
| \param [in] y second two 16-bit summands for each addition. |
| \return the addition of the low halfwords in the low halfword of the return value.\n |
| the addition of the high halfwords in the high halfword of the return value. |
| \remark |
| res[15:0] = val1[15:0] + val2[15:0] \n |
| res[31:16] = val1[31:16] + val2[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __UADD16(uint32_t x, uint32_t y) |
| { |
| int32_t r = 0, s = 0; |
| |
| r = (((x << 16) >> 16) + ((y << 16) >> 16)) & 0x0000FFFF; |
| s = (((x) >> 16) + ((y) >> 16)) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| |
| /** |
| \brief Dual 16-bit signed addition with halved results. |
| \details This function enables you to perform two signed 16-bit integer additions, halving the results. |
| \param [in] x first two 16-bit summands. |
| \param [in] y second two 16-bit summands. |
| \return the halved addition of the low halfwords, in the low halfword of the return value.\n |
| the halved addition of the high halfwords, in the high halfword of the return value. |
| \remark |
| res[15:0] = (val1[15:0] + val2[15:0]) >> 1 \n |
| res[31:16] = (val1[31:16] + val2[31:16]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __SHADD16(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = (((((int32_t)x << 16) >> 16) + (((int32_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; |
| s = (((((int32_t)x) >> 16) + (((int32_t)y) >> 16)) >> 1) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned addition with halved results. |
| \details This function enables you to perform two unsigned 16-bit integer additions, halving the results. |
| \param [in] x first two 16-bit summands. |
| \param [in] y second two 16-bit summands. |
| \return the halved addition of the low halfwords, in the low halfword of the return value.\n |
| the halved addition of the high halfwords, in the high halfword of the return value. |
| \remark |
| res[15:0] = (val1[15:0] + val2[15:0]) >> 1 \n |
| res[31:16] = (val1[31:16] + val2[31:16]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __UHADD16(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = ((((x << 16) >> 16) + ((y << 16) >> 16)) >> 1) & 0x0000FFFF; |
| s = ((((x) >> 16) + ((y) >> 16)) >> 1) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Quad 8-bit signed addition with halved results. |
| \details This function enables you to perform four signed 8-bit integer additions, halving the results. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the halved addition of the first bytes from each operand, in the first byte of the return value.\n |
| the halved addition of the second bytes from each operand, in the second byte of the return value.\n |
| the halved addition of the third bytes from each operand, in the third byte of the return value.\n |
| the halved addition of the fourth bytes from each operand, in the fourth byte of the return value. |
| \remark |
| res[7:0] = (val1[7:0] + val2[7:0] ) >> 1 \n |
| res[15:8] = (val1[15:8] + val2[15:8] ) >> 1 \n |
| res[23:16] = (val1[23:16] + val2[23:16]) >> 1 \n |
| res[31:24] = (val1[31:24] + val2[31:24]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __SHADD8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = (((((int32_t)x << 24) >> 24) + (((int32_t)y << 24) >> 24)) >> 1) & (int32_t)0x000000FF; |
| s = (((((int32_t)x << 16) >> 24) + (((int32_t)y << 16) >> 24)) >> 1) & (int32_t)0x000000FF; |
| t = (((((int32_t)x << 8) >> 24) + (((int32_t)y << 8) >> 24)) >> 1) & (int32_t)0x000000FF; |
| u = (((((int32_t)x) >> 24) + (((int32_t)y) >> 24)) >> 1) & (int32_t)0x000000FF; |
| |
| return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); |
| } |
| |
| /** |
| \brief Quad 8-bit unsigned addition with halved results. |
| \details This function enables you to perform four unsigned 8-bit integer additions, halving the results. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the halved addition of the first bytes from each operand, in the first byte of the return value.\n |
| the halved addition of the second bytes from each operand, in the second byte of the return value.\n |
| the halved addition of the third bytes from each operand, in the third byte of the return value.\n |
| the halved addition of the fourth bytes from each operand, in the fourth byte of the return value. |
| \remark |
| res[7:0] = (val1[7:0] + val2[7:0] ) >> 1 \n |
| res[15:8] = (val1[15:8] + val2[15:8] ) >> 1 \n |
| res[23:16] = (val1[23:16] + val2[23:16]) >> 1 \n |
| res[31:24] = (val1[31:24] + val2[31:24]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __UHADD8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = ((((x << 24) >> 24) + ((y << 24) >> 24)) >> 1) & 0x000000FF; |
| s = ((((x << 16) >> 24) + ((y << 16) >> 24)) >> 1) & 0x000000FF; |
| t = ((((x << 8) >> 24) + ((y << 8) >> 24)) >> 1) & 0x000000FF; |
| u = ((((x) >> 24) + ((y) >> 24)) >> 1) & 0x000000FF; |
| |
| return ((u << 24) | (t << 16) | (s << 8) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit saturating subtract. |
| \details This function enables you to perform two 16-bit integer subtractions in parallel, |
| saturating the results to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1. |
| \param [in] x first two 16-bit summands. |
| \param [in] y second two 16-bit summands. |
| \return the saturated subtraction of the low halfwords, in the low halfword of the return value.\n |
| the saturated subtraction of the high halfwords, in the high halfword of the return value.\n |
| The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1. |
| \remark |
| res[15:0] = val1[15:0] - val2[15:0] \n |
| res[31:16] = val1[31:16] - val2[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __QSUB16(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = __SSAT(((((int32_t)x << 16) >> 16) - (((int32_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; |
| s = __SSAT(((((int32_t)x) >> 16) - (((int32_t)y) >> 16)), 16) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned saturating subtraction. |
| \details This function enables you to perform two unsigned 16-bit integer subtractions, |
| saturating the results to the 16-bit unsigned integer range 0 < x < 2^16 - 1. |
| \param [in] x first two 16-bit operands for each subtraction. |
| \param [in] y second two 16-bit operands for each subtraction. |
| \return the saturated subtraction of the low halfwords, in the low halfword of the return value.\n |
| the saturated subtraction of the high halfwords, in the high halfword of the return value.\n |
| The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1. |
| \remark |
| res[15:0] = val1[15:0] - val2[15:0] \n |
| res[31:16] = val1[31:16] - val2[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __UQSUB16(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = __IUSAT((((x << 16) >> 16) - ((y << 16) >> 16)), 16) & 0x0000FFFF; |
| s = __IUSAT((((x) >> 16) - ((y) >> 16)), 16) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit signed subtraction. |
| \details This function enables you to perform two 16-bit signed integer subtractions. |
| \param [in] x first two 16-bit operands of each subtraction. |
| \param [in] y second two 16-bit operands of each subtraction. |
| \return the subtraction of the low halfword in the second operand from the low |
| halfword in the first operand, in the low halfword of the return value. \n |
| the subtraction of the high halfword in the second operand from the high |
| halfword in the first operand, in the high halfword of the return value. |
| \remark |
| res[15:0] = val1[15:0] - val2[15:0] \n |
| res[31:16] = val1[31:16] - val2[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __SSUB16(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = ((((int32_t)x << 16) >> 16) - (((int32_t)y << 16) >> 16)) & (int32_t)0x0000FFFF; |
| s = ((((int32_t)x) >> 16) - (((int32_t)y) >> 16)) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned subtract. |
| \details This function enables you to perform two 16-bit unsigned integer subtractions. |
| \param [in] x first two 16-bit operands of each subtraction. |
| \param [in] y second two 16-bit operands of each subtraction. |
| \return the subtraction of the low halfword in the second operand from the low |
| halfword in the first operand, in the low halfword of the return value. \n |
| the subtraction of the high halfword in the second operand from the high |
| halfword in the first operand, in the high halfword of the return value. |
| \remark |
| res[15:0] = val1[15:0] - val2[15:0] \n |
| res[31:16] = val1[31:16] - val2[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __USUB16(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = (((x << 16) >> 16) - ((y << 16) >> 16)) & 0x0000FFFF; |
| s = (((x) >> 16) - ((y) >> 16)) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit signed subtraction with halved results. |
| \details This function enables you to perform two signed 16-bit integer subtractions, halving the results. |
| \param [in] x first two 16-bit summands. |
| \param [in] y second two 16-bit summands. |
| \return the halved subtraction of the low halfwords, in the low halfword of the return value.\n |
| the halved subtraction of the high halfwords, in the high halfword of the return value. |
| \remark |
| res[15:0] = (val1[15:0] - val2[15:0]) >> 1 \n |
| res[31:16] = (val1[31:16] - val2[31:16]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __SHSUB16(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = (((((int32_t)x << 16) >> 16) - (((int32_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; |
| s = (((((int32_t)x) >> 16) - (((int32_t)y) >> 16)) >> 1) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned subtraction with halved results. |
| \details This function enables you to perform two unsigned 16-bit integer subtractions, halving the results. |
| \param [in] x first two 16-bit summands. |
| \param [in] y second two 16-bit summands. |
| \return the halved subtraction of the low halfwords, in the low halfword of the return value.\n |
| the halved subtraction of the high halfwords, in the high halfword of the return value. |
| \remark |
| res[15:0] = (val1[15:0] - val2[15:0]) >> 1 \n |
| res[31:16] = (val1[31:16] - val2[31:16]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __UHSUB16(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = ((((x << 16) >> 16) - ((y << 16) >> 16)) >> 1) & 0x0000FFFF; |
| s = ((((x) >> 16) - ((y) >> 16)) >> 1) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Quad 8-bit signed addition with halved results. |
| \details This function enables you to perform four signed 8-bit integer subtractions, halving the results. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the halved subtraction of the first bytes from each operand, in the first byte of the return value.\n |
| the halved subtraction of the second bytes from each operand, in the second byte of the return value.\n |
| the halved subtraction of the third bytes from each operand, in the third byte of the return value.\n |
| the halved subtraction of the fourth bytes from each operand, in the fourth byte of the return value. |
| \remark |
| res[7:0] = (val1[7:0] - val2[7:0] ) >> 1 \n |
| res[15:8] = (val1[15:8] - val2[15:8] ) >> 1 \n |
| res[23:16] = (val1[23:16] - val2[23:16]) >> 1 \n |
| res[31:24] = (val1[31:24] - val2[31:24]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __SHSUB8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = (((((int32_t)x << 24) >> 24) - (((int32_t)y << 24) >> 24)) >> 1) & (int32_t)0x000000FF; |
| s = (((((int32_t)x << 16) >> 24) - (((int32_t)y << 16) >> 24)) >> 1) & (int32_t)0x000000FF; |
| t = (((((int32_t)x << 8) >> 24) - (((int32_t)y << 8) >> 24)) >> 1) & (int32_t)0x000000FF; |
| u = (((((int32_t)x) >> 24) - (((int32_t)y) >> 24)) >> 1) & (int32_t)0x000000FF; |
| |
| return ((uint32_t)((u << 24) | (t << 16) | (s << 8) | (r))); |
| } |
| |
| /** |
| \brief Quad 8-bit unsigned subtraction with halved results. |
| \details This function enables you to perform four unsigned 8-bit integer subtractions, halving the results. |
| \param [in] x first four 8-bit summands. |
| \param [in] y second four 8-bit summands. |
| \return the halved subtraction of the first bytes from each operand, in the first byte of the return value.\n |
| the halved subtraction of the second bytes from each operand, in the second byte of the return value.\n |
| the halved subtraction of the third bytes from each operand, in the third byte of the return value.\n |
| the halved subtraction of the fourth bytes from each operand, in the fourth byte of the return value. |
| \remark |
| res[7:0] = (val1[7:0] - val2[7:0] ) >> 1 \n |
| res[15:8] = (val1[15:8] - val2[15:8] ) >> 1 \n |
| res[23:16] = (val1[23:16] - val2[23:16]) >> 1 \n |
| res[31:24] = (val1[31:24] - val2[31:24]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __UHSUB8(uint32_t x, uint32_t y) |
| { |
| int32_t r, s, t, u; |
| |
| r = ((((x << 24) >> 24) - ((y << 24) >> 24)) >> 1) & 0x000000FF; |
| s = ((((x << 16) >> 24) - ((y << 16) >> 24)) >> 1) & 0x000000FF; |
| t = ((((x << 8) >> 24) - ((y << 8) >> 24)) >> 1) & 0x000000FF; |
| u = ((((x) >> 24) - ((y) >> 24)) >> 1) & 0x000000FF; |
| |
| return ((u << 24) | (t << 16) | (s << 8) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit add and subtract with exchange. |
| \details This function enables you to exchange the halfwords of the one operand, |
| then add the high halfwords and subtract the low halfwords, |
| saturating the results to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1. |
| \param [in] x first operand for the subtraction in the low halfword, |
| and the first operand for the addition in the high halfword. |
| \param [in] y second operand for the subtraction in the high halfword, |
| and the second operand for the addition in the low halfword. |
| \return the saturated subtraction of the high halfword in the second operand from the |
| low halfword in the first operand, in the low halfword of the return value.\n |
| the saturated addition of the high halfword in the first operand and the |
| low halfword in the second operand, in the high halfword of the return value.\n |
| The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1. |
| \remark |
| res[15:0] = val1[15:0] - val2[31:16] \n |
| res[31:16] = val1[31:16] + val2[15:0] |
| */ |
| __ALWAYS_INLINE uint32_t __QASX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = __SSAT(((((int32_t)x << 16) >> 16) - (((int32_t)y) >> 16)), 16) & (int32_t)0x0000FFFF; |
| s = __SSAT(((((int32_t)x) >> 16) + (((int32_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned saturating addition and subtraction with exchange. |
| \details This function enables you to exchange the halfwords of the second operand and |
| perform one unsigned 16-bit integer addition and one unsigned 16-bit subtraction, |
| saturating the results to the 16-bit unsigned integer range 0 <= x <= 2^16 - 1. |
| \param [in] x first operand for the subtraction in the low halfword, |
| and the first operand for the addition in the high halfword. |
| \param [in] y second operand for the subtraction in the high halfword, |
| and the second operand for the addition in the low halfword. |
| \return the saturated subtraction of the high halfword in the second operand from the |
| low halfword in the first operand, in the low halfword of the return value.\n |
| the saturated addition of the high halfword in the first operand and the |
| low halfword in the second operand, in the high halfword of the return value.\n |
| The returned results are saturated to the 16-bit unsigned integer range 0 <= x <= 2^16 - 1. |
| \remark |
| res[15:0] = val1[15:0] - val2[31:16] \n |
| res[31:16] = val1[31:16] + val2[15:0] |
| */ |
| __ALWAYS_INLINE uint32_t __UQASX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = __IUSAT((((x << 16) >> 16) - ((y) >> 16)), 16) & 0x0000FFFF; |
| s = __IUSAT((((x) >> 16) + ((y << 16) >> 16)), 16) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit addition and subtraction with exchange. |
| \details It enables you to exchange the halfwords of the second operand, add the high halfwords |
| and subtract the low halfwords. |
| \param [in] x first operand for the subtraction in the low halfword, |
| and the first operand for the addition in the high halfword. |
| \param [in] y second operand for the subtraction in the high halfword, |
| and the second operand for the addition in the low halfword. |
| \return the subtraction of the high halfword in the second operand from the |
| low halfword in the first operand, in the low halfword of the return value.\n |
| the addition of the high halfword in the first operand and the |
| low halfword in the second operand, in the high halfword of the return value. |
| \remark |
| res[15:0] = val1[15:0] - val2[31:16] \n |
| res[31:16] = val1[31:16] + val2[15:0] |
| */ |
| __ALWAYS_INLINE uint32_t __SASX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = ((((int32_t)x << 16) >> 16) - (((int32_t)y) >> 16)) & (int32_t)0x0000FFFF; |
| s = ((((int32_t)x) >> 16) + (((int32_t)y << 16) >> 16)) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned addition and subtraction with exchange. |
| \details This function enables you to exchange the two halfwords of the second operand, |
| add the high halfwords and subtract the low halfwords. |
| \param [in] x first operand for the subtraction in the low halfword, |
| and the first operand for the addition in the high halfword. |
| \param [in] y second operand for the subtraction in the high halfword, |
| and the second operand for the addition in the low halfword. |
| \return the subtraction of the high halfword in the second operand from the |
| low halfword in the first operand, in the low halfword of the return value.\n |
| the addition of the high halfword in the first operand and the |
| low halfword in the second operand, in the high halfword of the return value. |
| \remark |
| res[15:0] = val1[15:0] - val2[31:16] \n |
| res[31:16] = val1[31:16] + val2[15:0] |
| */ |
| __ALWAYS_INLINE uint32_t __UASX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = (((x << 16) >> 16) - ((y) >> 16)) & 0x0000FFFF; |
| s = (((x) >> 16) + ((y << 16) >> 16)) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit signed addition and subtraction with halved results. |
| \details This function enables you to exchange the two halfwords of one operand, perform one |
| signed 16-bit integer addition and one signed 16-bit subtraction, and halve the results. |
| \param [in] x first 16-bit operands. |
| \param [in] y second 16-bit operands. |
| \return the halved subtraction of the high halfword in the second operand from the |
| low halfword in the first operand, in the low halfword of the return value.\n |
| the halved addition of the low halfword in the second operand from the high |
| halfword in the first operand, in the high halfword of the return value. |
| \remark |
| res[15:0] = (val1[15:0] - val2[31:16]) >> 1 \n |
| res[31:16] = (val1[31:16] + val2[15:0]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __SHASX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = (((((int32_t)x << 16) >> 16) - (((int32_t)y) >> 16)) >> 1) & (int32_t)0x0000FFFF; |
| s = (((((int32_t)x) >> 16) + (((int32_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned addition and subtraction with halved results and exchange. |
| \details This function enables you to exchange the halfwords of the second operand, |
| add the high halfwords and subtract the low halfwords, halving the results. |
| \param [in] x first operand for the subtraction in the low halfword, and |
| the first operand for the addition in the high halfword. |
| \param [in] y second operand for the subtraction in the high halfword, and |
| the second operand for the addition in the low halfword. |
| \return the halved subtraction of the high halfword in the second operand from the |
| low halfword in the first operand, in the low halfword of the return value.\n |
| the halved addition of the low halfword in the second operand from the high |
| halfword in the first operand, in the high halfword of the return value. |
| \remark |
| res[15:0] = (val1[15:0] - val2[31:16]) >> 1 \n |
| res[31:16] = (val1[31:16] + val2[15:0]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __UHASX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = ((((x << 16) >> 16) - ((y) >> 16)) >> 1) & 0x0000FFFF; |
| s = ((((x) >> 16) + ((y << 16) >> 16)) >> 1) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit subtract and add with exchange. |
| \details This function enables you to exchange the halfwords of one operand, |
| then subtract the high halfwords and add the low halfwords, |
| saturating the results to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1. |
| \param [in] x first operand for the addition in the low halfword, |
| and the first operand for the subtraction in the high halfword. |
| \param [in] y second operand for the addition in the high halfword, |
| and the second operand for the subtraction in the low halfword. |
| \return the saturated addition of the low halfword of the first operand and the high |
| halfword of the second operand, in the low halfword of the return value.\n |
| the saturated subtraction of the low halfword of the second operand from the |
| high halfword of the first operand, in the high halfword of the return value.\n |
| The returned results are saturated to the 16-bit signed integer range -2^15 <= x <= 2^15 - 1. |
| \remark |
| res[15:0] = val1[15:0] + val2[31:16] \n |
| res[31:16] = val1[31:16] - val2[15:0] |
| */ |
| __ALWAYS_INLINE uint32_t __QSAX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = __SSAT(((((int32_t)x << 16) >> 16) + (((int32_t)y) >> 16)), 16) & (int32_t)0x0000FFFF; |
| s = __SSAT(((((int32_t)x) >> 16) - (((int32_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned saturating subtraction and addition with exchange. |
| \details This function enables you to exchange the halfwords of the second operand and perform |
| one unsigned 16-bit integer subtraction and one unsigned 16-bit addition, saturating |
| the results to the 16-bit unsigned integer range 0 <= x <= 2^16 - 1. |
| \param [in] x first operand for the addition in the low halfword, |
| and the first operand for the subtraction in the high halfword. |
| \param [in] y second operand for the addition in the high halfword, |
| and the second operand for the subtraction in the low halfword. |
| \return the saturated addition of the low halfword of the first operand and the high |
| halfword of the second operand, in the low halfword of the return value.\n |
| the saturated subtraction of the low halfword of the second operand from the |
| high halfword of the first operand, in the high halfword of the return value.\n |
| The returned results are saturated to the 16-bit unsigned integer range 0 <= x <= 2^16 - 1. |
| \remark |
| res[15:0] = val1[15:0] + val2[31:16] \n |
| res[31:16] = val1[31:16] - val2[15:0] |
| */ |
| __ALWAYS_INLINE uint32_t __UQSAX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = __IUSAT((((x << 16) >> 16) + ((y) >> 16)), 16) & 0x0000FFFF; |
| s = __IUSAT((((x) >> 16) - ((y << 16) >> 16)), 16) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned subtract and add with exchange. |
| \details This function enables you to exchange the halfwords of the second operand, |
| subtract the high halfwords and add the low halfwords. |
| \param [in] x first operand for the addition in the low halfword, |
| and the first operand for the subtraction in the high halfword. |
| \param [in] y second operand for the addition in the high halfword, |
| and the second operand for the subtraction in the low halfword. |
| \return the addition of the low halfword of the first operand and the high |
| halfword of the second operand, in the low halfword of the return value.\n |
| the subtraction of the low halfword of the second operand from the |
| high halfword of the first operand, in the high halfword of the return value.\n |
| \remark |
| res[15:0] = val1[15:0] + val2[31:16] \n |
| res[31:16] = val1[31:16] - val2[15:0] |
| */ |
| __ALWAYS_INLINE uint32_t __USAX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = (((x << 16) >> 16) + ((y) >> 16)) & 0x0000FFFF; |
| s = (((x) >> 16) - ((y << 16) >> 16)) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit signed subtraction and addition with exchange. |
| \details This function enables you to exchange the two halfwords of one operand and perform one |
| 16-bit integer subtraction and one 16-bit addition. |
| \param [in] x first operand for the addition in the low halfword, and the first operand |
| for the subtraction in the high halfword. |
| \param [in] y second operand for the addition in the high halfword, and the second |
| operand for the subtraction in the low halfword. |
| \return the addition of the low halfword of the first operand and the high |
| halfword of the second operand, in the low halfword of the return value.\n |
| the subtraction of the low halfword of the second operand from the |
| high halfword of the first operand, in the high halfword of the return value.\n |
| \remark |
| res[15:0] = val1[15:0] + val2[31:16] \n |
| res[31:16] = val1[31:16] - val2[15:0] |
| */ |
| __ALWAYS_INLINE uint32_t __SSAX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = ((((int32_t)x << 16) >> 16) + (((int32_t)y) >> 16)) & (int32_t)0x0000FFFF; |
| s = ((((int32_t)x) >> 16) - (((int32_t)y << 16) >> 16)) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| |
| /** |
| \brief Dual 16-bit signed subtraction and addition with halved results. |
| \details This function enables you to exchange the two halfwords of one operand, perform one signed |
| 16-bit integer subtraction and one signed 16-bit addition, and halve the results. |
| \param [in] x first 16-bit operands. |
| \param [in] y second 16-bit operands. |
| \return the halved addition of the low halfword in the first operand and the |
| high halfword in the second operand, in the low halfword of the return value.\n |
| the halved subtraction of the low halfword in the second operand from the |
| high halfword in the first operand, in the high halfword of the return value. |
| \remark |
| res[15:0] = (val1[15:0] + val2[31:16]) >> 1 \n |
| res[31:16] = (val1[31:16] - val2[15:0]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __SHSAX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = (((((int32_t)x << 16) >> 16) + (((int32_t)y) >> 16)) >> 1) & (int32_t)0x0000FFFF; |
| s = (((((int32_t)x) >> 16) - (((int32_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF; |
| |
| return ((uint32_t)((s << 16) | (r))); |
| } |
| |
| /** |
| \brief Dual 16-bit unsigned subtraction and addition with halved results and exchange. |
| \details This function enables you to exchange the halfwords of the second operand, |
| subtract the high halfwords and add the low halfwords, halving the results. |
| \param [in] x first operand for the addition in the low halfword, and |
| the first operand for the subtraction in the high halfword. |
| \param [in] y second operand for the addition in the high halfword, and |
| the second operand for the subtraction in the low halfword. |
| \return the halved addition of the low halfword in the first operand and the |
| high halfword in the second operand, in the low halfword of the return value.\n |
| the halved subtraction of the low halfword in the second operand from the |
| high halfword in the first operand, in the high halfword of the return value. |
| \remark |
| res[15:0] = (val1[15:0] + val2[31:16]) >> 1 \n |
| res[31:16] = (val1[31:16] - val2[15:0]) >> 1 |
| */ |
| __ALWAYS_INLINE uint32_t __UHSAX(uint32_t x, uint32_t y) |
| { |
| int32_t r, s; |
| |
| r = ((((x << 16) >> 16) + ((y) >> 16)) >> 1) & 0x0000FFFF; |
| s = ((((x) >> 16) - ((y << 16) >> 16)) >> 1) & 0x0000FFFF; |
| |
| return ((s << 16) | (r)); |
| } |
| |
| /** |
| \brief Dual 16-bit signed multiply with exchange returning difference. |
| \details This function enables you to perform two 16-bit signed multiplications, subtracting |
| one of the products from the other. The halfwords of the second operand are exchanged |
| before performing the arithmetic. This produces top * bottom and bottom * top multiplication. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \return the difference of the products of the two 16-bit signed multiplications. |
| \remark |
| p1 = val1[15:0] * val2[31:16] \n |
| p2 = val1[31:16] * val2[15:0] \n |
| res[31:0] = p1 - p2 |
| */ |
| __ALWAYS_INLINE uint32_t __SMUSDX(uint32_t x, uint32_t y) |
| { |
| return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y) >> 16)) - |
| ((((int32_t)x) >> 16) * (((int32_t)y << 16) >> 16)))); |
| } |
| |
| /** |
| \brief Sum of dual 16-bit signed multiply with exchange. |
| \details This function enables you to perform two 16-bit signed multiplications with exchanged |
| halfwords of the second operand, adding the products together. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \return the sum of the products of the two 16-bit signed multiplications with exchanged halfwords of the second operand. |
| \remark |
| p1 = val1[15:0] * val2[31:16] \n |
| p2 = val1[31:16] * val2[15:0] \n |
| res[31:0] = p1 + p2 |
| */ |
| __ALWAYS_INLINE uint32_t __SMUADX(uint32_t x, uint32_t y) |
| { |
| return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y) >> 16)) + |
| ((((int32_t)x) >> 16) * (((int32_t)y << 16) >> 16)))); |
| } |
| |
| |
| /** |
| \brief Saturating add. |
| \details This function enables you to obtain the saturating add of two integers. |
| \param [in] x first summand of the saturating add operation. |
| \param [in] y second summand of the saturating add operation. |
| \return the saturating addition of val1 and val2. |
| \remark |
| res[31:0] = SAT(val1 + SAT(val2)) |
| */ |
| __ALWAYS_INLINE int32_t __QADD(int32_t x, int32_t y) |
| { |
| int32_t result; |
| |
| if (y >= 0) { |
| if (x + y >= x) { |
| result = x + y; |
| } else { |
| result = 0x7FFFFFFF; |
| } |
| } else { |
| if (x + y < x) { |
| result = x + y; |
| } else { |
| result = 0x80000000; |
| } |
| } |
| |
| return result; |
| } |
| |
| /** |
| \brief Saturating subtract. |
| \details This function enables you to obtain the saturating add of two integers. |
| \param [in] x first summand of the saturating add operation. |
| \param [in] y second summand of the saturating add operation. |
| \return the saturating addition of val1 and val2. |
| \remark |
| res[31:0] = SAT(val1 + SAT(val2)) |
| */ |
| __ALWAYS_INLINE int32_t __QSUB(int32_t x, int32_t y) |
| { |
| int64_t tmp; |
| int32_t result; |
| |
| tmp = (int64_t)x - (int64_t)y; |
| |
| if (tmp > 0x7fffffff) { |
| tmp = 0x7fffffff; |
| } else if (tmp < (-2147483647 - 1)) { |
| tmp = -2147483647 - 1; |
| } |
| |
| result = tmp; |
| return result; |
| } |
| |
| /** |
| \brief Dual 16-bit signed multiply with single 32-bit accumulator. |
| \details This function enables you to perform two signed 16-bit multiplications, |
| adding both results to a 32-bit accumulate operand. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \param [in] sum accumulate value. |
| \return the product of each multiplication added to the accumulate value, as a 32-bit integer. |
| \remark |
| p1 = val1[15:0] * val2[15:0] \n |
| p2 = val1[31:16] * val2[31:16] \n |
| res[31:0] = p1 + p2 + val3[31:0] |
| */ |
| __ALWAYS_INLINE uint32_t __SMLAD(uint32_t x, uint32_t y, uint32_t sum) |
| { |
| return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y << 16) >> 16)) + |
| ((((int32_t)x) >> 16) * (((int32_t)y) >> 16)) + |
| (((int32_t)sum)))); |
| } |
| |
| /** |
| \brief Pre-exchanged dual 16-bit signed multiply with single 32-bit accumulator. |
| \details This function enables you to perform two signed 16-bit multiplications with exchanged |
| halfwords of the second operand, adding both results to a 32-bit accumulate operand. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \param [in] sum accumulate value. |
| \return the product of each multiplication with exchanged halfwords of the second |
| operand added to the accumulate value, as a 32-bit integer. |
| \remark |
| p1 = val1[15:0] * val2[31:16] \n |
| p2 = val1[31:16] * val2[15:0] \n |
| res[31:0] = p1 + p2 + val3[31:0] |
| */ |
| __ALWAYS_INLINE uint32_t __SMLADX(uint32_t x, uint32_t y, uint32_t sum) |
| { |
| return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y) >> 16)) + |
| ((((int32_t)x) >> 16) * (((int32_t)y << 16) >> 16)) + |
| (((int32_t)sum)))); |
| } |
| |
| /** |
| \brief Dual 16-bit signed multiply with exchange subtract with 32-bit accumulate. |
| \details This function enables you to perform two 16-bit signed multiplications, take the |
| difference of the products, subtracting the high halfword product from the low |
| halfword product, and add the difference to a 32-bit accumulate operand. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \param [in] sum accumulate value. |
| \return the difference of the product of each multiplication, added to the accumulate value. |
| \remark |
| p1 = val1[15:0] * val2[15:0] \n |
| p2 = val1[31:16] * val2[31:16] \n |
| res[31:0] = p1 - p2 + val3[31:0] |
| */ |
| __ALWAYS_INLINE uint32_t __SMLSD(uint32_t x, uint32_t y, uint32_t sum) |
| { |
| return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y << 16) >> 16)) - |
| ((((int32_t)x) >> 16) * (((int32_t)y) >> 16)) + |
| (((int32_t)sum)))); |
| } |
| |
| /** |
| \brief Dual 16-bit signed multiply with exchange subtract with 32-bit accumulate. |
| \details This function enables you to exchange the halfwords in the second operand, then perform two 16-bit |
| signed multiplications. The difference of the products is added to a 32-bit accumulate operand. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \param [in] sum accumulate value. |
| \return the difference of the product of each multiplication, added to the accumulate value. |
| \remark |
| p1 = val1[15:0] * val2[31:16] \n |
| p2 = val1[31:16] * val2[15:0] \n |
| res[31:0] = p1 - p2 + val3[31:0] |
| */ |
| __ALWAYS_INLINE uint32_t __SMLSDX(uint32_t x, uint32_t y, uint32_t sum) |
| { |
| return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y) >> 16)) - |
| ((((int32_t)x) >> 16) * (((int32_t)y << 16) >> 16)) + |
| (((int32_t)sum)))); |
| } |
| |
| /** |
| \brief Dual 16-bit signed multiply with single 64-bit accumulator. |
| \details This function enables you to perform two signed 16-bit multiplications, adding both results |
| to a 64-bit accumulate operand. Overflow is only possible as a result of the 64-bit addition. |
| This overflow is not detected if it occurs. Instead, the result wraps around modulo2^64. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \param [in] sum accumulate value. |
| \return the product of each multiplication added to the accumulate value. |
| \remark |
| p1 = val1[15:0] * val2[15:0] \n |
| p2 = val1[31:16] * val2[31:16] \n |
| sum = p1 + p2 + val3[63:32][31:0] \n |
| res[63:32] = sum[63:32] \n |
| res[31:0] = sum[31:0] |
| */ |
| __ALWAYS_INLINE uint64_t __SMLALD(uint32_t x, uint32_t y, uint64_t sum) |
| { |
| return ((uint64_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y << 16) >> 16)) + |
| ((((int32_t)x) >> 16) * (((int32_t)y) >> 16)) + |
| (((uint64_t)sum)))); |
| } |
| |
| /** |
| \brief Dual 16-bit signed multiply with exchange with single 64-bit accumulator. |
| \details This function enables you to exchange the halfwords of the second operand, and perform two |
| signed 16-bit multiplications, adding both results to a 64-bit accumulate operand. Overflow |
| is only possible as a result of the 64-bit addition. This overflow is not detected if it occurs. |
| Instead, the result wraps around modulo2^64. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \param [in] sum accumulate value. |
| \return the product of each multiplication added to the accumulate value. |
| \remark |
| p1 = val1[15:0] * val2[31:16] \n |
| p2 = val1[31:16] * val2[15:0] \n |
| sum = p1 + p2 + val3[63:32][31:0] \n |
| res[63:32] = sum[63:32] \n |
| res[31:0] = sum[31:0] |
| */ |
| __ALWAYS_INLINE uint64_t __SMLALDX(uint32_t x, uint32_t y, uint64_t sum) |
| { |
| return ((uint64_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y) >> 16)) + |
| ((((int32_t)x) >> 16) * (((int32_t)y << 16) >> 16)) + |
| (((uint64_t)sum)))); |
| } |
| |
| /** |
| \brief dual 16-bit signed multiply subtract with 64-bit accumulate. |
| \details This function It enables you to perform two 16-bit signed multiplications, take the difference |
| of the products, subtracting the high halfword product from the low halfword product, and add the |
| difference to a 64-bit accumulate operand. Overflow cannot occur during the multiplications or the |
| subtraction. Overflow can occur as a result of the 64-bit addition, and this overflow is not |
| detected. Instead, the result wraps round to modulo2^64. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \param [in] sum accumulate value. |
| \return the difference of the product of each multiplication, added to the accumulate value. |
| \remark |
| p1 = val1[15:0] * val2[15:0] \n |
| p2 = val1[31:16] * val2[31:16] \n |
| res[63:0] = p1 - p2 + val3[63:0] |
| */ |
| __ALWAYS_INLINE uint64_t __SMLSLD(uint32_t x, uint32_t y, uint64_t sum) |
| { |
| return ((uint64_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y << 16) >> 16)) - |
| ((((int32_t)x) >> 16) * (((int32_t)y) >> 16)) + |
| (((uint64_t)sum)))); |
| } |
| |
| /** |
| \brief Dual 16-bit signed multiply with exchange subtract with 64-bit accumulate. |
| \details This function enables you to exchange the halfwords of the second operand, perform two 16-bit multiplications, |
| adding the difference of the products to a 64-bit accumulate operand. Overflow cannot occur during the |
| multiplications or the subtraction. Overflow can occur as a result of the 64-bit addition, and this overflow |
| is not detected. Instead, the result wraps round to modulo2^64. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \param [in] sum accumulate value. |
| \return the difference of the product of each multiplication, added to the accumulate value. |
| \remark |
| p1 = val1[15:0] * val2[31:16] \n |
| p2 = val1[31:16] * val2[15:0] \n |
| res[63:0] = p1 - p2 + val3[63:0] |
| */ |
| __ALWAYS_INLINE uint64_t __SMLSLDX(uint32_t x, uint32_t y, uint64_t sum) |
| { |
| return ((uint64_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y) >> 16)) - |
| ((((int32_t)x) >> 16) * (((int32_t)y << 16) >> 16)) + |
| (((uint64_t)sum)))); |
| } |
| |
| /** |
| \brief 32-bit signed multiply with 32-bit truncated accumulator. |
| \details This function enables you to perform a signed 32-bit multiplications, adding the most |
| significant 32 bits of the 64-bit result to a 32-bit accumulate operand. |
| \param [in] x first operand for multiplication. |
| \param [in] y second operand for multiplication. |
| \param [in] sum accumulate value. |
| \return the product of multiplication (most significant 32 bits) is added to the accumulate value, as a 32-bit integer. |
| \remark |
| p = val1 * val2 \n |
| res[31:0] = p[61:32] + val3[31:0] |
| */ |
| __ALWAYS_INLINE uint32_t __SMMLA(int32_t x, int32_t y, int32_t sum) |
| { |
| return (uint32_t)((int32_t)((int64_t)((int64_t)x * (int64_t)y) >> 32) + sum); |
| } |
| |
| /** |
| \brief Sum of dual 16-bit signed multiply. |
| \details This function enables you to perform two 16-bit signed multiplications, adding the products together. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \return the sum of the products of the two 16-bit signed multiplications. |
| \remark |
| p1 = val1[15:0] * val2[15:0] \n |
| p2 = val1[31:16] * val2[31:16] \n |
| res[31:0] = p1 + p2 |
| */ |
| __ALWAYS_INLINE uint32_t __SMUAD(uint32_t x, uint32_t y) |
| { |
| return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y << 16) >> 16)) + |
| ((((int32_t)x) >> 16) * (((int32_t)y) >> 16)))); |
| } |
| |
| /** |
| \brief Dual 16-bit signed multiply returning difference. |
| \details This function enables you to perform two 16-bit signed multiplications, taking the difference |
| of the products by subtracting the high halfword product from the low halfword product. |
| \param [in] x first 16-bit operands for each multiplication. |
| \param [in] y second 16-bit operands for each multiplication. |
| \return the difference of the products of the two 16-bit signed multiplications. |
| \remark |
| p1 = val1[15:0] * val2[15:0] \n |
| p2 = val1[31:16] * val2[31:16] \n |
| res[31:0] = p1 - p2 |
| */ |
| __ALWAYS_INLINE uint32_t __SMUSD(uint32_t x, uint32_t y) |
| { |
| return ((uint32_t)(((((int32_t)x << 16) >> 16) * (((int32_t)y << 16) >> 16)) - |
| ((((int32_t)x) >> 16) * (((int32_t)y) >> 16)))); |
| } |
| |
| /** |
| \brief Dual extracted 8-bit to 16-bit signed addition. |
| \details This function enables you to extract two 8-bit values from the second operand (at bit positions |
| [7:0] and [23:16]), sign-extend them to 16-bits each, and add the results to the first operand. |
| \param [in] x values added to the sign-extended to 16-bit values. |
| \param [in] y two 8-bit values to be extracted and sign-extended. |
| \return the addition of val1 and val2, where the 8-bit values in val2[7:0] and |
| val2[23:16] have been extracted and sign-extended prior to the addition. |
| \remark |
| res[15:0] = val1[15:0] + SignExtended(val2[7:0]) \n |
| res[31:16] = val1[31:16] + SignExtended(val2[23:16]) |
| */ |
| __ALWAYS_INLINE uint32_t __SXTAB16(uint32_t x, uint32_t y) |
| { |
| return ((uint32_t)((((((int32_t)y << 24) >> 24) + (((int32_t)x << 16) >> 16)) & (int32_t)0x0000FFFF) | |
| (((((int32_t)y << 8) >> 8) + (((int32_t)x >> 16) << 16)) & (int32_t)0xFFFF0000))); |
| } |
| |
| /** |
| \brief Extracted 16-bit to 32-bit unsigned addition. |
| \details This function enables you to extract two 8-bit values from one operand, zero-extend |
| them to 16 bits each, and add the results to two 16-bit values from another operand. |
| \param [in] x values added to the zero-extended to 16-bit values. |
| \param [in] y two 8-bit values to be extracted and zero-extended. |
| \return the addition of val1 and val2, where the 8-bit values in val2[7:0] and |
| val2[23:16] have been extracted and zero-extended prior to the addition. |
| \remark |
| res[15:0] = ZeroExt(val2[7:0] to 16 bits) + val1[15:0] \n |
| res[31:16] = ZeroExt(val2[31:16] to 16 bits) + val1[31:16] |
| */ |
| __ALWAYS_INLINE uint32_t __UXTAB16(uint32_t x, uint32_t y) |
| { |
| return ((uint32_t)(((((y << 24) >> 24) + ((x << 16) >> 16)) & 0x0000FFFF) | |
| ((((y << 8) >> 8) + ((x >> 16) << 16)) & 0xFFFF0000))); |
| } |
| |
| /** |
| \brief Dual extract 8-bits and sign extend each to 16-bits. |
| \details This function enables you to extract two 8-bit values from an operand and sign-extend them to 16 bits each. |
| \param [in] x two 8-bit values in val[7:0] and val[23:16] to be sign-extended. |
| \return the 8-bit values sign-extended to 16-bit values.\n |
| sign-extended value of val[7:0] in the low halfword of the return value.\n |
| sign-extended value of val[23:16] in the high halfword of the return value. |
| \remark |
| res[15:0] = SignExtended(val[7:0]) \n |
| res[31:16] = SignExtended(val[23:16]) |
| */ |
| __ALWAYS_INLINE uint32_t __SXTB16(uint32_t x) |
| { |
| return ((uint32_t)(((((int32_t)x << 24) >> 24) & (int32_t)0x0000FFFF) | |
| ((((int32_t)x << 8) >> 8) & (int32_t)0xFFFF0000))); |
| } |
| |
| /** |
| \brief Dual extract 8-bits and zero-extend to 16-bits. |
| \details This function enables you to extract two 8-bit values from an operand and zero-extend them to 16 bits each. |
| \param [in] x two 8-bit values in val[7:0] and val[23:16] to be zero-extended. |
| \return the 8-bit values sign-extended to 16-bit values.\n |
| sign-extended value of val[7:0] in the low halfword of the return value.\n |
| sign-extended value of val[23:16] in the high halfword of the return value. |
| \remark |
| res[15:0] = SignExtended(val[7:0]) \n |
| res[31:16] = SignExtended(val[23:16]) |
| */ |
| __ALWAYS_INLINE uint32_t __UXTB16(uint32_t x) |
| { |
| return ((uint32_t)((((x << 24) >> 24) & 0x0000FFFF) | |
| (((x << 8) >> 8) & 0xFFFF0000))); |
| } |
| |
| #endif /* _CSI_SIMD_H_ */ |