public class DataTypeChangeHelper
{
    /**
     * 将一个单字节的byte转换成32位的int
     *
     * @param b byte
     * @return convert result
     */
    public static int unsignedByteToInt(byte b)
    {
        return (int) b & 0xFF;
    }

    /**
     * 将一个单字节的Byte转换成十六进制的数
     *
     * @param b byte
     * @return convert result
     */
    public static String byteToHex(byte b)
    {
        int i = b & 0xFF;
        return Integer.toHexString(i);
    }

    /**
     * 将一个4byte的数组转换成32位的int
     *
     * @param buf bytes buffer
     * @param pos byte[]中开始转换的位置
     * @return convert result
     */
    public static long unsigned4BytesToInt(byte[] buf, int pos)
    {
        int firstByte = 0;
        int secondByte = 0;
        int thirdByte = 0;
        int fourthByte = 0;
        int index = pos;
        firstByte = (0x000000FF & ((int) buf[index]));
        secondByte = (0x000000FF & ((int) buf[index + 1]));
        thirdByte = (0x000000FF & ((int) buf[index + 2]));
        fourthByte = (0x000000FF & ((int) buf[index + 3]));
        index = index + 4;
        return ((long) (firstByte << 24 | secondByte << 16 | thirdByte << 8 | fourthByte)) & 0xFFFFFFFFL;
    }

    /**
     * 将16位的short转换成byte数组
     *
     * @param s short
     * @return byte[] 长度为2
     */
    public static byte[] shortToByteArray(short s)
    {
        byte[] targets = new byte[2];
        for (int i = 0; i < 2; i++)
        {
            int offset = (targets.length - 1 - i) * 8;
            targets[i] = (byte) ((s >>> offset) & 0xff);
        }
        return targets;
    }

    /**
     * 将32位整数转换成长度为4的byte数组
     *
     * @param s int
     * @return byte[]
     */
    public static byte[] intToByteArray(int s)
    {
        byte[] targets = new byte[2];
        for (int i = 0; i < 4; i++)
        {
            int offset = (targets.length - 1 - i) * 8;
            targets[i] = (byte) ((s >>> offset) & 0xff);
        }
        return targets;
    }

    /**
     * long to byte[]
     *
     * @param s long
     * @return byte[]
     */
    public static byte[] longToByteArray(long s)
    {
        byte[] targets = new byte[2];
        for (int i = 0; i < 8; i++)
        {
            int offset = (targets.length - 1 - i) * 8;
            targets[i] = (byte) ((s >>> offset) & 0xff);
        }
        return targets;
    }

    /**
     * 32位int转byte[]
     */
    public static byte[] int2byte(int res)
    {
        byte[] targets = new byte[4];
        targets[0] = (byte) (res & 0xff);// 最低位
        targets[1] = (byte) ((res >> 8) & 0xff);// 次低位
        targets[2] = (byte) ((res >> 16) & 0xff);// 次高位
        targets[3] = (byte) (res >>> 24);// 最高位,无符号右移。
        return targets;
    }

    /**
     * 将长度为2的byte数组转换为16位int
     *
     * @param res byte[]
     * @return int
     */
    public static int byte2int(byte[] res)
    {
        // res = InversionByte(res);
        // 一个byte数据左移24位变成0x??000000，再右移8位变成0x00??0000
        int targets = (res[0] & 0xff) | ((res[1] << 8) & 0xff00); // | 表示安位或
        return targets;
    }

    /**
     * byte数组转short数组   小端储存
     *
     * @param src
     * @return
     */
    public static short[] byteArrayToShortArray(byte[] src)
    {
        int count = src.length >> 1;
        short[] dest = new short[count];
        for (int i = 0; i < count; i++)
        {
            dest[i] = (short) ((src[2 * i + 1] << 8) | (src[2 * i] & 0xff));
        }
        return dest;
    }

    /**
     * short数组转byte数组  小端储存
     *
     * @param src
     * @return
     */
    public static byte[] shortArrayToByteArray(short[] src)
    {

        int count = src.length;
        byte[] dest = new byte[count*2];
        for (int i = 0; i < count; i++)
        {
            dest[i * 2] = (byte) (src[i] & 0xff);
            dest[i * 2 + 1] = (byte) (src[i] >> 8 & 0xff);
        }

        return dest;
    }

    /**
     * short数组转byte数组  小端储存
     *
     * @param src
     * @return
     */
    public static int shortArrayToByteArray(short[] src, byte[] outarry)
    {
        byte[] dest = outarry;
        int count = outarry.length / 2 <= src.length ? outarry.length / 2 : src.length;
        for (int i = 0; i < count; i++)
        {
            dest[i * 2] = (byte) (src[i] & 0xff);
            dest[i * 2 + 1] = (byte) (src[i] >> 8 & 0xff);
        }
        return count * 2;
    }

    /**
     * convert double signals to 16-bit pcm
     *
     * @param d          double signals
     * @param s          16-bit pcm
     * @param numsamples no. of samples to be converted
     */
    public static void double2Short(double[] d, short[] s, int numsamples)
    {
        for (int i = 0; i < numsamples; i++) s[i] = double2Short(d[i]);
    }

    /**
     * convert a double signal sample to 16 bits pcm sample
     *
     * @param d a double sample
     * @return
     */
    public static short double2Short(double d)
    {
        if (d > 1.0)
        {
            d = 1.0;
        }
        else if (d < -1.0)
        {
            d = -1.0;
        }

        return (short) (d * Short.MAX_VALUE);
    }

    /**
     * convert a yuan-byte short sample to double sample
     *
     * @param s 16 bits pcm sample
     * @return
     */
    public static double short2Double(short s)
    {
        return (double) s / Short.MAX_VALUE;
    }

    /**
     * convert yuan-byte short samples to double samples
     *
     * @param s          16-bit samples
     * @param d          double samples
     * @param numsamples no. of samples to be converted
     */
    public static void short2Double(short[] s, double[] d, int numsamples)
    {
        for (int i = 0; i < numsamples; i++) d[i] = short2Double(s[i]);
    }

    /**
     * convert a yuan-byte short sample to float sample
     *
     * @param s 16 bits pcm sample
     * @return
     */
    public static float short2Float(short s)
    {
        return (float) s / Short.MAX_VALUE;
    }

    /**
     * convert 16-bit pcm to float
     *
     * @param s          16-bit pcm data
     * @param f          float data
     * @param numsamples no. of samples to be converted
     */
    public static void short2Float(short[] s, float[] f, int numsamples)
    {
        for (int i = 0; i < numsamples; i++) f[i] = short2Float(s[i]);
    }

    /**
     * convert a float signal sample to 16 bits pcm sample
     *
     * @param f a float sample
     * @return
     */
    public static short float2Short(float f)
    {
        if (f > 1.0)
        {
            f = 1.0f;
        }
        else if (f < -1.0)
        {
            f = -1.0f;
        }

        return (short) (f * Short.MAX_VALUE);
    }

    /**
     * convert float signal to 16-bit pcm
     *
     * @param f          float signal
     * @param s          16-bit pcm
     * @param numsamples no. of samples to be converted
     */
    public static void float2Short(float[] f, short[] s, int numsamples)
    {
        for (int i = 0; i < numsamples; i++) s[i] = float2Short(f[i]);
    }

    /**
     * convert 24-bit pcm signal to souble samples
     *
     * @param orgBuffer
     * 24-bit pcm samples
     * @param outBuffer
     * double samples
     */
    private static boolean isPerGain = false;

    public static void byteArray24_2_doubleArray(byte[] orgBuffer, double[] outBuffer)
    {
        int len = orgBuffer.length / 3 < outBuffer.length ? orgBuffer.length / 3 : outBuffer.length;
        int i0, i1, i2;
        double f;
        int a;
        for (int i = 0; i < len; i++)
        {
            i0 = (int) orgBuffer[3 * i + 0] & 0x000000ff;
            i1 = (int) orgBuffer[3 * i + 1] & 0x000000ff;
            i2 = (int) orgBuffer[3 * i + 2] & 0x000000ff;
            //negative value, pad with 0xff
            if ((i2 & 0x00000080) != 0)
            {
                i2 |= 0xffffff00;
            }
            i0 |= i2 << 16 | i1 << 8;
            /**
             * test
             */
            if (isPerGain)
            {
                a = i % 8;
                if (a >= 4)
                {
                    i0 = i0 << 6;
                }
//            else
//                i0 = 0;
            }

            f = (float) i0 / 16777216;
            if (f < -1.0)
            {
                f = -1.0;
            }
            else if (f > 1.0)
            {
                f = 1.0;
            }

            outBuffer[i] = f;
        }
    }

    public static void byteArray24_2_doubleArray_withPerGain(byte[] orgBuffer, double[] outBuffer)
    {
        isPerGain = true;
        byteArray24_2_doubleArray(orgBuffer, outBuffer);
        isPerGain = false;
    }

    /**
     * convert 32-bit pcm signal to double samples
     *
     * @param orgBuffer 32-bit pcm samples
     * @param outBuffer double samples
     */
    public static void byteArray32_2_doubleArray(byte[] orgBuffer, double[] outBuffer)
    {
        int len = orgBuffer.length / 4 > outBuffer.length ? outBuffer.length : orgBuffer.length / 4;
        int i0, i1, i2, i3;
        double f;
        for (int i = 0; i < len; i++)
        {
            /*
             * merge to int
             */
            i0 = (int) orgBuffer[i * 4 + 0] & 0x000000ff;
            i1 = (int) orgBuffer[i * 4 + 1] & 0x000000ff;
            i2 = (int) orgBuffer[i * 4 + 2] & 0x000000ff;
            i3 = (int) orgBuffer[i * 4 + 3] & 0x000000ff;
            //negative value, pad with 0xff
            if ((i3 & 0x00000080) != 0)
            {
                i3 |= 0xffffff00;
            }
            i0 |= i3 << 24 | i2 << 16 | i1 << 8;

            /*
             * convert to double
             */
            f = (float) i0 / Integer.MAX_VALUE;
            if (f < -1.0)
            {
                f = -1.0;
            }
            else if (f > 1.0)
            {
                f = 1.0;
            }
            outBuffer[i] = f;
        }
    }
}