CameraImage.cs

/*
 * Copyright (C) 2020-2023 Tilt Five, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
using System;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using UnityEngine;
 
using TiltFive;
using TiltFive.Logging;
 
namespace TiltFive
{
    public class CameraImage : Singleton<CameraImage>
    {

        private Dictionary<GlassesHandle, CameraImageCore> cameraImageCores = new Dictionary<GlassesHandle, CameraImageCore>();
 
        #region Public Functions
 
        internal static void Initialize(GlassesHandle glassesHandle)
        {
            Instance.cameraImageCores[glassesHandle] = new CameraImageCore(glassesHandle);
        }
 
        internal static void RemoveCore(GlassesHandle glassesHandle){
            if(!Instance.cameraImageCores.TryGetValue(glassesHandle, out var cameraImageCore)) { return; }
            cameraImageCore.Dispose();
            Instance.cameraImageCores.Remove(glassesHandle);
        }

        public static bool TryGetFilledCameraImageBuffer(PlayerIndex playerIndex, ref T5_CamImage camImage)
        {
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                return false;
            }
 
            return TryGetFilledCameraImageBuffer(glassesHandle, ref camImage);
        }
 
        internal static bool TryGetFilledCameraImageBuffer(GlassesHandle glassesHandle, ref T5_CamImage camImage)
        {
            if(!Glasses.IsConnected(glassesHandle) || !Instance.cameraImageCores.TryGetValue(glassesHandle, out var cameraImageCore))
            {
                return false;
            }
 
            return cameraImageCore.TryGetFilledCameraImageBuffer(ref camImage);
        }

 
        public static bool TrySubmitEmptyCameraImageBuffer(PlayerIndex playerIndex, IntPtr imageBuffer, UInt32 bufferSize)
        {
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                return false;
            }
 
            return TrySubmitEmptyCameraImageBuffer(glassesHandle, imageBuffer, bufferSize);
        }
 
        internal static bool TrySubmitEmptyCameraImageBuffer(GlassesHandle glassesHandle, IntPtr imageBuffer, UInt32 bufferSize)
        {
            if(!Glasses.IsConnected(glassesHandle) || !Instance.cameraImageCores.TryGetValue(glassesHandle, out var cameraImageCore))
            {
                return false;
            }
 
            return cameraImageCore.TrySubmitEmptyCameraImageBuffer(imageBuffer, bufferSize);
        }

 
        public static bool TryCancelCameraImageBuffer(PlayerIndex playerIndex, byte[] imageBuffer)
        {
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                return false;
            }
 
            return TryCancelCameraImageBuffer(glassesHandle, imageBuffer);
        }
 
        internal static bool TryCancelCameraImageBuffer(GlassesHandle glassesHandle, byte[] imageBuffer)
        {
            if(!Glasses.IsConnected(glassesHandle) || !Instance.cameraImageCores.TryGetValue(glassesHandle, out var cameraImageCore))
            {
                return false;
            }
 
            return cameraImageCore.TryCancelCameraImageBuffer(imageBuffer);
        }

 
        public static bool TryConfigureCameraImageStream(PlayerIndex playerIndex, T5_CameraStreamConfig config)
        {
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                return false;
            }
 
            return TryConfigureCameraImageStream(glassesHandle, config);
        }
 
        internal static bool TryConfigureCameraImageStream(GlassesHandle glassesHandle, T5_CameraStreamConfig config)
        {
            if(!Glasses.IsConnected(glassesHandle) || !Instance.cameraImageCores.TryGetValue(glassesHandle, out var cameraImageCore))
            {
                return false;
            }
 
            return cameraImageCore.TryConfigureCameraImageStream(config);
        }

 
        public static bool TryGetDewarpedPixelCoordinate(PlayerIndex playerIndex, ref T5_PixelDewarp pixelDewarp)
        {
            if(!Player.TryGetGlassesHandle(playerIndex, out var glassesHandle))
            {
                return false;
            }
 
            return TryGetDewarpedPixelCoordinate(glassesHandle, ref pixelDewarp);
        }
 
        internal static bool TryGetDewarpedPixelCoordinate(GlassesHandle glassesHandle, ref T5_PixelDewarp pixelDewarp)
        {
            if(!Glasses.IsConnected(glassesHandle) || !Instance.cameraImageCores.TryGetValue(glassesHandle, out var cameraImageCore))
            {
                return false;
            }
 
            return cameraImageCore.TryGetDewarpedPixelCoordinate(ref pixelDewarp);
        }
 
        #endregion Public Functions
 

        private class CameraImageCore : IDisposable
        {
            public GlassesHandle glassesHandle;
 
            public CameraImageCore(GlassesHandle glassesId)
            {
                this.glassesHandle = glassesId;
            }
 
            public virtual void Dispose(){
                Log.Info($"CameraImageCore for {glassesHandle} disconnected");
                return;
            }
 
            public bool TryGetDewarpedPixelCoordinate(ref T5_PixelDewarp pixelDewarp)
            {
                int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
                try
                {
                    result = NativePlugin.GetDewarpedPixelCoordinate(glassesHandle, ref pixelDewarp);
                }
                catch (System.Exception e)
                {
                    Log.Error($"Error calculating pixel dewarp location: {e.Message}");
                }
                return result == NativePlugin.T5_RESULT_SUCCESS;
            }
 
            public bool TryConfigureCameraImageStream(T5_CameraStreamConfig config)
            {
                int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
                try
                {
                    result = NativePlugin.ConfigureCameraStream(glassesHandle, config);
                }
                catch (System.Exception e)
                {
                    Log.Error($"Error enabling Camera Stream: {e.Message}");
                }
                return result == NativePlugin.T5_RESULT_SUCCESS;
            }
 
            public bool TryGetFilledCameraImageBuffer(ref T5_CamImage camImage)
            {
                int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
 
                try
                {
                    result = NativePlugin.GetFilledCamImageBuffer(glassesHandle, ref camImage);
                }
                catch (System.Exception e)
                {
                    Log.Error($"Error getting Camera Image: {e.Message}");
                }
                return result == NativePlugin.T5_RESULT_SUCCESS;
            }
 
            public bool TrySubmitEmptyCameraImageBuffer(IntPtr imageBuffer, UInt32 bufferSize)
            {
                int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
                try
                {
                    result = NativePlugin.SubmitEmptyCamImageBuffer(glassesHandle, imageBuffer, bufferSize);
                }
                catch (System.Exception e)
                {
                    Log.Error($"Error submitting Camera Image Buffer: {e.Message}");
                }
 
                return result == NativePlugin.T5_RESULT_SUCCESS;
            }
 
            public bool TryCancelCameraImageBuffer(byte[] imageBuffer)
            {
                int result = NativePlugin.T5_RESULT_UNKNOWN_ERROR;
                try
                {
                    GCHandle handle = GCHandle.Alloc(imageBuffer, GCHandleType.Pinned);
                    var ImageBufferHandle = handle.AddrOfPinnedObject();
                    result = NativePlugin.CancelCamImageBuffer(glassesHandle, ImageBufferHandle);
                    handle.Free();
                }
                catch (System.Exception e)
                {
                    Log.Error($"Error clearing Camera Image Buffers: {e.Message}");
                }
 
                return result == NativePlugin.T5_RESULT_SUCCESS;
            }
        }
    }
}