做过音频相关的应该见过这种Eq曲线，每一个点都有一个影响范围，并对整体曲线有影响。

图片为前半部分。之前做的时候在网上并没有找到，Eq曲线的计算和画法。这里拿出来分享一下。这里只提供画图的方法，曲线的算法不在这里提供（公司资产）。如有需要请私聊。（本人也是翻译mathlib获取的）

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.Point;
import android.graphics.RectF;
import android.util.AttributeSet;
import android.util.Log;
import android.util.TypedValue;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

import com.iszcc.x5audio.bean.CarAudioConfig;
import com.iszcc.x5audio.bean.param.base.EQ;
import com.iszcc.x5audio.bean.param.base.FILTER;
import com.iszcc.x5audio.constans.Constants;
import com.iszcc.x5audio.eqcalc.CalcEqueal;
import com.iszcc.x5audio.eqcalc.EqParam;
import com.iszcc.x5audio.uitl.DataUtil;

import java.math.BigDecimal;
import java.util.ArrayList;

import static com.iszcc.x5audio.constans.Constants.EQ_freq;
import static com.iszcc.x5audio.constans.Constants.pointColor;

/**
 * Created by DB on 2017/6/9.
 */

public class EQSurfaceView extends SurfaceView implements SurfaceHolder.Callback, Runnable {
    private static final String TAG = "SurfaceView";
    //SurfaceHolder
    private SurfaceHolder mHolder;

    private byte passByte = 0;

    //用于绘图的Canvas
    private Canvas canvas;
    //子线程标志位
    private boolean mIsDrawing;
    private Context mContext;

    private Paint paintXy;//xy轴画笔

    private Paint paintText;//文字画笔

    private Paint mWrapPaint;//曲线笔

    private Paint mPaintPoint;//

    private Paint mPaintCurve;//主曲线笔

    private Paint mPaintPass;// 显示EQ旁路的画笔


    // 坐标轴上描述性文字的空间大小
    private int mTopUnitHeight;// 顶部Y轴单位高度
    private int mBottomTextHeight;//X轴底部字体的高度
    private int mLeftTextWidth;
    // 网格尺寸
    private int mGridWidth, mGridHeight;

    private int yHeight, xWeith;//x y 轴的长度

    private ArrayList<Point> pointsList = new ArrayList<>();//点的集合
    private Point hPFPoint = new Point();//高通点
    private Point lPFPoint = new Point();//低通点


    private boolean isDrawWrap = false;//是否画阴影的曲线

    private boolean isDrawHLPF = false;//高低通

    private CalcEqueal calcEqueal = CalcEqueal.getInstance();

    //频响曲线
    private double[] freqX = new double[1024];
    private double[] freqY = new double[1024];

    //x y 轴坐标值
    private String[] xLineStr = new String[]{"-24dB", "-18dB", "-12dB", "-6dB", "0dB", "6dB", "12dB"};
    private String[] yLineStr = new String[]{"20HZ", "50HZ", "100HZ", "200HZ", "500HZ", "1kHZ", "2kHZ", "5kHZ", "10kHZ", "20kHZ"};
    //x轴什么所有线对应的频率值，对这些数取对数，在比上宽度值就是x坐标。
    private float[] yLin = new float[]{
            10,
            20.0f, 30.0f, 40.0f,
            50.0f, 60.0f, 70.0f, 80.0f, 90.0f,
            100.0f,
            200.0f, 300.0f, 400.0f,
            500.0f, 600.0f, 700.0f, 800.0f, 900.0f,
            1000.0f,
            2000.0f, 3000.0f, 4000.0f,
            5000.0f, 6000.0f, 7000.0f, 8000.0f, 9000.0f,
            10000.0f,
            20000.0f, 24000.0f};

    public EQSurfaceView(Context context) {
        super(context);
        mContext = context;
        initView();
    }


    public EQSurfaceView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mContext = context;
        initView();
    }

    public EQSurfaceView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mContext = context;
        initView();
    }

    private void initView() {
        mHolder = getHolder();
        //添加回调
        mHolder.addCallback(this);

        {
            mBottomTextHeight = dp2px(20);// X轴底部字体的高度
            mLeftTextWidth = mBottomTextHeight;// Y轴左边字体的宽度
            mTopUnitHeight = dp2px(20);// 顶部Y轴的单位

            // 初始化坐标轴Paint
            paintXy = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
            paintXy.setStrokeWidth(dp2px(1));
            paintXy.setColor(Color.parseColor("#71737171"));
            // 初始化文本Paint
            paintText = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
            paintText.setColor(Color.GRAY);
            paintText.setTextSize(sp2px(8));

            //Eq 旁路的画笔

            mPaintPass = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
            mPaintPass.setColor(Color.GRAY);
            mPaintPass.setTextSize(sp2px(40));

            // 初始化曲线Paint
            mWrapPaint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
            // mWrapPaint.setPathEffect(new CornerPathEffect(50f));//设置转角度数

            //初始化主曲线笔
            mPaintCurve = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);

            //画点
            mPaintPoint = new Paint(Paint.ANTI_ALIAS_FLAG | Paint.DITHER_FLAG);
            mPaintPoint.setColor(Color.RED);
            mPaintPoint.setStrokeWidth(dp2px(2));
            mPaintPoint.setStyle(Paint.Style.FILL);

        }

        setFocusable(true);
        setFocusableInTouchMode(true);
        this.setKeepScreenOn(true);
    }

    //Surface的生命周期
    @Override
    public void surfaceCreated(SurfaceHolder holder) {

        mIsDrawing = true;
        new Thread(this).start();
        isFristDraw = true;
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {


    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        mIsDrawing = false;

    }

    private boolean isFristDraw = false;

    @Override
    public void run() {
        while (mIsDrawing) {
            draw();
            //通过线程休眠以控制刷新速度
            try {
                Thread.sleep(50);
                if (isFristDraw) {

                    CarAudioConfig carAudioConfig = CarAudioConfig.getInstance();
                    byte eqPass = (byte) ((carAudioConfig.getMusic().getMusicL_EQSel().getValue() & 0x80) >> 7);
                    calcEq(carAudioConfig.getMusic().getMusicL_EQ_Show(),
                            carAudioConfig.getMusic().getMusicL_HPF(),
                            carAudioConfig.getMusic().getMusicL_LPF(), eqPass);
                    isFristDraw = false;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void draw() {
        try {
            //锁定画布并返回画布对象
            canvas = mHolder.lockCanvas();
            //接下去就是在画布上进行一下draw
            if (canvas != null) {
                canvas.drawRGB(0, 0, 0);//设置画布为黑色

                drawLineXY(canvas);//绘制xy

                drawWrap(canvas);//绘制阴影曲线

                drawPoint(canvas);//绘制点

                drawFrequencyCurve(canvas);

                drawEqPass(canvas);

            }

        } catch (Exception e) {
            mIsDrawing = false;
        } finally {
            //当画布内容不为空时，才post，避免出现黑屏的情况。
            if (canvas != null) {
                mHolder.unlockCanvasAndPost(canvas);
            }
        }
    }

    private String passText = "EQ BYPASS";

    /**
     * Eq 旁路
     *
     * @param canvas
     */
    private void drawEqPass(Canvas canvas) {
        if (passByte == 0) {
            return;
        }
        float textWieth = mPaintPass.measureText(passText);

        canvas.drawText(passText, getWidth() / 2 - textWieth / 2, getHeight() / 2 + dp2px(40) / 2, mPaintPass);
    }

    /**
     * 绘制点
     *
     * @param canvas
     */
    private void drawPoint(Canvas canvas) {

        for (int i = 0; i < pointsList.size(); i++) {
            mPaintPoint.setColor(pointColor[i]);
            canvas.drawCircle(pointsList.get(i).x, pointsList.get(i).y, dp2px(2), mPaintPoint);
        }

        //高通
        mPaintPoint.setColor(Color.YELLOW);
        canvas.drawCircle(hPFPoint.x, hPFPoint.y, dp2px(2), mPaintPoint);
        //低通
        mPaintPoint.setColor(Color.RED);
        canvas.drawCircle(lPFPoint.x, lPFPoint.y, dp2px(2), mPaintPoint);


    }

    /**
     * 绘制阴影部分曲线
     */
    private void drawWrap(Canvas canvas) {

        canvas.clipRect(new RectF(
                getPaddingLeft() + mLeftTextWidth,
                0,
                getRight() - getPaddingRight(),
                getHeight() - getPaddingBottom() - mBottomTextHeight)
        );
        if (!isDrawWrap) {
            return;
        }

        if (!isDrawHLPF) {
            //eq划线
            Path path = new Path();
            path.moveTo((float) eqX[0], (float) calcPointY(0));

            for (int index = 0; index < eqX.length; index++) {
                path.lineTo((float) eqX[index], (float) eqY[index]);
            }

            mWrapPaint.setStyle(Paint.Style.FILL);
            path.lineTo(getRight() - getPaddingRight(), (float) calcPointY(0));
            path.close();

            mWrapPaint.setColor(Color.parseColor("#71c2bbbb"));
            canvas.drawPath(path, mWrapPaint);

        } else {
            //高低通划线

            Path path = new Path();
            path.moveTo((float) eqX[0], (float) calcPointY(-24));

            for (int index = 0; index < eqX.length; index++) {
                path.lineTo((float) eqX[index], (float) eqY[index]);
            }

            mWrapPaint.setStyle(Paint.Style.FILL);
            path.lineTo((float) eqX[eqX.length - 1], (float) calcPointY(-24));
            path.close();

            mWrapPaint.setColor(Color.parseColor("#71c2bbbb"));
            canvas.drawPath(path, mWrapPaint);


        }

        // isDrawWrap = false;

    }

    /**
     * 绘制主曲线
     *
     * @param canvas
     */
    private void drawFrequencyCurve(Canvas canvas) {

        Path path = new Path();
        path.moveTo((float) freqX[0], (float) freqY[0]);

        for (int index = 1; index < freqX.length; index++) {
            path.lineTo((float) freqX[index], (float) freqY[index]);
        }

        //  path.lineTo(getRight() - getPaddingRight(), (float) calcPointY(0));
        // path.close(); 曲线闭合

        mPaintCurve.setColor(Color.GREEN);
        mPaintCurve.setStrokeWidth(dp2px(1.0f));
        mPaintCurve.setStyle(Paint.Style.STROKE);

        canvas.drawPath(path, mPaintCurve);

    }

    /**
     * 绘制 X Y 坐标系
     */
    private void drawLineXY(Canvas canvas) {

        Point start = new Point();
        Point stop = new Point();

        int xLineCount = xLineStr.length;


        yHeight = getHeight() - getPaddingTop() - getPaddingBottom() - mBottomTextHeight - mTopUnitHeight;//y轴高度
        mGridHeight = yHeight / (xLineCount - 1);

        for (int i = 0; i < xLineCount; i++) {
            start.x = getPaddingLeft() + mLeftTextWidth;
            start.y = getHeight() - getPaddingBottom() - mBottomTextHeight - mGridHeight * i;
            stop.x = getRight() - getPaddingRight();
            stop.y = start.y;
            // 绘制横轴线
            canvas.drawLine(start.x, start.y, stop.x, stop.y, paintXy);


            // 绘制纵坐标单位
            String drawText = xLineStr[i];
            Paint.FontMetricsInt fontMetrics = paintText.getFontMetricsInt();
            float offsetY = ((fontMetrics.bottom - fontMetrics.top) / 2 + fontMetrics.bottom) / 2;
            float baseLine = start.y + offsetY;
            float left = getPaddingLeft() + mLeftTextWidth / 2 - paintText.measureText(drawText) / 2;
            canvas.drawText(drawText, left, baseLine, paintText);

            if (i != xLineCount - 1) {

                start.x = getPaddingLeft() + mLeftTextWidth;
                start.y = getHeight() - getPaddingBottom() - mBottomTextHeight - mGridHeight * i - mGridHeight / 2;
                stop.x = getRight() - getPaddingRight();
                stop.y = start.y;
                // 绘制横轴线
                canvas.drawLine(start.x, start.y, stop.x, stop.y, paintXy);
            }

        }

        // 2. 绘制纵轴线和横坐标单位
       /* int yLineCount = yLineStr.length;
        mGridWidth = (getWidth() - getPaddingLeft() - getPaddingRight() - mLeftTextWidth) / (yLineCount - 1);*/

        xWeith = getWidth() - getPaddingLeft() - getPaddingRight() - mLeftTextWidth;

        double[] yJuli = calcYlin(xWeith);//计算y坐标的位置
        int textInt = 0;
        for (int i = 0; i < yJuli.length; i++) {
            start.x = (int) (getPaddingLeft() + mLeftTextWidth + yJuli[i]);
            start.y = getPaddingTop() + mTopUnitHeight;
            stop.x = start.x;
            stop.y = getHeight() - mBottomTextHeight - getPaddingBottom();
            // 绘制纵轴线
            canvas.drawLine(start.x, start.y, stop.x, stop.y, paintXy);

            // 绘制横坐标单位

            if (i == 1 || i == 4 || i == 9 || i == 10 || i == 13 || i == 18 || i == 19 || i == 22 || i == 27 || i == 28) {
                String drawText = yLineStr[textInt];
                Paint.FontMetricsInt fontMetrics = paintText.getFontMetricsInt();
                float offsetY = ((fontMetrics.bottom - fontMetrics.top) / 2 + fontMetrics.bottom) / 2;
                float baseLine = getHeight() - getPaddingBottom() - mBottomTextHeight / 2 + offsetY;
                float left = start.x - paintText.measureText(drawText) / 2;

                canvas.drawText(drawText, left, baseLine, paintText);
                textInt++;
            }
        }


    }

    /**
     * 将增益和频率转化为坐标上的点
     *
     * @param gain 增益
     * @param freq 频率
     * @return
     */
    private Point calcPoint(float gain, float freq) {

        return new Point((int) calcPointX(freq), (int) calcPointY(gain));
    }


    /**
     * 将y坐标点转化为增益
     *
     * @param y
     * @return
     */
    private float calcYToGain(int y) {

        float hBili = ((getHeight() - getPaddingBottom() - mBottomTextHeight) - y) / (float) yHeight;//高度比例


        float T = 36 * hBili - 24;
        BigDecimal b = new BigDecimal(T);

        return b.setScale(1, BigDecimal.ROUND_HALF_UP).floatValue();

    }


    /**
     * 将y坐标转化为频率
     *
     * @param x
     * @return
     */
    private float calcXToFreq(int x) {

        double bili = (x - (getPaddingLeft() + mLeftTextWidth)) / (double) xWeith; //getWidth() - getPaddingLeft() - getPaddingRight() - mLeftTextWidth;

        Log.e("calcPoint:", "calcXToFreq :比例11 ：" + (x - (getPaddingLeft() + mLeftTextWidth)) + " 对数22：" + xWeith);

        //最大值和最小值取对数的的差值(对应x轴长度)
        double duiShuCha = logarithm(24000.0f, 10.0) - 1;// logarithm(10.0f, 10.0)=1

        double v = duiShuCha * bili + 1;

        Log.e("calcPoint:", "calcXToFreq :比例 ：" + bili + " 对数：" + v);

        float T = (float) Math.pow(10.0f, v);//求平方值

        //保留一位小数的返回值
        BigDecimal b = new BigDecimal(T);
        return b.setScale(1, BigDecimal.ROUND_HALF_UP).floatValue();
    }

    /**
     * 计算增益对应的y轴高度
     */
    private double calcPointY(double gain) {

        //y坐标高度


        return (getHeight() - getPaddingBottom() - mBottomTextHeight) - ((double) (gain - (-24)) / (double) 36) * yHeight;

    }

    /**
     * 计算增益对应的X轴高度
     */
    private double calcPointX(double freq) {
        //最大值和最小值取对数的的差值(对应x轴长度)
        double duiShuCha = logarithm(24000.0f, 10.0) - 1;// logarithm(10.0f, 10.0)=1

        return (double) ((getPaddingLeft() + mLeftTextWidth) + (((logarithm((double) freq, 10.0f) - 1) / duiShuCha) * xWeith));
    }

    /**
     * 计算y坐标的位置
     * <p>
     * y坐标为相应的值去对数，然后根据对数比例来确定坐标位置
     * weith x轴长度
     */
    private double[] calcYlin(int weith) {

        //最大值和最小值取对数的的差值(对应x轴长度)
        double duiShuCha = logarithm(24000.0f, 10.0) - 1;// logarithm(10.0f, 10.0)=1

        double[] yJuli = new double[yLin.length];//保存各个点到原点的距离
        for (int i = 0; i < yLin.length; i++) {
            //x轴上的值去对数 - 1 与最大最小对数差值比例 *  x轴长度
            yJuli[i] = ((logarithm(yLin[i], 10.0f) - 1) / duiShuCha) * weith;
        }
        return yJuli;

    }


    private double[] eqX = new double[1024];
    private double[] eqY = new double[1024];

    public void setEq(int eqItem, Constants.DRAW_EQ drawHLPF, EQ[] eqs, FILTER hPF, FILTER lPF, byte eqPass) {

        int selectItem = 0;


        if (drawHLPF == Constants.DRAW_EQ.PEQ) {
            selectItem = eqItem;//选中为具体的eq段
        } else if (drawHLPF == Constants.DRAW_EQ.HPF) {
            selectItem = eqs.length;//选中为高通
        } else if (drawHLPF == Constants.DRAW_EQ.LPF) {
            selectItem = eqs.length + 1;//选中为低通
        }

        //传递selectItem的作用就是在计算eq曲线的时候，初始化全部的eq段和高低通全部要计算一遍，
        // 传递selectItem就是接下来只计算调节之后的那一段曲线，其他复用之前的，减少计算量。
        EqParam[] eqParams = initEq(eqs, hPF, lPF, selectItem);


        eqX = freqX;

        if (drawHLPF == Constants.DRAW_EQ.PEQ) {
            isDrawHLPF = false;

            isDrawWrap = true;

            for (int i = 0; i < eqY.length; i++) {
                eqY[i] = calcPointY(eqParams[eqItem].getPts()[i]);
            }

        } else if (drawHLPF == Constants.DRAW_EQ.HPF) {
            if (calcHLPFFreq(hPF) == 0) {//如果频率为0，不显示阴影
                isDrawWrap = false;
            } else {
                isDrawWrap = true;
            }
            isDrawHLPF = true;


            for (int i = 0; i < eqY.length; i++) {
                eqY[i] = calcPointY(eqParams[eqs.length].getPts()[i]);
            }

        } else if (drawHLPF == Constants.DRAW_EQ.LPF) {
            if (calcHLPFFreq(lPF) == 0) {
                isDrawWrap = false;
            } else {
                isDrawWrap = true;
            }
            isDrawHLPF = true;
            for (int i = 0; i < eqY.length; i++) {
                eqY[i] = calcPointY(eqParams[eqs.length + 1].getPts()[i]);
            }
        }

        //   invalidate();
    }

    public void setEqEffect(int eqItem, Constants.DRAW_EQ drawHLPF, EQ[] eqs, int hPF, int lPF, byte eqPass) {

        int selectItem = 0;


        if (drawHLPF == Constants.DRAW_EQ.PEQ) {
            selectItem = eqItem;//选中为具体的eq段
        } else if (drawHLPF == Constants.DRAW_EQ.HPF) {
            selectItem = eqs.length;//选中为高通
        } else if (drawHLPF == Constants.DRAW_EQ.LPF) {
            selectItem = eqs.length + 1;//选中为低通
        }

        //传递selectItem的作用就是在计算eq曲线的时候，初始化全部的eq段和高低通全部要计算一遍，传递selectItem就是接下来只计算调节之后的那一段曲线，其他复用之前的，减少计算量。
        EqParam[] eqParams = initEqEffect(eqs, hPF, lPF, selectItem);


        eqX = freqX;

        if (drawHLPF == Constants.DRAW_EQ.PEQ) {
            isDrawHLPF = false;

            isDrawWrap = true;

            for (int i = 0; i < eqY.length; i++) {
                eqY[i] = calcPointY(eqParams[eqItem].getPts()[i]);
            }

        } else if (drawHLPF == Constants.DRAW_EQ.HPF) {
            if (Constants.LHFP_freq[hPF] == 0) {//如果频率为0，不显示阴影
                isDrawWrap = false;
            } else {
                isDrawWrap = true;
            }
            isDrawHLPF = true;


            for (int i = 0; i < eqY.length; i++) {
                eqY[i] = calcPointY(eqParams[eqs.length].getPts()[i]);
            }

        } else if (drawHLPF == Constants.DRAW_EQ.LPF) {
            if (Constants.LFP_freq[lPF] == 0) {
                isDrawWrap = false;
            } else {
                isDrawWrap = true;
            }
            isDrawHLPF = true;
            for (int i = 0; i < eqY.length; i++) {
                eqY[i] = calcPointY(eqParams[eqs.length + 1].getPts()[i]);
            }
        }

        //   invalidate();
    }


    public void calcEq(EQ[] eqs, FILTER hPF, FILTER lPF, byte eqPass) {
        this.passByte = eqPass;

        initEq(eqs, hPF, lPF, -1);
        isDrawWrap = false;
        //   invalidate();

    }

    public void calcEqEffect(EQ[] eqs, int hPF, int lPF, byte eqPass) {

        initEqEffect(eqs, hPF, lPF, -1);
        isDrawWrap = false;
        //   invalidate();

    }


    public EqParam[] initEq(EQ[] eqs, FILTER hPF, FILTER lPF, int eqItem) {


        //高低通
        float lhPFGain = -15;//高低通位置放在-14的增益位置

        //高通
        float hPFFreq = calcHLPFFreq(hPF);
        hPFPoint = calcPoint(lhPFGain, hPFFreq);

        //低通
        float lPFFreq = calcHLPFFreq(lPF);
        lPFPoint = calcPoint(lhPFGain, lPFFreq);

        EqParam[] eqParams = drawEq(eqs, eqItem,
                hPF.getFilter_Type().getValueInt(), hPFFreq, (Constants.EQ_q[hPF.getFilter_Q().getValueInt()]),
                lPF.getFilter_Type().getValueInt(), lPFFreq, (Constants.EQ_q[lPF.getFilter_Q().getValueInt()]));


        return eqParams;
    }


    /**
     * 效果部分的高低通只有频率，没有q值和类型等参数所以不能传递FILTER
     *
     * @param eqs
     * @param hPF
     * @param lPF
     */
    public EqParam[] initEqEffect(EQ[] eqs, int hPF, int lPF, int eqItem) {


        //高低通
        float lhPFGain = -15;//高低通位置放在-15的增益位置

        //高通
        double hPFFreq = Constants.LHFP_freq[hPF];

        hPFPoint = calcPoint(lhPFGain, (float) hPFFreq);

        //低通
        double lPFFreq = Constants.LFP_freq[lPF];

        lPFPoint = calcPoint(lhPFGain, (float) lPFFreq);

        EqParam[] eqParams = drawEq(eqs, eqItem,
                3, hPFFreq, (Constants.EQ_q[9]),
                3, lPFFreq, (Constants.EQ_q[9]));

        return eqParams;
    }


    /**
     * 显示eq曲线的公共方法
     *
     * @param eqs     eq
     * @param hType   高通类型
     * @param hPFFreq 高通频率
     * @param hQ      高通q值
     * @param lType   低通类型
     * @param lPFFreq 低通频率
     * @param lQ      低通q值
     */
    private EqParam[] drawEq(EQ[] eqs, int eqItem, int hType, double hPFFreq, double hQ, int lType, double lPFFreq, double lQ) {
        pointsList.clear();
        for (int i = 0; i < eqs.length; i++) {
            int gain = DataUtil.pinJie2ByteToInt(eqs[i].getEQ_Gain().getValue()[1], eqs[i].getEQ_Gain().getValue()[0]);
            int freq = DataUtil.pinJie2ByteToInt(eqs[i].getEQ_Freq().getValue()[1], eqs[i].getEQ_Freq().getValue()[0]);


            Point point = calcPoint(gain / 10.0f - 24, (float) EQ_freq[freq]);

            pointsList.add(point);
        }

        //主曲线
        ArrayList<EqParam> eqParamList = new ArrayList<>();

        //添加峰值
        for (int i = 0; i < eqs.length; i++) {
            EqParam eqParam = new EqParam();

            //滤波器
            if (eqs[i].getEQ_Mode().getValueInt() == 0) {
                eqParam.setType(0);//类型
                eqParam.setFilter(Constants.ENUM_FILTER_TYPE.eParametric);
                eqParam.setQ(Constants.EQ_q[eqs[i].getEQ_PEQ_Q().getValueInt()]);
            } else if (eqs[i].getEQ_Mode().getValueInt() == 1) {
                eqParam.setType(1);//类型
                eqParam.setFilter(Constants.ENUM_FILTER_TYPE.eShelving);
                eqParam.setQ2(Constants.EQ_q[eqs[i].getEQ_HLSEQ_Q().getValueInt()]);
            } else if (eqs[i].getEQ_Mode().getValueInt() == 2) {
                eqParam.setType(2);//类型
                eqParam.setFilter(Constants.ENUM_FILTER_TYPE.eShelving);
                eqParam.setQ2(Constants.EQ_q[eqs[i].getEQ_HLSEQ_Q().getValueInt()]);
            }
            //频率
            int freq = DataUtil.pinJie2ByteToInt(eqs[i].getEQ_Freq().getValue()[1], eqs[i].getEQ_Freq().getValue()[0]);
            eqParam.setFreq(EQ_freq[freq]);
            //增益
            int gain = DataUtil.pinJie2ByteToInt(eqs[i].getEQ_Gain().getValue()[1], eqs[i].getEQ_Gain().getValue()[0]);
            eqParam.setGain(gain / 10.0f - 24);


            eqParamList.add(eqParam);
        }

        //高通
        EqParam eqParamH = new EqParam();
        eqParamH.setType(2);
        if (hType == 0) {
            eqParamH.setFilter(Constants.ENUM_FILTER_TYPE.eBessel);
            eqParamH.setGain(-24);
        } else if (hType == 1) {
            eqParamH.setFilter(Constants.ENUM_FILTER_TYPE.eButterWorth);
            eqParamH.setGain(-24);
        } else if (hType == 2) {
            eqParamH.setFilter(Constants.ENUM_FILTER_TYPE.eLinkWitz_Riley);
            eqParamH.setGain(-24);
        } else if (hType == 3) {
            eqParamH.setFilter(Constants.ENUM_FILTER_TYPE.eUserFilter);
            eqParamH.setGain(-12);
        } else if (hType == 4) {
            eqParamH.setFilter(Constants.ENUM_FILTER_TYPE.eUserFilter);
            eqParamH.setGain(-24);
        }

        eqParamH.setFreq(hPFFreq);
        eqParamH.setQ(hQ);

        //低通
        EqParam eqParamL = new EqParam();
        eqParamL.setType(1);
        if (lType == 0) {
            eqParamL.setFilter(Constants.ENUM_FILTER_TYPE.eBessel);
            eqParamL.setGain(-24);
        } else if (lType == 1) {
            eqParamL.setFilter(Constants.ENUM_FILTER_TYPE.eButterWorth);
            eqParamL.setGain(-24);
        } else if (lType == 2) {
            eqParamL.setFilter(Constants.ENUM_FILTER_TYPE.eLinkWitz_Riley);
            eqParamL.setGain(-24);
        } else if (lType == 3) {
            eqParamL.setFilter(Constants.ENUM_FILTER_TYPE.eUserFilter);
            eqParamL.setGain(-12);
        } else if (lType == 4) {
            eqParamL.setFilter(Constants.ENUM_FILTER_TYPE.eUserFilter);
            eqParamL.setGain(-24);
        }

        eqParamL.setFreq(lPFFreq);
        eqParamL.setQ(lQ);//EqDatebase.Qx100[lPF.getFilter_Q().getValueInt()

        eqParamList.add(eqParamH);
        eqParamList.add(eqParamL);

        //集合转数组
        EqParam[] eqParams = new EqParam[eqParamList.size()];
        eqParamList.toArray(eqParams);


        double[] doubles = calcEqueal.setCalcEqueal(eqs.length, eqParams, eqItem);

        freqCurve(doubles);


        return calcEqueal.getmEqParams();

    }


    /**
     * 主曲线
     *
     * @param freqs
     */
    private void freqCurve(double[] freqs) {

        double x = (double) xWeith / 1023.00;
        freqX[0] = (getPaddingLeft() + mLeftTextWidth);
        for (int i = 1; i < freqX.length; i++) {
            freqX[i] = freqX[i - 1] + x;
        }

        for (int i = 0; i < freqY.length; i++) {
            freqY[i] = calcPointY(freqs[i]);

        }
    }


    /**
     * 计算高低通频率
     *
     * @param filter
     * @return
     */
    private float calcHLPFFreq(FILTER filter) {

        int feqMulH = filter.getFilter_FeqMul().getValueInt();//倍数 0 x1, 1 x10 2 x100
        int beishuH = 1;
        if (feqMulH == 0) {
            beishuH = 1;
        } else if (feqMulH == 1) {
            beishuH = 10;
        } else if (feqMulH == 2) {
            beishuH = 100;
        }
        float hPFFreq = (float) (Constants.LHFP_freq[filter.getFilter_Freq().getValueInt()] * beishuH);

        return hPFFreq > 20600 ? 20600 : hPFFreq;
    }

    /**
     * 对数计算公式
     *
     * @return
     */
    private double logarithm(double value, double base) {
        return Math.log(value) / Math.log(base);
    }


    private int dp2px(float dp) {
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                dp, getResources().getDisplayMetrics());
    }

    private int sp2px(float sp) {
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
                sp, getResources().getDisplayMetrics());
    }


    public Canvas getCanvas() {
        return canvas;
    }

    public void setCanvas(Canvas canvas) {
        this.canvas = canvas;
    }
}