想要快速搭建直播平台，最快的办法就是使用成品直播源码直接搭建直播平台，而在搭建过程中，美颜功能是必不可少的。

如上图所示，直播平台中使用的美颜主要有四大功能，分别是贴纸、美颜、特效和哈哈镜：
1．贴纸是给人脸上添加一些面具等装饰效果，分为基础和高级大类
2．美颜是调整人脸的美白，磨皮，红润，大眼，瘦脸，瘦鼻，额头等形状位置，从而美化面部特征，以及添加多种滤镜
3．特效里面包括一些动态特效，例如各种抖动效果，以及添加水印的功能。
4．哈哈镜则是让人脸像哈哈镜一样进行各种夸张的变化，增加趣味性。这个功能是依托于人脸识别来实现的。

快速搭建直播平台，接入美颜功能的部分代码如下：

public class MhDataManager {

private static MhDataManager sInstance;
private MHBeautyManager mMhManager;
private MeiYanValueBean mInputValue; 
private MeiYanValueBean mUseValue; 
private MeiYanValueBean mMeiYanValue; 
private MeiYanValueBean mOneKeyValue; 
private IBeautyEffectListener mMeiYanChangedListener;
private String mStickerName;//贴纸
private int mSpeciallyName = MHSDK.SPECIAL_NONE;//特效
private int mFilterId = MHSDK.FILTER_NONE;//滤镜
private int mWaterBitmapRes;//水印图片
private int mWaterAlignEnum = MHSDK.WATER_NONE;//水印位置
private int mDistortionName = MHSDK.HAHA_NONE;//哈哈镜

private MhDataManager() {

}

public static MhDataManager getInstance() {
    if (sInstance == null) {
        synchronized (MhDataManager.class) {
            if (sInstance == null) {
                sInstance = new MhDataManager();
            }
        }
    }
    return sInstance;
}

public MhDataManager init() {
    mInputValue = new MeiYanValueBean();
    mUseValue = null;
    mMeiYanValue = null;
    mOneKeyValue = null;
    mStickerName = null;
    mSpeciallyName = MHSDK.SPECIAL_NONE;
    mFilterId = MHSDK.FILTER_NONE;
    mWaterBitmapRes = 0;
    mWaterAlignEnum = MHSDK.WATER_NONE;
    mDistortionName = MHSDK.HAHA_NONE;
    releaseBeautyManager();
    return this;
}

public void createBeautyManager() {
    if (mInputValue != null) {
        mInputValue.reset();
    } else {
        mInputValue = new MeiYanValueBean();
    }
    try {
        mMhManager = new MHBeautyManager(CommonAppContext.getInstance());
    } catch (Exception e) {
        mMhManager = null;
        e.printStackTrace();
    }
}

public void setMeiYanChangedListener(IBeautyEffectListener meiYanChangedListener) {
    mMeiYanChangedListener = meiYanChangedListener;
}

public void release() {
    mMeiYanChangedListener = null;
    mInputValue = null;
    mUseValue = null;
    mMeiYanValue = null;
    mOneKeyValue = null;
    mStickerName = null;
    mSpeciallyName = MHSDK.SPECIAL_NONE;
    mFilterId = MHSDK.FILTER_NONE;
    mWaterBitmapRes = 0;
    mWaterAlignEnum = MHSDK.WATER_NONE;
    mDistortionName = MHSDK.HAHA_NONE;
    releaseBeautyManager();
}

public void releaseBeautyManager() {
    if (mMhManager != null) {
        try {
            mMhManager.destroy();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    mMhManager = null;
}


public int render(int texture, int width, int height) {
    if (mMhManager != null) {
        try {
            //    mMhSDKManager.setAsync(true); 
            int faceScale = 4; 
            int textureScale = 2; 
            int align = 128; 
            int newWidth = ((width * 4 + (align - 1)) & ~(align - 1)) / 4;
            int newHeight = ((height * 4 + (align - 1)) & ~(align - 1)) / 4;
            texture = mMhManager.render12(texture, newWidth, newHeight, faceScale, textureScale);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return texture;
}

public void restoreBeautyValue() {
    notifyMeiYanChanged();
    notifyLiangDuChanged();
    if (!TextUtils.isEmpty(mStickerName)) {
        setTieZhi(mStickerName);
    }
    if (mFilterId != MHSDK.FILTER_NONE) {
        if (isUseMhFilter() && mMhManager != null) {
            mMhManager.setFilter(mFilterId);
        }
    }
    if (mSpeciallyName != MHSDK.SPECIAL_NONE) {
        setTeXiao(mSpeciallyName);
    }
    if (mWaterBitmapRes != 0 && mWaterAlignEnum != MHSDK.WATER_NONE) {
        setWater(mWaterBitmapRes, mWaterAlignEnum);
    }
    if (mDistortionName != MHSDK.HAHA_NONE) {
        setHaHa(mDistortionName);
    }
}

public void saveBeautyValue() {
    if (mMeiYanValue != null) {
        CommonHttpUtil.setBeautyValue(JSON.toJSONString(mMeiYanValue));
    }
}

public MeiYanValueBean getMeiYanValue() {
    return mMeiYanValue;
}

public MeiYanValueBean getOneKeyValue() {
    return mOneKeyValue;
}

public MhDataManager setMeiYanValue(MeiYanValueBean meiYanValue) {
    mMeiYanValue = meiYanValue;
    return this;
}

public MhDataManager setOneKeyValue(MeiYanValueBean oneKeyValue) {
    mOneKeyValue = oneKeyValue;
    return this;
}


public MhDataManager useMeiYan() {
    mUseValue = mMeiYanValue;
    return this;
}

public MhDataManager useOneKey() {
    mUseValue = mOneKeyValue;
    return this;
}


public void setMeiBai(int meiBai) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setMeiBai(meiBai);
    }
    useMeiYan().notifyMeiYanChanged();
}


public void setMoPi(int moPi) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setMoPi(moPi);
    }
    useMeiYan().notifyMeiYanChanged();
}


public void setHongRun(int hongRun) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setHongRun(hongRun);
    }
    useMeiYan().notifyMeiYanChanged();
}


public void setLiangDu(int liangDu) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setLiangDu(liangDu);
    }
    useMeiYan().notifyLiangDuChanged();
}


public void setDaYan(int daYan) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setDaYan(daYan);
    }
    useMeiYan().notifyMeiYanChanged();
}


public void setMeiMao(int meiMao) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setMeiMao(meiMao);
    }
    useMeiYan().notifyMeiYanChanged();
}


public void setYanJu(int yanJu) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setYanJu(yanJu);
    }
    useMeiYan().notifyMeiYanChanged();
}

public void setYanJiao(int yanJiao) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setYanJiao(yanJiao);
    }
    useMeiYan().notifyMeiYanChanged();
}


public void setShouLian(int shouLian) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setShouLian(shouLian);
    }
    useMeiYan().notifyMeiYanChanged();
}


public void setZuiXing(int zuiXing) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setZuiXing(zuiXing);
    }
    useMeiYan().notifyMeiYanChanged();
}

public void setShouBi(int shouBi) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setShouBi(shouBi);
    }
    useMeiYan().notifyMeiYanChanged();
}

public void setXiaBa(int xiaBa) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setXiaBa(xiaBa);
    }
    useMeiYan().notifyMeiYanChanged();
}


public void setETou(int ETou) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setETou(ETou);
    }
    useMeiYan().notifyMeiYanChanged();
}


public void setChangBi(int changBi) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setChangBi(changBi);
    }
    useMeiYan().notifyMeiYanChanged();
}

public void setXueLian(int xueLian) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setXueLian(xueLian);
    }
    useMeiYan().notifyMeiYanChanged();
}

public void setKaiYanJiao(int kaiYanJiao) {
    if (mMeiYanValue != null) {
        mMeiYanValue.setKaiYanJiao(kaiYanJiao);
    }
    useMeiYan().notifyMeiYanChanged();
}


/**
 * 哈哈镜
 */
public void setHaHa(int hahaName) {
    mDistortionName = hahaName;
    if (mMhManager != null) {
        mMhManager.setDistortionEffect(hahaName);
    }
}

/**
 * 贴纸是否可用
 */
public boolean isTieZhiEnable() {
    return mMeiYanChangedListener == null || mMeiYanChangedListener.isTieZhiEnable();
}

/**
 * 贴纸
 */
public void setTieZhi(String tieZhiName) {
    mStickerName = tieZhiName;
    if (mMhManager != null) {
        mMhManager.setSticker(tieZhiName);
    }
}


/**
 * 水印
 */
public void setWater(int bitmapRes, int position) {
    mWaterBitmapRes = bitmapRes;
    mWaterAlignEnum = position;
    if (mMhManager != null) {
        Bitmap bitmap = null;
        if (bitmapRes == 0) {
            bitmap = Bitmap.createBitmap(1, 1, Bitmap.Config.ALPHA_8);
        } else {
            bitmap = BitmapFactory.decodeResource(CommonAppContext.getInstance().getResources(), bitmapRes);
        }
        mMhManager.setWaterMark(bitmap, position);
    }
}


/**
 * 特效
 */
public void setTeXiao(int teXiaoId) {
    mSpeciallyName = teXiaoId;
    if (mMhManager != null) {
        mMhManager.setSpeciallyEffect(teXiaoId);
    }
}

/**
 * 是否使用用美狐的滤镜 true使用美狐滤镜，false不使用
 */
public boolean isUseMhFilter() {
    return mMeiYanChangedListener == null || mMeiYanChangedListener.isUseMhFilter();
}


/**
 * 滤镜
 */
public void setFilter(MeiYanFilterBean bean) {
    if (isUseMhFilter()) {
        mFilterId = bean.getFilterRes();
        if (mMhManager != null) {
            mMhManager.setFilter(bean.getFilterRes());
        }
    } else {
        if (mMeiYanChangedListener != null) {
            mMeiYanChangedListener.onFilterChanged(bean.getName());
        }
    }

}

/**
 * 亮度数值发生变化
 */
private void notifyLiangDuChanged() {
    if (mMhManager == null || mInputValue == null || mUseValue == null) {
        return;
    }
    if (mInputValue.getLiangDu() != mUseValue.getLiangDu()) {
        mInputValue.setLiangDu(mUseValue.getLiangDu());
        mMhManager.setBrightness(mUseValue.getLiangDu());
    }
}

/**
 * 美颜美型数值发生变化
 */
public void notifyMeiYanChanged() {
    if (mMhManager == null || mInputValue == null || mUseValue == null) {
        return;
    }
    MeiYanValueBean input = mInputValue;
    MeiYanValueBean use = mUseValue;
    if (mMeiYanChangedListener != null) {
        boolean meiBaiChanged = false;
        boolean moPiChanged = false;
        boolean hongRunChanged = false;
        if (input.getMeiBai() != use.getMeiBai()) {
            input.setMeiBai(use.getMeiBai());
            meiBaiChanged = true;
        }
        if (input.getMoPi() != use.getMoPi()) {
            input.setMoPi(use.getMoPi());
            moPiChanged = true;
        }
        if (input.getHongRun() != use.getHongRun()) {
            input.setHongRun(use.getHongRun());
            hongRunChanged = true;
        }
        mMeiYanChangedListener.onMeiYanChanged(input.getMeiBai(), meiBaiChanged, input.getMoPi(), moPiChanged, input.getHongRun(), hongRunChanged);

    } else {
        //美白
        if (input.getMeiBai() != use.getMeiBai()) {
            input.setMeiBai(use.getMeiBai());
            mMhManager.setSkinWhiting(input.getMeiBai());
        }
        //磨皮
        if (input.getMoPi() != use.getMoPi()) {
            input.setMoPi(use.getMoPi());
            mMhManager.setSkinSmooth(input.getMoPi());

        }
        //红润
        if (input.getHongRun() != use.getHongRun()) {
            input.setHongRun(use.getHongRun());
            mMhManager.setSkinTenderness(input.getHongRun());
        }
    }

    //大眼
    if (input.getDaYan() != use.getDaYan()) {
        input.setDaYan(use.getDaYan());
        mMhManager.setBigEye(input.getDaYan());
    }
    //眉毛
    if (input.getMeiMao() != use.getMeiMao()) {
        input.setMeiMao(use.getMeiMao());
        mMhManager.setEyeBrow(input.getMeiMao());
    }
    //眼距
    if (input.getYanJu() != use.getYanJu()) {
        input.setYanJu(use.getYanJu());
        mMhManager.setEyeLength(input.getYanJu());
    }
    //眼角
    if (input.getYanJiao() != use.getYanJiao()) {
        input.setYanJiao(use.getYanJiao());
        mMhManager.setEyeCorner(input.getYanJiao());
    }
    //瘦脸
    if (input.getShouLian() != use.getShouLian()) {
        input.setShouLian(use.getShouLian());
        mMhManager.setFaceLift(input.getShouLian());
    }
    //嘴型
    if (input.getZuiXing() != use.getZuiXing()) {
        input.setZuiXing(use.getZuiXing());
        mMhManager.setMouseLift(input.getZuiXing());
    }
    //瘦鼻
    if (input.getShouBi() != use.getShouBi()) {
        input.setShouBi(use.getShouBi());
        mMhManager.setNoseLift(input.getShouBi());
    }
    //下巴
    if (input.getXiaBa() != use.getXiaBa()) {
        input.setXiaBa(use.getXiaBa());
        mMhManager.setChinLift(input.getXiaBa());
    }
    //额头
    if (input.getETou() != use.getETou()) {
        input.setETou(use.getETou());
        mMhManager.setForeheadLift(input.getETou());
    }
    //长鼻
    if (input.getChangBi() != use.getChangBi()) {
        input.setChangBi(use.getChangBi());
        mMhManager.setLengthenNoseLift(input.getChangBi());
    }
    //削脸
    if (input.getXueLian() != use.getXueLian()) {
        input.setXueLian(use.getXueLian());
        mMhManager.setFaceShave(input.getXueLian());
    }
    //开眼角
    if (input.getKaiYanJiao() != use.getKaiYanJiao()) {
        input.setKaiYanJiao(use.getKaiYanJiao());
        mMhManager.setEyeAlat(input.getKaiYanJiao());
    }
}


/**
 * 获取贴纸列表
 */
public static void getTieZhiList(int id, final CommonCallback<String> commonCallback) {
    MHSDK.getTieZhiList(id, new MHSDK.TieZhiListCallback() {
        @Override
        public void getTieZhiList(String data) {
            if (commonCallback != null) {
                commonCallback.callback(data);
            }
        }
    });
}


/**
 * 下载贴纸
 */
public static void downloadTieZhi(String tieZhiName, final CommonCallback<Boolean> commonCallback) {
    MHSDK.downloadSticker(tieZhiName, new MHSDK.TieZhiDownloadCallback() {
        @Override
        public void tieZhiDownload(String tieZhiName, boolean success) {
            if (success) {
                if (commonCallback != null) {
                    commonCallback.callback(true);
                }
            } else {
                if (commonCallback != null) {
                    commonCallback.callback(false);
                }
            }
        }
    });

}


/**
 * 贴纸是否下载了
 */
public static boolean isTieZhiDownloaded(String name) {
    return MHSDK.isTieZhiDownloaded(name);
}

这样就实现了美颜的功能，一般来说，在快速搭建直播平台的过程中，美颜功能是直接使用美颜SDK实现。