CameraDevice.cs

/*==============================================================================
Copyright 2017 Maxst, Inc. All Rights Reserved.
==============================================================================*/

using UnityEngine;
using System;
using System.Linq;
using System.Runtime.InteropServices;
using System.Collections.Generic;
using System.Text;

namespace maxstAR
{
    public class CameraDevice
    {
        public enum FocusMode 
        {
            FOCUS_MODE_CONTINUOUS_AUTO = 1,
            FOCUS_MODE_AUTO = 2
        }

        public enum CameraType
        {
            Rear = 0,

            Face = 1,
        }

        public enum CameraResolution
        {
            Resolution640x480,

            Resolution1280x720,

            Resolution1920x1080,
        }

        public enum FlipDirection
        {
            HORIZONTAL = 0,

            VERTICAL = 1
        }

        private static CameraDevice instance = null;

        public static CameraDevice GetInstance()
        {
            if (instance == null)
            {
                instance = new CameraDevice();
            }
            return instance;
        }

        private int cameraId = 0;
        private int preferredWidth = 0;
        private int preferredHeight = 0;
        private bool flipHorizontal = false;
        private bool flipVertical = false;
        private byte[] cameraFrameBuffer = null;

        private CameraDevice()
        {
        }

        public ResultCode Start()
        {
            int cameraType = 0;
            if (Application.platform == RuntimePlatform.OSXEditor || Application.platform == RuntimePlatform.WindowsEditor)
            {
                cameraType = AbstractConfigurationScriptableObject.GetInstance().WebcamType;
            }
            else
            {
                // TODO: Check WebCamTexture.devices isFrontFacing
                cameraType = (int)AbstractConfigurationScriptableObject.GetInstance().CameraType;
            }

            CameraDevice.CameraResolution cameraResolution = AbstractConfigurationScriptableObject.GetInstance().CameraResolution;
            switch (cameraResolution)
            {
                case CameraDevice.CameraResolution.Resolution640x480:
                    preferredWidth = 640;
                    preferredHeight = 480;
                    break;

                case CameraDevice.CameraResolution.Resolution1280x720:
                    preferredWidth = 1280;
                    preferredHeight = 720;
                    break;

                case CameraDevice.CameraResolution.Resolution1920x1080:
                    preferredWidth = 1920;
                    preferredHeight = 1080;
                    break;

                default:
                    preferredWidth = 640;
                    preferredHeight = 480;
                    break;
            }

            Debug.Log("Camera id : " + cameraId);

            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return (ResultCode)(NativeStaticAPI.CameraDevice_start(cameraType, preferredWidth, preferredHeight));
            }
            else
            {
                return (ResultCode)(NativeSharedAPI.CameraDevice_start(cameraType, preferredWidth, preferredHeight));
            }
        }

        public bool SetFocusMode(FocusMode focusMode)
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return NativeStaticAPI.CameraDevice_setFocusMode((int)focusMode);
            }
            else
            {
                return NativeSharedAPI.CameraDevice_setFocusMode((int)focusMode);
            }
        }

        public bool SetFlashLightMode(bool toggle)
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return NativeStaticAPI.CameraDevice_setFlashLightMode(toggle);
            }
            else
            {
                return NativeSharedAPI.CameraDevice_setFlashLightMode(toggle);
            }
        }

        public bool SetAutoWhiteBalanceLock(bool toggle)
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return NativeStaticAPI.CameraDevice_setAutoWhiteBalanceLock(toggle);
            }
            else
            {
                return NativeSharedAPI.CameraDevice_setAutoWhiteBalanceLock(toggle);
            }
        }

        public void FlipVideo(FlipDirection direction, bool on)
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                NativeStaticAPI.CameraDevice_flipVideo((int)direction, on);
            }
            else
            {
                NativeSharedAPI.CameraDevice_flipVideo((int)direction, on);
            }

            if (direction == FlipDirection.HORIZONTAL)
            {
                flipHorizontal = on;
            }

            if (direction == FlipDirection.VERTICAL)
            {
                flipVertical = on;
            }
        }

        public List<string> GetParamList()
        {
            List<string> paramList = new List<string>();
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                int size = NativeStaticAPI.CameraDevice_getParamList();
                for (int i = 0; i < size; i++)
                {
                    int keyLength = NativeStaticAPI.CameraDevice_Param_getKeyLength(i);
                    byte[] keyBytes = new byte[keyLength];
                    NativeStaticAPI.CameraDevice_Param_getKey(i, keyBytes);
                    string keyString = Encoding.UTF8.GetString(keyBytes).TrimEnd('\0');
                    paramList.Add(keyString);
                }
            }
            else
            {
                int size = NativeSharedAPI.CameraDevice_getParamList();
                for (int i = 0; i < size; i++)
                {
                    int keyLength = NativeSharedAPI.CameraDevice_Param_getKeyLength(i);
                    byte[] keyBytes = new byte[keyLength];
                    NativeSharedAPI.CameraDevice_Param_getKey(i, keyBytes);
                    string keyString = Encoding.UTF8.GetString(keyBytes).TrimEnd('\0');
                    paramList.Add(keyString);
                }
            }

            return paramList;
        }


        public bool SetParam(string key, bool boolTypeValue)
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return NativeStaticAPI.CameraDevice_setBoolTypeParameter(key, boolTypeValue);
            }
            else
            {
                return NativeSharedAPI.CameraDevice_setBoolTypeParameter(key, boolTypeValue);
            }
        }

        public bool SetParam(string key, int intTypeValue)
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return NativeStaticAPI.CameraDevice_setIntTypeParameter(key, intTypeValue);
            }
            else
            {
                return NativeSharedAPI.CameraDevice_setIntTypeParameter(key, intTypeValue);
            }
        }

        public bool SetParam(string key, int min, int max)
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return NativeStaticAPI.CameraDevice_setRangeTypeParameter(key, min, max);
            }
            else
            {
                return NativeSharedAPI.CameraDevice_setRangeTypeParameter(key, min, max);
            }
        }

        public bool SetParam(string key, string stringTypeValue)
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return NativeStaticAPI.CameraDevice_setStringTypeParameter(key, stringTypeValue);
            }
            else
            {
                return NativeSharedAPI.CameraDevice_setStringTypeParameter(key, stringTypeValue);
            }
        }

        public void Stop()
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                NativeStaticAPI.CameraDevice_stop();
            }
            else
            {
                NativeSharedAPI.CameraDevice_stop();
            }
        }

        public int GetWidth()
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return NativeStaticAPI.CameraDevice_getWidth();
            }
            else
            {
                return NativeSharedAPI.CameraDevice_getWidth();
            }
        }

        public int GetHeight()
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                return NativeStaticAPI.CameraDevice_getHeight();
            }
            else
            {
                return NativeSharedAPI.CameraDevice_getHeight();
            }
        }

        internal void GetProjectionMatrix(float[] matrix)
        {
            if (Application.platform == RuntimePlatform.IPhonePlayer)
            {
                NativeStaticAPI.CameraDevice_getProjectionMatrix(matrix);
            }
            else
            {
                NativeSharedAPI.CameraDevice_getProjectionMatrix(matrix);
            }
        }

        internal bool IsFlipHorizontal()
        {
            return flipHorizontal;
        }

        internal bool IsFlipVertical()
        {
            return flipVertical;
        }

        internal byte [] GetCameraFrameBuffer()
        {
            if (cameraFrameBuffer == null)
            {
                int cameraWidth = GetWidth();
                int cameraHeight = GetHeight();
                if (cameraWidth > 0 && cameraHeight > 0)
                {
                    cameraFrameBuffer = new byte[cameraWidth * cameraHeight * 3];
                }
            }

            if (cameraFrameBuffer != null)
            {
                TrackingState trackingState = TrackerManager.GetInstance().GetTrackingState();
                NativeSharedAPI.CameraDevice_getCameraImagePtr(trackingState.GetTrackingStateCPtr(), cameraFrameBuffer);
            }

            return cameraFrameBuffer;
        }
    }
}