API 接口文档说明

一、绿幕抠图-android

public class LSOGreenMatting {
    public LSOGreenMatting();
    /**
     * 设置抠像强度, 范围是0--100;
     */
    public void setGreenMattingLevel(int level);
    /**
     * 获取当前抠图强度
     * 范围是0--100;
     */
    public int getGreenMattingLevel();
    /**
     * 获取默认抠图强度
     */
    public int getGreenMattingDefaultLevel();
    /**
     * 抠绿的保护区域设置
     * xStart和xEnd的范围 0.0---1.0;
     * yStart 和 yEnd的范围是0.0 --1.0;
     *
     * @param xStart 横向坐标的开始区域.
     * @param xEnd   横向坐标的结束区域坐标. 范围是0.0---1.0; 左侧是0.0, 最右侧是1.0;
     * @param yStart 纵向Y的开始坐标 范围是0.0---1.0; 上侧是0.0, 最下侧是1.0;
     * @param yEnd   纵向Y的结束坐标, 范围是0.0---1.0; 上侧是0.0, 最下侧是1.0;
     */
    public void setGreenMattingProtectRect(float xStart, float xEnd, float yStart, float yEnd);
    /**
     * 取消绿幕抠图的区域保护
     */
    public void cancelGreenMattingProtectRect();
    /**
     * 获取抠绿的最小阈值范围
     */
    public Range<Float> getMattingGreenMinThresholdRange();
    /**
     * 获取抠绿的最大阈值范围
     */
    public Range<Float> getMattingGreenMaxThresholdRange();
    /**
     * 设置抠绿的最小阈值;
     */
    public void setMattingGreenMinThreshold(float value);
    /**
     * 获取当前抠绿的最小阈值;
     */
    public float getMattingGreenMinThreshold();
    /**
     * 设置抠绿的最大阈值;
     */
    public void setMattingGreenMaxThreshold(float value);
    /**
     * 获取抠绿的最大阈值;
     */
    public float getMattingGreenMaxThreshold();
    /**
     * 设置抠蓝的最小阈值范围;
     * @return
     */
    public Range<Float> getMattingBlueMinThresholdRange();
    /**
     * 设置抠蓝的最大阈值范围;
     */
    public Range<Float> getMattingBlueMaxThresholdRange();
    /**
     * 设置抠蓝的最小阈值
     */
    public void setMattingBlueMinThreshold(float value);
    /**
     * 获取当前抠蓝的最小阈值
     */
    public float getMattingBlueMinThreshold() ;
    /**
     * 设置抠蓝的最大阈值
     */
    public void setMattingBlueMaxThreshold(float value);
    /**
     * 获取当前抠蓝的最大阈值;
     */
    public float getMattingBlueMaxThreshold() ;
    /**
     * 获取抠红的最小阈值范围;
     */
    public Range<Float> getMattingRedMinThresholdRange() ;
    /**
     * 获取抠红的最大阈值范围;
     */
    public Range<Float> getMattingRedMaxThresholdRange();
    /**
     * 设置抠红的最小阈值;
     */
    public void setMattingRedMinThreshold(float value) ;
    /**
     * 获取当前抠红的最小阈值
     */
    public float getMattingRedMinThreshold() ;
    /**
     * 设置抠红的最大阈值;
     */
    public void setMattingRedMaxThreshold(float value);
    /**
     * 获取当前抠红的最大阈值
     */
    public float getMattingRedMaxThreshold() ;
    /**
     * 设置抠图类型;
     * 当前支持 NONE/ GREEN /BLUE/RED;
     * @param type
     */
    public void setMattingType(LSOGreenMattingType type) ;
    /**
     * 执行绿幕抠图
     * 此方法工作在opengles语境中.
     * @param context   android的Context的语境 可以是getApplicationContext()
     * @param textureId sample2D类型的纹理, 建议是fbo渲染后的.
     * @param width     纹理的宽度
     * @param height    纹理的高度
     * @return 返回渲染后的纹理, 失败则返回-1
     */
    public int renderOnGPU(Context context, int textureId, int width, int height);
;
    /**
     * 执行绿幕抠图 camera环境下.
     *   此方法工作在opengles语境中.
     * @param context   android的context语境
     * @param textureId 输入的相机纹理EXT类型
     * @param tmpMatrix 相机获取到的坐标
     * @param front 当前是否前置
     * @param width 纹理宽度
     * @param height 高度
     * @return 返回渲染后的纹理,失败则返回-1
     */
    public int renderCameraExtIdOnGPU(Context context, int textureId, float[] tmpMatrix, boolean front, int width, int height);
    /**
     * 释放纹理
     * 此方法工作在opengles语境中.
     */
    public void releaseOnGPU();
}

二、绿幕抠图-iOS

#import <Foundation/Foundation.h>
#import "LSOObject.h"
NS_ASSUME_NONNULL_BEGIN
@interface LSOGreenMatting : LSOObject
/**
初始化
*/
- (instancetype)init;
/**
size: 是输入的图像宽高;
如果是竖屏则建议是720x1280 / 1080x1920;
如果是横屏,则建议是1280x720   / 1920x1080;
仅在初始化后,设置一次; 不可多次设置;
*/
@property (nonatomic, assign)CGSize renderSize;
/**
渲染一帧,输入的是sampleBuffer
输出的是CVPixelBuffer;
*/
- (CVPixelBufferRef)renderOneFrameWithSampeBuffer:(CMSampleBufferRef)sampleBuffer;
/**
抠绿一帧
*/
- (CVPixelBufferRef)renderOneFrameWithPixelBuffer:(CVPixelBufferRef)pixelBuffer;
/**
释放;
*/
- (void)releaseLSO;
/**
设置分割类型, 默认是绿色; 支持绿色/红色/蓝色/无;
*/
@property (nonatomic, assign) VisionSDKMattingType mattingType;
/**
绿幕抠图的调节级别
范围是:
0--1.0f;
0是禁止抠像; 0.1抠的很弱; 0.5适中; 1.0是抠的最强(可能会把一些不是绿的也抠去)
*/
@property (nonatomic,assign) CGFloat greenMattingLevel;
/**
读取 默认强度;
*/
@property (nonatomic,readonly) CGFloat greenMattingLevelDefault;
/// 在绿幕抠图的时候, 光线很暗的情况下可能有阴影,这里是设置阴影的百分比.
/// 范围是0.0---1.0; 默认是1.0; 0.0是完全消除; 1.0是不消除;
@property (nonatomic, assign) CGFloat greenMattingShadowPercent;
///--------------------------------------------抠绿---------------------------------
/// 获取抠绿 最小阈值范围start;
@property (nonatomic, readonly) CGFloat mattingGreenMin_start;
/// 获取抠绿的最小阈值范围end
@property (nonatomic, readonly) CGFloat mattingGreenMin_end;
/// 获取抠绿的最小阈值默认值;
@property (nonatomic, readonly) CGFloat mattingGreenMin_default;
/// 设置和获取抠绿的最小阈值
@property (nonatomic,assign) CGFloat mattingGreenMin;
/// 获取抠绿的最大阈值范围start;
@property (nonatomic, readonly) CGFloat mattingGreenMax_start;
/// 获取抠绿的最大阈值end
@property (nonatomic, readonly) CGFloat mattingGreenMax_end;
/// 获取抠绿的最大阈值默认值;
@property (nonatomic, readonly) CGFloat mattingGreenMax_default;
/// 设置和获取抠绿的最大阈值
@property (nonatomic,assign) CGFloat mattingGreenMax;
///----------------------------------------------抠蓝(参数含义同抠绿)-------------------------------
//调节蓝色抠图 最小阈值
@property (nonatomic, readonly) CGFloat mattingBlueMin_start;
@property (nonatomic, readonly) CGFloat mattingBlueMin_end;
@property (nonatomic, readonly) CGFloat mattingBlueMin_default;
@property (nonatomic, assign) CGFloat mattingBlueMin;
//调节蓝色抠图 最大阈值
@property (nonatomic, readonly) CGFloat mattingBlueMax_start;
@property (nonatomic, readonly) CGFloat mattingBlueMax_end;
@property (nonatomic, readonly) CGFloat mattingBlueMax_default;
@property (nonatomic, assign) CGFloat mattingBlueMax;
///---------------------------------------------抠红(参数含义同抠绿)-------------------------------
//调节红色抠图 最小阈值
@property (nonatomic, readonly) CGFloat mattingRedMin_start;
@property (nonatomic, readonly) CGFloat mattingRedMin_end;
@property (nonatomic, readonly) CGFloat mattingRedMin_default;
@property (nonatomic, assign) CGFloat mattingRedMin;
//调节红色抠图 最大阈值
@property (nonatomic, readonly) CGFloat mattingRedMax_start;
@property (nonatomic, readonly) CGFloat mattingRedMax_end;
@property (nonatomic, readonly) CGFloat mattingRedMax_default;
@property (nonatomic, assign) CGFloat mattingRedMax;
/// 设置绿色抠图的保护区域.
/// 保护区域内不抠图;
/// @param startX 横向的开始点, 横向从左到右,分别是0.0---1.0;
/// @param endX 横向的结束点, 横向从左到右,分别是0.0---1.0;
/// @param startY 竖向的结束点, 从上到下,分别是0.0---1.0;
/// @param endY 竖向的结束点, 从上到下,分别是0.0---1.0;
-(void)setMattingProtectRect:(CGFloat)startX endX:(CGFloat)endX startY:(CGFloat)startY endY:(CGFloat)endY;
/**
取消保护区域
*/
-(void)cancelMattingProtectRect;
@end
NS_ASSUME_NONNULL_END

三、AI人像抠图-Android

Java-AI抠图的纹理接口

public class LSOAiMattingCamera {
    /**
     * 异步初始化
     */
    public void initAsync()
    /**
     * 异步初始化是否完毕;
     */
    public boolean isReady()
    /**
     * 相机是否切换镜头
     * 如果是视频抠图,则不需要调用;
     */
    public void changeCameraOnGPU()
    /**
     *   对相机camera的抠图
     * @param isExt 是否是ext类型的纹理
     * @param texture 纹理id
     * @param tmpMatrix 纹理的matrix坐标
     * @param front 当前是否是前置
     * @param width 纹理的宽度
     * @param height 纹理的高度
     * @return 抠图后的纹理, 如失败返回-1;
     * @throws Exception 其他情况会抛出异常
     */
    public int mattingTextureOnGPU(boolean isExt, int texture, float[] tmpMatrix, boolean front, int width, int height) throws Exception;
    /**
     * sample2D类型的纹理;
     * [图片抠图用到]
     * @param textureId 纹理
     * @param width     纹理宽度
     * @param height    纹理高度
     * @return
     */
    public int mattingSample2DTextureOnGPU(int textureId, int width, int height) throws Exception;
    /**
     * 释放
     * 工作在GPU语境下;
     */
    public void releaseOnGPU();
}

Java-AI抠图的RGBA接口

public class LSOAiMattingRGBA {
/**
     * 加载模型[静态方法, 初始一次即可]
     * @param protoV2
     * @param model2
     * @param protoV6
     * @param modelV6
     * @param cacheDir
     */
public static void setModelPath(String protoV2,String model2,String protoV6,String modelV6,String cacheDir);
    public LSOAiMattingRGBA() ;
/**
     * 初始化
     * 使用快速的模型
     */
public void initWithFast();
/**
     * 初始化模型
     * 使用精细模式的模型
     */
public void initWithGood() ;
/**
     * 抠图一帧画面
     *
     * @param dataBytes 输入的图像数据;
     * @param width     数据的实际宽度
     * @param height    图像的实际高度
     * @param rotate    是否要旋转角度, 当前支持0/90/180/270; 其中ARGB不支持旋转;
     * @param format    输入图像的格式
     * @param dstBytes   抠图结果图像数据,注意:无论是否旋转,输出的图像数据的宽高是init时的宽度和高度;
     * @return 是否抠图成功
*/
public boolean mattingOneFrame(byte[] dataBytes, int width, int height, LSODataRotateType rotate, LSODataFormatType format, byte[] dstBytes);
/**
     * 释放
     */
public void releaseOnRGBA();
}

C语言-AI抠图RGBA接口

/**
* RGBA的方式抠图
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* 设置模型路径
* @param protoV2
* @param modelV2
* @param protoV6
* @param modelV6
* @param cacheDir 缓存路径,建议参考demo的路径;
*/
void LSOAiMattingRGBA_setModelPath(char *protoV2, char *modelV2,char *protoV6, char *modelV6,char *cacheDir);
/**
*   初始化快的模型;
*   耗时严重, 建议异步加载;
*   [初始化只能是一个]
* @return 返回对象句柄;
*/
long LSOAiMattingRGBA_initWithFast();
/**
*   初始化好的模型;
*   耗时严重, 建议异步加载;
*   [初始化只能是一个]
* @return 返回对象句柄;
*/
long LSOAiMattingRGBA_initWithGood();
/**
* 抠图一帧画面,可输入不同的分辨率
* 输入的宽高必须是4的倍数,并大于144x144,
* 输出的分辨率 等于输入的分辨率,如果有旋转则输出的宽高是旋转后的宽高;
*
* 内部有同步机制,确保同一时刻只有一个执行;
*
*   DATA_FORMAT_ARGB = 0,
        DATA_FORMAT_NV21 = 1,
        DATA_FORMAT_NV12 = 2,
        DATA_FORMAT_YUV420 = 3,
* @param handle 初始化返回的句柄
* @param srcData 输入图像指针
* @param width   输入图像的宽度
* @param height 输入图像的高度
* @param rotate 旋转角度是0/90/180/270.其中RGBA不支持旋转;
* @param format 见上面
* @param dstBuffer 输出指针,外部创建,ARgb格式(A最高位,R最低位),
* @return
*/
bool LSOAiMattingRGBA_mattingOneFrame(long handle, void *srcData,int width, int height, int rotate, int format, void *dstBuffer);
/**
* 释放
* @param handle 初始化时的句柄;
*/
void LSOAiMattingRGBA_release(long handle);
#ifdef __cplusplus
};
#endif

四、AI 人像抠图- iOS

//
//   VisionSDKAiMattingAPI.h
//   LanSongEditorFramework
//
//   Created by sno on 2021/12/30.
//   Copyright © 2021 sno. All rights reserved.
//
#import <Foundation/Foundation.h>
#import <Foundation/Foundation.h>
#import "LSOObject.h"
NS_ASSUME_NONNULL_BEGIN
@interface LSOAiMatting : NSObject
/// 抠图初始化 , 此方法耗时,建议放到异步执行;
/// @param force 是否强制等级, 如设置为NO,则内部会根据不同处理器,而做相关的调整; 设置为YES则用最好的等级;
/// @param fastMode 是否是快速模式, 建议为快速模式; 设置为YES
/// @param angle 本地视频的时候, 是否旋转角度;
- (instancetype)initWithForceLevel:(BOOL)force fastMode:(BOOL)fastMode videoRotateAngle:(int)angle;
/// 是否正在工作;
@property (nonatomic, readonly) BOOL   isWorking;
/// 是否画面左右镜像;
@property (nonatomic, assign) BOOL   mirrorX;
/// 是否输出mask类型的黑白图像; 在调用mattingWithSampleBuffer 之前设置;
/// [不建议设置]
@property (nonatomic, assign) BOOL   outMaskData;
@property (nonatomic, assign) BOOL   advanceMatting;
/// 抠图方法
/// @param sampleBuffer 输入的是摄像头的图像, 需要是kCVPixelFormatType_32BGRA格式
/// @param handler 抠图完毕后的画面,可转换为UIImage,直接预览, 工作在UI(dispatch_get_main_queue)线程中;
- (void)mattingWithSampleBuffer:(CMSampleBufferRef)sampleBuffer handler:(void (^)(CVImageBufferRef)) handler;
/// 释放
- (void)releaseLSO;
@end
NS_ASSUME_NONNULL_END

五、AI人像抠图- widows

#ifndef VisionSDKSegmentAPI_H
#define VisionSDKSegmentAPI_H
#include <string>
#pragma warning(push)
#pragma warning(disable : 4251)
class __declspec(dllimport) VisionSDKSegmentAPI {
public:
    /**
     * @brief   初始化分割模型
     *
     * @param keyPath 模型的授权文件, 暂时为null;
     * @param protoPath 输入我们提供的tenLineV3.proto路径
     * @param modelPath 输入我们提供的tenLineV3.model路径
     * @return int 初始化成功,返回0; 失败返回-1;
     */
    int init(std::string keyPath, std::string protoPath, std::string modelPath);
    /**
     * @brief 开始分割一帧数据
     *
     * @param rgba 要分割的图像数据指针,rgba格式
     * @param width 图像数据的宽度
     * @param height   图像的高度
     * @param dst   分割完毕后返回的图像指针, rgba格式， 内部是抠图完毕后的一帧带透明的画面。
     * @return int 分割成功返回0,失败返回-1;
     */
    int segmentOneFrame(unsigned char *rgba, int width, int height, unsigned char *dst);
    /**
     * @brief 释放分割模型
     *
     * @return int 返回0;
     */
    int release();
private:
    int createModelEnty(int level, int cpuType);
    double testRunTime(int type);
};
//------------------
//
//   如果您是C# 接口, 则建议用以下形式
// 以下代码和VisionSDKSegmentAPI类对象的形式底层是同一份代码.
//
/**
* @brief 打印调试信息开关;
*   is =1 则打印信息, =0 不打印;
*/
__declspec(dllimport) void _stdcall setVisionSDKSegmentAPIPrintDebugInfo(int is);
/**
* @brief 初始化
*
* @param ptrKeyPath 授权文件路径的指针, 内部会转好为char *;
* @param ptrProtoPath
* @param ptrModelPath
* @return int 成功返回0; 失败返回-1;
*/
__declspec(dllimport) int _stdcall VisionSDKSegmentAPI_init(void *ptrKeyPath, void *ptrProtoPath, void *ptrModelPath);
/**
* @brief 开始分割一帧数据
*
* @param rgba 要分割的图像数据指针,rgba格式
* @param width 图像数据的宽度
* @param height   图像的高度
* @param dst   分割完毕后返回的图像指针, rgba格式
* @return int 分割成功返回0,失败返回-1;
*/
__declspec(dllimport) int _stdcall VisionSDKSegmentAPI_segmentOneFrame(unsigned char *rgba, int width, int height,
                                                                       unsigned char *dst);
/**
* @brief 释放分割模型
*/
__declspec(dllimport) void _stdcall VisionSDKSegmentAPI_release(void);
#pragma warning(pop)
#endif   // VisionSDKSegmentAPI_H

六、图层容器-android

/**
* 创建一个图层渲染器
*
* @param context    android的context对象
* @param compWidth   渲染器的宽度
* @param compHeight 渲染器的高度;
*/
public LSOLayerRender(Context context, int compWidth, int compHeight)
    /**
     * 获取容器的宽度;
     *
     * @return
     */
    public int getCompWidth()
    /**
     * 获取容器的高度
     *
     * @return
     */
    public int getCompHeight()
    /**
     * 是否在运行;
     */
    public boolean isRunning()
    /**
     * 设置预览监听
     * @param listener
     */
    public void setOnPreviewProgressListener(OnPreviewProgressListener listener)
    /**
     * 错误监听
     */
    public void setOnLanSongSDKErrorListener(OnLanSongSDKErrorListener listener)
    /**
     * 请求渲染;
     * 外部主动请求渲染;
     */
    public void requestRender()
    /**
     * 容器开始执行
     */
    public boolean start()
    /**
     * 获取点击的坐标;
     * @param x
     * @param y
     * @return
     */
    public ILayerInterface getTouchPointLayer(float x, float y)
    /**
     * 设置touchView的参考大小;
     * @param width
     * @param height
     */
    public void setPreviewTempSize(int width, int height)
    /**
     * 替换背景, 背景可以是图片或视频, 内部通过后缀名区分
     *
     * @param path
     * @param audioVolume 音量, 视频时有效, 图片无效
     * @param listener    设置 好后的监听;
     */
    public void setBackGroundPath(String path, float audioVolume,
                                  OnSetCompletedListener listener)
    /**
     * 增加一个图层显示窗口
     * <p>
     * 把 指定图层绘制到此窗口上
     *
     * @param surfaceTexture 窗口对象
     * @param width          窗口的宽度
     * @param height         窗口的高度
     * @param layers         要显示的图层列表;
     * @param option         选项;
     */
    public void addLayerDisplayView(SurfaceTexture surfaceTexture, int width,
                                    int height, List<LSOCamLayer> layers,
                                    LSODisplayViewOption option)
}
/**
* 更新显示窗口 要显示的图层;
*
* @param surfaceTexture 要更新的窗口;
* @param layers         指定哪些图层更新这个窗口;
*/
public void updateLayerDisplayView(SurfaceTexture surfaceTexture,
                                   List<LSOCamLayer> layers)
    /**
     * 删除显示窗口;
     */
    public void removeLayerDisplayView(SurfaceTexture texture)
    /**
     * 是否包含指定的显示窗口
     *
     * @param surfaceTexture
     * @return
     */
    public boolean isContainDisplayView(SurfaceTexture surfaceTexture)
    /**
     * 增加一个外部的surface图层,异步增加 回调
     * surface图层和其他图层之处在于:
     * 其他图层直接绘制,而surface图层要等待外部把图像渲染到这个surface上.
     * 因此分为两步:
     * 第一步:. 给外部一个surface,让外部拿到调用setSurface对象后,
     * 开启摄像头/MediaPlayer等; 第二步:内部等到surface上有图像后,
     * 才返回图层对象;
     *
     * @param width    宽度
     * @param height   高度;
     * @param listener 增加后的状态监听
     */
    public void addSurfaceLayer(int width, int height,
                                OnAddSurfaceLayerEventListener listener)
    /**
     * 拷贝图层 仅支持通过addSurfaceLayer的图层 复制一个图层;
     * 注意:拷贝后的图层在使用中时, 原图层不能释放;
     *
     * @param layer        原图层
     * @param afterMatting 是否在抠图后拷贝
     * @param listener     结果监听;
     */
    public void copySurfaceLayer(LSOCamLayer layer, boolean afterMatting,
                                 OnAddLayerResultListener listener)
    /**
     * 增加一层图片图层;
     *
     * @return
     */
    public void addBitmapLayer(String path, OnAddLayerResultListener listener)
    /**
     * 增加一个图片图层.
     *
     * @param bmp
     * @return
     */
    public void addBitmapLayer(Bitmap bmp, OnAddLayerResultListener listener)
    /**
     * 增加gif图层
     *
     * @param path
     * @return
     */
    public void addGifLayer(String path, OnAddLayerResultListener listener)
    /**
     * 增加一个挂件:有绿色的视频或图片, 会把绿色部分抠图, 变成透明;
     *
     * @param path
     * @param listener
     */
    public void addGreenFileLayer(String path,
                                  OnAddLayerResultListener listener)
    /**
     * 增加画中画
     *
     * @param path     视频路径
     * @param listener
     */
    public void addVideoLayer(String path,
                              final OnAddLayerResultListener listener)
    /**
     * 增加nv21的图层
     */
    /**
     * 增加nv21图层
     *
     * @param width   数据的原始宽度
     * @param height 数据的原始高度
     * @param rotate 数据要旋转的角度;
     * @return
     */
    public void addNv21Layer(int width, int height, int rotate,
                             OnAddLayerResultListener listener)
    /**
     * 增加RGBA图层;, 宽度和高度必须是4的倍数;
     *
     * @param width   宽度
     * @param height 高度
     * @return
     */
    public void addRGBALayer(int width, int height,
                             OnAddLayerResultListener listener)
    /**
     * 从容器里释放一个图层;
     * @param layer
     * @param listener 释放完成监听;
     */
    public void releaseLayer(LSOCamLayer layer,
                             OnReleaseCompletedListener listener)
    /**
     * 获取背景图层.
     * 在每次setBackGroundPath会更新背景图层对象, 需要重新获取;
     * 设置后需等待30毫秒后获取
     * 不建议使用;
     *
     * @return
     */
    public LSOCamLayer getBackGroundLayer()
    /**
     * 设置输出数据的角度, 当前仅在nv21格式的时候,图像支持旋转;
     * 支持90/180/270;
     * [特定客户使用]
     *
     * @param angle
     */
    public void setPlayOutDataAngle(int angle)
    /**
     * 获取渲染一帧的时间;
     * 单位微秒;
     *
     * @return
     */
    public long getRenderOneFrameTimeMs()
    /**
     * 获取转换一帧的时间,
     * 单位微秒;
     *
     * @return
     */
    public long getConvertOneFrameTimeMs()
    /**
     * 指定图层的数据输出;
     *
     * 这里输出的图层是不包括背景图层的, 因为背景图层是必须输出到外部的.
     *
     * @param layers
     */
    public void setOnPlayerOutLayers(List<LSOCamLayer> layers)
    /**
     * 把当前容器中的图像 引出
     *
     * @param type     引出的数据类型;
     * @param sizeType 尺寸大小.
     * @param listener 回调, 工作在其他线程中,建议尽快把数据拷贝走,
     *     并用handler去另外处理
     */
    public void setOnPlayerDataOutListener(LSODataFormatType type,
                                           LSODataSizeType sizeType,
                                           OnPlayerDataOutListener listener)
    /**
    释放容器
   */
    public void release()

    /**
     * 获取原始宽度
     */
    public int getOriginalWidth();
    /**
     * 获取原始高度
     */
    public int getOriginalHeight();
    /**
     * 获取原始路径
     */
    public String getOriginalPath();
    /**
     * 获取原始时长
     *
     * @return
     */
    public long getOriginalDurationUs() ;
    /**
     * 获取当前图层在容器中的位置.
     * 最底部是0;
     */
    public int getLayerIndex()
    /**
     * 当是surface图层的时候, 获取surface对象
     */
    public Surface getSurface();
    /**
     * 推送nv21数据到图层
     */
    public void pushNV21Data(byte[] bytes);
    /**
     * 设置图层的缩放枚举类型
     类型有:
       //无缩放形式.则内部会根据不同的素材,采用默认形式;
    NONE,
     // 原始大小
     // 直接放入, 不做任意处理;
    ORIGINAL,
     // 忽略百分比,把宽度等于容器的宽度, 高度等于容器的高度,填满整个容器.
     // 这样有些画面可能会变形;
    FILL_COMPOSITION,
     // 裁剪填满 放入到容器中;
     // 把视频的中心点放到容器的中心点,然后 把画面等比例提填满整个容器,把多的部分裁剪掉.
    CROP_FILL_COMPOSITION,
     // 视频缩放模式
     // 如果视频宽度大于高度, 则宽度和容器对齐, 然后等比例调整高度;
     // 如果高度大于宽度, 则反之.
    VIDEO_SCALE_TYPE,
//画中画模式,即居中显示, 图像大小默认为容器的0.6倍;
PIP_TYPE
     */
    public void setScaleType(LSOScaleType type);
    /**
     * 设置是否显示
     * @param is
     */
    public void setVisibility(boolean is);
    public boolean isVisibility();
    /**
     * 缩放到的实际值
     * 当要设置缩放和旋转和位置时,
     * 应先缩放; 后设置位置;
     *
     * @param width
     * @param height
     */
    public void setScaledValue(float width, float height);
    /**
     * 返回缩放后的实际值;
     */
    public float getScaleWidth();
    /**
     * 获取缩放后的高度
     */
    public float getScaleHeight();
    /**
     * 获取容器的宽度
     */
    public int getCompWidth();
    /**
     * 获取容器的高度
     */
    public int getCompHeight();
    /**
     * 获取旋转角度.
     * @return
     */
    public float getRotation();
    /**
     * 设置旋转角度
     */
    public void setRotation(float angle);
    /**
     * 设置图层是否镜像, 上下镜像, 左右镜像.
     *
     * @param flipHorizontal
     * @param flipVertical
     */
    public void setLayerMirror(boolean flipHorizontal, boolean flipVertical);
    /**
     * 取消镜像
     */
    public void cancelLayerMirror();
    /**
     * 设置图层中心点的位置
     */
    public void setPosition(float xPos, float yPos);
    /**
     * 设置图层的位置;
     */
    public void setPosition(LSOLayerPosition position);
    /**
     * 获取中心点的X坐标
     */
    public float getPositionX() ;
    /**
     * 获取中心点的Y坐标
     */
    public float getPositionY();
    /**
     * 设置透明度比例,范围0.0-1.0;
     */
    public void setOpacityPercent(float percent);
    /**
     * 获取透明度范围
     */
    public float getOpacityPercent();
    /**
     * 当图层是RGBA图层时, 推送RGBA数据.
     */
    public void pushRgbaData(byte[] bytes);