async void Start()
{
webCamScreen = GameObject.Find("WebCamScreen");
if (useGPU)
{
gpuResources = GpuResources.Create().ConsumeValue();
gpuHelper = new GlCalculatorHelper();
gpuHelper.InitializeForTest(gpuResources);
}
#if UNITY_EDITOR
var resourceManager = LocalAssetManager.Instance;
#else
var resourceManager = AssetBundleManager.Instance;
#endif
ResourceUtil.InitializeResourceManager(resourceManager);
try {
await resourceManager.LoadAllAssetsAsync();
IsAssetLoaded = true;
} catch (Exception e) {
Debug.LogError(e);
IsAssetLoadFailed = true;
}
}
public void Ctor_ShouldInstantiateGlCalculatorHelper()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
Assert.AreNotEqual(IntPtr.Zero, glCalculatorHelper.mpPtr);
}
}
public void IsDisposed_ShouldReturnFalse_When_NotDisposedYet()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
Assert.False(glCalculatorHelper.isDisposed);
}
}
public void Initialize(GpuResources gpuResources, GlCalculatorHelper gpuHelper)
{
this.Initialize();
graph.SetGpuResources(gpuResources).AssertOk();
this.gpuHelper = gpuHelper;
}
public void InitializeForTest_ShouldInitialize()
{
var glCalculatorHelper = new GlCalculatorHelper();
Assert.False(glCalculatorHelper.Initialized());
glCalculatorHelper.InitializeForTest(GpuResources.Create().ConsumeValueOrDie());
Assert.True(glCalculatorHelper.Initialized());
}
private GlContext GetGlContext()
{
using (var glCalculatorHelper = new GlCalculatorHelper()) {
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
return(glCalculatorHelper.GetGlContext());
}
}
public void IsDisposed_ShouldReturnTrue_When_AlreadyDisposed()
{
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.Dispose();
Assert.True(glCalculatorHelper.isDisposed);
}
public void InitializeForTest_ShouldInitialize()
{
using (var glCalculatorHelper = new GlCalculatorHelper()) {
Assert.False(glCalculatorHelper.Initialized());
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
Assert.True(glCalculatorHelper.Initialized());
}
}
public void framebuffer_ShouldReturnGLName()
{
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.InitializeForTest(GpuResources.Create().ConsumeValueOrDie());
// default frame buffer
Assert.AreEqual(glCalculatorHelper.framebuffer, 0);
}
public void RunInGlContext_ShouldReturnInternal_When_FunctionReturnsInternal()
{
using (var glCalculatorHelper = new GlCalculatorHelper()) {
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
var status = glCalculatorHelper.RunInGlContext(() => { return(Status.Build(Status.StatusCode.Internal, "error")); });
Assert.AreEqual(status.code, Status.StatusCode.Internal);
}
}
public void RunInGlContext_ShouldReturnOk_When_FunctionReturnsOk()
{
using (var glCalculatorHelper = new GlCalculatorHelper()) {
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
var status = glCalculatorHelper.RunInGlContext(() => { return(Status.Ok()); });
Assert.True(status.ok);
}
}
public void RunInGlContext_ShouldReturnInternal_When_FunctionThrows()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
var status = glCalculatorHelper.RunInGlContext((GlCalculatorHelper.GlFunction)(() => { throw new Exception("Function Throws"); }));
Assert.AreEqual(Status.StatusCode.Internal, status.Code());
}
}
public void RunInGlContext_ShouldReturnFailedPreCondition_When_FunctionThrows()
{
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.InitializeForTest(GpuResources.Create().ConsumeValueOrDie());
var status = glCalculatorHelper.RunInGlContext(() => { throw new InvalidProgramException(); });
Assert.AreEqual(status.code, Status.StatusCode.FailedPrecondition);
}
public void Framebuffer_ShouldReturnGLName()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
// default frame buffer
Assert.AreEqual(0, glCalculatorHelper.framebuffer);
}
}
public static IEnumerator Initialize()
{
lock (setupLock) {
if (isInitialized)
{
Logger.LogWarning(TAG, "Already set up");
yield break;
}
#if UNITY_ANDROID && !UNITY_EDITOR
isContextInitialized = false;
PluginCallback callback = GetCurrentContext;
var fp = Marshal.GetFunctionPointerForDelegate(callback);
GL.IssuePluginEvent(fp, 1);
#else
isContextInitialized = true;
#endif
var count = 1000;
yield return(new WaitUntil(() => {
return --count < 0 || isContextInitialized;
}));
if (!isContextInitialized)
{
throw new TimeoutException("Failed to get GlContext");
}
#if UNITY_ANDROID
if (currentContext == IntPtr.Zero)
{
Logger.LogWarning(TAG, "EGL context is not found, so MediaPipe won't share their EGL contexts with Unity");
}
else
{
Logger.LogVerbose(TAG, $"EGL context is found: {currentContext}");
}
#endif
try {
Logger.LogInfo(TAG, "Initializing GpuResources...");
gpuResources = GpuResources.Create(currentContext).Value();
Logger.LogInfo(TAG, "Initializing GlCalculatorHelper...");
glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.InitializeForTest(gpuResources);
isInitialized = true;
} catch (Exception e) {
Logger.LogException(e);
Logger.LogError(TAG, "Failed to create GpuResources. If your native library is built for CPU, change 'Preferable Inference Mode' to CPU from the Inspector Window for Bootstrap");
}
}
}
protected virtual void OnDestroy()
{
Stop();
graph = null;
gpuHelper = null;
if (stopwatch != null && stopwatch.IsRunning)
{
stopwatch.Stop();
}
}
public void GetCurrent_ShouldReturnCurrentContext_When_CalledInGlContext()
{
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.InitializeForTest(GpuResources.Create().ConsumeValueOrDie());
glCalculatorHelper.RunInGlContext(() => {
var glContext = GlContext.GetCurrent();
Assert.NotNull(glContext);
Assert.True(glContext.IsCurrent());
return(Status.Ok());
}).AssertOk();
}
protected virtual void OnDestroy()
{
Stop();
if (graph != null)
{
graph.Dispose();
graph = null;
}
if (gpuHelper != null)
{
gpuHelper.Dispose();
gpuHelper = null;
}
}
public void CreateSourceTexture_ShouldFail_When_ImageFrameFormatIsInvalid()
{
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.InitializeForTest(GpuResources.Create().ConsumeValueOrDie());
var imageFrame = new ImageFrame(ImageFormat.Format.SBGRA, 32, 24);
var status = glCalculatorHelper.RunInGlContext(() => {
var texture = glCalculatorHelper.CreateSourceTexture(imageFrame);
texture.Dispose();
return(Status.Ok());
});
Assert.AreEqual(status.code, Status.StatusCode.FailedPrecondition);
}
private GlContext GetGlContext()
{
GlContext glContext = null;
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.InitializeForTest(GpuResources.Create().ConsumeValueOrDie());
glCalculatorHelper.RunInGlContext(() => {
glContext = GlContext.GetCurrent();
return(Status.Ok());
}).AssertOk();
return(glContext);
}
public void GetGlContext_ShouldReturnCurrentContext()
{
using (var glCalculatorHelper = new GlCalculatorHelper()) {
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
var glContext = glCalculatorHelper.GetGlContext();
#if UNITY_EDITOR_LINUX || UNITY_STANDALONE_LINUX || UNITY_ANDROID
Assert.AreNotEqual(glContext.eglContext, IntPtr.Zero);
#elif UNITY_STANDALONE_OSX
Assert.AreNotEqual(glContext.nsglContext, IntPtr.Zero);
#elif UNITY_IOS
Assert.AreNotEqual(glContext.eaglContext, IntPtr.Zero);
#endif
}
}
public void GetCurrent_ShouldReturnCurrentContext_When_CalledInGlContext()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
glCalculatorHelper.RunInGlContext(() =>
{
using (var glContext = GlContext.GetCurrent())
{
Assert.NotNull(glContext);
Assert.True(glContext.IsCurrent());
}
}).AssertOk();
}
}
void ExpectSetSurfaceOk(IntPtr surface)
{
var eglSurfaceHolder = new EglSurfaceHolder();
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.InitializeForTest(GpuResources.Create().ConsumeValueOrDie());
var status = glCalculatorHelper.RunInGlContext(() => {
var glContext = GlContext.GetCurrent();
eglSurfaceHolder.SetSurface(surface, glContext);
return(Status.Ok());
});
Assert.True(status.ok);
}
public void CreateDestinationTexture_ShouldReturnGlTexture_When_GpuBufferFormatIsValid()
{
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.InitializeForTest(GpuResources.Create().ConsumeValueOrDie());
var status = glCalculatorHelper.RunInGlContext(() => {
var glTexture = glCalculatorHelper.CreateDestinationTexture(32, 24, GpuBufferFormat.kBGRA32);
Assert.AreEqual(glTexture.width, 32);
Assert.AreEqual(glTexture.height, 24);
return(Status.Ok());
});
Assert.True(status.ok);
}
/// <summary>
/// Dispose GPU resources.
/// </summary>
/// <remarks>
/// This has to be called before the application exits.
/// Otherwise, UnityEditor can freeze.
/// </remarks>
public static void Shutdown()
{
if (GpuResources != null)
{
GpuResources.Dispose();
GpuResources = null;
}
if (GlCalculatorHelper != null)
{
GlCalculatorHelper.Dispose();
GlCalculatorHelper = null;
}
IsInitialized = false;
}
public void CreateDestinationTexture_ShouldReturnGlTexture_When_GpuBufferFormatIsValid()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
var status = glCalculatorHelper.RunInGlContext(() =>
{
var glTexture = glCalculatorHelper.CreateDestinationTexture(32, 24, GpuBufferFormat.kBGRA32);
Assert.AreEqual(32, glTexture.width);
Assert.AreEqual(24, glTexture.height);
});
Assert.True(status.Ok());
}
}
/// <summary>
/// This method must be called (only) once before calling StartRun.
/// `graph` and `gpuHelper` (if useGPU is true) are initialized here.
/// If the config is invalid, it throws an error.
/// </summary>
public void Initialize()
{
if (config == null)
{
throw new InvalidOperationException("config is missing");
}
graph = new CalculatorGraph(config.text);
if (shouldUseGPU())
{
var gpuResources = new StatusOrGpuResources().ConsumeValue();
graph.SetGpuResources(gpuResources).AssertOk();
gpuHelper = new GlCalculatorHelper();
gpuHelper.InitializeForTest(graph.GetGpuResources());
}
}
void InitializeGpuHelper(int eventId)
{
// context is EGL_NO_CONTEXT if the graphics API is not OpenGL ES
var context = Egl.getCurrentContext();
if (context == IntPtr.Zero)
{
Debug.LogWarning("No EGL Context Found");
}
else
{
Debug.Log($"EGL Context Found ({context})");
}
gpuResources = GpuResources.Create(context).ConsumeValueOrDie();
gpuHelper = new GlCalculatorHelper();
gpuHelper.InitializeForTest(gpuResources);
}
public void CreateSourceTexture_ShouldReturnGlTexture_When_CalledWithImageFrame()
{
var glCalculatorHelper = new GlCalculatorHelper();
glCalculatorHelper.InitializeForTest(GpuResources.Create().ConsumeValueOrDie());
var imageFrame = new ImageFrame(ImageFormat.Format.SRGBA, 32, 24);
var status = glCalculatorHelper.RunInGlContext(() => {
var texture = glCalculatorHelper.CreateSourceTexture(imageFrame);
Assert.AreEqual(texture.width, 32);
Assert.AreEqual(texture.height, 24);
texture.Dispose();
return(Status.Ok());
});
Assert.True(status.ok);
}
public void CreateSourceTexture_ShouldFail_When_ImageFrameFormatIsInvalid()
{
using (var glCalculatorHelper = new GlCalculatorHelper())
{
glCalculatorHelper.InitializeForTest(GpuResources.Create().Value());
using (var imageFrame = new ImageFrame(ImageFormat.Types.Format.Sbgra, 32, 24))
{
var status = glCalculatorHelper.RunInGlContext(() =>
{
using (var texture = glCalculatorHelper.CreateSourceTexture(imageFrame))
{
texture.Release();
}
});
Assert.AreEqual(Status.StatusCode.FailedPrecondition, status.Code());
status.Dispose();
}
}
}
