/// <summary>
 /// Renders the latest frame.
 /// </summary>
 /// <param name="cameraId">Camera identifier.</param>
 public static void RenderLatestFrame(TangoEnums.TangoCameraId cameraId)
 {
     double timestamp = 0.0f;
     int returnValue = VideoOverlayAPI.TangoService_updateTexture(cameraId, ref timestamp);
     if (returnValue != Common.ErrorType.TANGO_SUCCESS)
     {
         Debug.Log("VideoOverlayProvider.UpdateTexture() Texture was not updated by camera!");
     }
 }

 /// <summary>
 /// Get the camera/sensor intrinsics.
 /// </summary>
 /// <param name="cameraId">Camera identifier.</param>
 /// <param name="intrinsics">Camera intrinsics data.</param>
 public static void GetIntrinsics(TangoEnums.TangoCameraId cameraId, [Out] TangoCameraIntrinsics intrinsics)
 {
     int returnValue = VideoOverlayAPI.TangoService_getCameraIntrinsics(cameraId, intrinsics);
     
     if (returnValue != Common.ErrorType.TANGO_SUCCESS)
     {
         Debug.Log("IntrinsicsProviderAPI.TangoService_getCameraIntrinsics() failed!");
     }
 }

 /// <summary>
 /// Connects the texture.
 /// </summary>
 /// <param name="cameraId">Camera identifier.</param>
 /// <param name="textureId">Texture identifier.</param>
 public static void ConnectTexture(TangoEnums.TangoCameraId cameraId, int textureId)
 {
     int returnValue = VideoOverlayAPI.TangoService_connectTextureId(cameraId, textureId);
     
     if (returnValue != Common.ErrorType.TANGO_SUCCESS)
     {
         Debug.Log("VideoOverlayProvider.ConnectTexture() Texture was not connected to camera!");
     }
 }

 public static void ExperimentalConnectTexture(TangoEnums.TangoCameraId cameraId, int textureId, TangoService_onUnityFrameAvailable onUnityFrameAvailable)
 {
     int returnValue = VideoOverlayAPI.TangoService_Experimental_connectTextureIdUnity(cameraId, (uint)textureId, callbackContext, onUnityFrameAvailable);
     
     if (returnValue != Common.ErrorType.TANGO_SUCCESS)
     {
         Debug.Log("VideoOverlayProvider.ConnectTexture() Texture was not connected to camera!");
     }
 }

		/// <summary>
		/// Sets the callback for notifications when image data is ready.
		/// </summary>
		/// <param name="cameraId">Camera identifier.</param>
		/// <param name="onImageAvailable">On image available callback handler.</param>
		public static void SetCallback(TangoEnums.TangoCameraId cameraId, TangoService_onImageAvailable onImageAvailable)
		{
			int returnValue = VideoOverlayAPI.TangoService_connectOnFrameAvailable(cameraId, callbackContext, onImageAvailable);
			if(returnValue == Tango.Common.ErrorType.TANGO_SUCCESS)
			{
				Debug.Log(CLASS_NAME + ".SetCallback() Callback was set.");
			}
			else
			{
				Debug.Log(CLASS_NAME + ".SetCallback() Callback was not set!");
			}

		}

 public static extern int TangoService_Experimental_connectTextureIdUnity(TangoEnums.TangoCameraId id, 
                                                                          uint tex, 
                                                                          IntPtr context, 
                                                                          TangoService_onUnityFrameAvailable onUnityFrameAvailable);

 public static int TangoService_Experimental_connectTextureIdUnity(
     TangoEnums.TangoCameraId id, UInt32 texture_y, UInt32 texture_Cb, UInt32 texture_Cr, 
     IntPtr context, APIOnTextureAvailable callback)
 {
     return Common.ErrorType.TANGO_SUCCESS;
 }

 public static int TangoService_getCameraIntrinsics(
     TangoEnums.TangoCameraId cameraId, [Out] TangoCameraIntrinsics intrinsics)
 {
     return Common.ErrorType.TANGO_SUCCESS;
 }

 public static int TangoService_updateTexture(TangoEnums.TangoCameraId cameraId, ref double timestamp)
 {
     return Common.ErrorType.TANGO_SUCCESS;
 }

 public static extern int TangoService_connectOnTextureAvailable(
     TangoEnums.TangoCameraId cameraId, IntPtr ContextMenu, APIOnTextureAvailable callback);

 public static int TangoService_connectOnFrameAvailable(TangoEnums.TangoCameraId cameraId,
                                                        IntPtr context,
                                                        [In,Out] TangoService_onImageAvailable onImageAvailable)
 {
     return Tango.Common.ErrorType.TANGO_SUCCESS;
 }

 public static int TangoService_connectTextureId(TangoEnums.TangoCameraId cameraId, int textureHandle)
 {
     return Tango.Common.ErrorType.TANGO_SUCCESS;
 }

 /// <summary>
 /// Connect a callback to a camera for texture updates.
 /// </summary>
 /// <param name="cameraId">
 /// The ID of the camera to connect this texture to.  Only <code>TANGO_CAMERA_COLOR</code> and
 /// <code>TANGO_CAMERA_FISHEYE</code> are supported.
 /// </param>
 /// <param name="callback">Function called when a new frame is available from the camera.</param>
 internal static void SetCallback(TangoEnums.TangoCameraId cameraId, APIOnTextureAvailable callback)
 {
     int returnValue = API.TangoService_connectOnTextureAvailable(cameraId, IntPtr.Zero, callback);
     if (returnValue == Common.ErrorType.TANGO_SUCCESS)
     {
         Debug.Log(CLASS_NAME + ".SetCallback(OnTextureAvailable) Callback was set.");
     }
     else
     {
         Debug.Log(CLASS_NAME + ".SetCallback(OnTextureAvailable) Callback was not set!");
     }
 }

        /// <summary>
        /// Clear all camera callbacks.
        /// </summary>
        /// <param name="cameraId">Camera identifier.</param>
        internal static void ClearCallback(TangoEnums.TangoCameraId cameraId)
        {
            int returnValue = API.TangoService_Experimental_connectTextureIdUnity(cameraId, 0, 0, 0, 
                                                                                  IntPtr.Zero, null);
            if (returnValue == Common.ErrorType.TANGO_SUCCESS)
            {
                Debug.Log(CLASS_NAME + ".ClearCallback() Unity callback was cleared.");
            }
            else
            {
                Debug.Log(CLASS_NAME + ".ClearCallback() Unity callback was not cleared!");
            }

            returnValue = API.TangoService_connectOnFrameAvailable(cameraId, IntPtr.Zero, null);
            if (returnValue == Common.ErrorType.TANGO_SUCCESS)
            {
                Debug.Log(CLASS_NAME + ".ClearCallback() Frame callback was cleared.");
            }
            else
            {
                Debug.Log(CLASS_NAME + ".ClearCallback() Frame callback was not cleared!");
            }
            
            returnValue = API.TangoService_connectOnTextureAvailable(cameraId, IntPtr.Zero, null);
            if (returnValue == Common.ErrorType.TANGO_SUCCESS)
            {
                Debug.Log(CLASS_NAME + ".ClearCallback() Texture callback was cleared.");
            }
            else
            {
                Debug.Log(CLASS_NAME + ".ClearCallback() Texture callback was not cleared!");
            }
        }

        /// <summary>
        /// Handle the callback sent by the Tango Service
        /// when a new image is sampled.
        /// </summary>
        /// <param name="cameraId">Camera identifier.</param>
        /// <param name="callbackContext">Callback context.</param>
        /// <param name="imageBuffer">Image buffer.</param>
        protected void _OnImageAvailable(IntPtr callbackContext,
    	                                 TangoEnums.TangoCameraId cameraId, 
    	                                 TangoImageBuffer imageBuffer)
        {
            m_previousCameraId = cameraId;

            if(m_previousImageBuffer.data == null)
            {
                m_previousImageBuffer.data = new byte[imageBuffer.width * imageBuffer.height * 2];
            }

            m_previousImageBuffer.width = imageBuffer.width;
            m_previousImageBuffer.height = imageBuffer.height;
            m_previousImageBuffer.stride = imageBuffer.stride;
            m_previousImageBuffer.timestamp = imageBuffer.timestamp;
            m_previousImageBuffer.format = imageBuffer.format;
            m_previousImageBuffer.frame_number = imageBuffer.frame_number;

            Marshal.Copy(imageBuffer.data, m_previousImageBuffer.data, 0, m_previousImageBuffer.data.Length);

            m_shouldSendEvent = true;
        }

 public static extern int TangoService_updateTextureExternalOes(
     TangoEnums.TangoCameraId cameraId, UInt32 glTextureId, out double timestamp);

    /// <summary>
    /// This will be called when a new frame is available from the camera.
    ///
    /// The first scan-line of the color image is reserved for metadata instead of image pixels.
    /// </summary>
    /// <param name="cameraId">Camera identifier.</param>
    public void OnExperimentalTangoImageAvailable(TangoEnums.TangoCameraId cameraId)
    {
        if (cameraId == TangoEnums.TangoCameraId.TANGO_CAMERA_COLOR)
        {
            m_screenUpdateTime = VideoOverlayProvider.RenderLatestFrame(TangoEnums.TangoCameraId.TANGO_CAMERA_COLOR);

            // Rendering the latest frame changes a bunch of OpenGL state.  Ensure Unity knows the current OpenGL state.
            GL.InvalidateState();
        }
    }

 public static extern int TangoService_connectOnFrameAvailable(
     TangoEnums.TangoCameraId cameraId, IntPtr context, 
     [In, Out] APIOnImageAvailable callback);

        /// <summary>
        /// DEPRECATED: Update the texture that has been connected to camera referenced by TangoCameraId with the latest image
        /// from the camera.
        /// </summary>
        /// <returns>The timestamp of the image that has been pushed to the connected texture.</returns>
        /// <param name="cameraId">
        /// The ID of the camera to connect this texture to.  Only <c>TANGO_CAMERA_COLOR</c> is supported.
        /// </param>
        public static double RenderLatestFrame(TangoEnums.TangoCameraId cameraId)
        {
#if UNITY_EDITOR
            if (m_emulatedExpId_Y != null && m_emulatedExpId_CbCr != null)
            {
                m_emulatedExpId_Y.DiscardContents();
                m_emulatedExpId_CbCr.DiscardContents();
                Graphics.Blit(m_emulatedColorRenderTexture, m_emulatedExpId_Y, m_yuvFilterY);
                Graphics.Blit(m_emulatedColorRenderTexture, m_emulatedExpId_CbCr, m_yuvFilterCbCr);
            }

            return m_lastColorEmulationTime;
#else

            double timestamp = 0.0;
            int returnValue = API.TangoService_updateTexture(cameraId, ref timestamp);
            if (returnValue != Common.ErrorType.TANGO_SUCCESS)
            {
                Debug.Log("VideoOverlayProvider.UpdateTexture() Texture was not updated by camera!");
            }
            
            return timestamp;
#endif
        }

        /// <summary>
        /// Update the AR screen's texture to the most recent state of the specified camera.
        /// </summary>
        /// <returns>The timestamp of the image that has been pushed to the AR screen's texture.</returns>
        /// <param name="cameraId">
        /// The ID of the camera to connect this texture to.  Only <c>TANGO_CAMERA_COLOR</c> is supported.
        /// </param>
        public static double UpdateARScreen(TangoEnums.TangoCameraId cameraId)
        {
#if UNITY_EDITOR
            if (m_emulatedARScreenTexture != null)
            {
                m_emulatedARScreenTexture.DiscardContents();
                Graphics.Blit(m_emulatedColorRenderTexture, m_emulatedARScreenTexture);
            }

            return m_lastColorEmulationTime;
#else
            double timestamp = 0.0;
            uint tex = API.TangoUnity_getArTexture();
            int returnValue = API.TangoService_updateTextureExternalOes(cameraId, tex, out timestamp);
            
            if (returnValue != Common.ErrorType.TANGO_SUCCESS)
            {
                Debug.Log("Unable to update texture. " + Environment.StackTrace);
            }

            // Rendering the latest frame changes a bunch of OpenGL state.  Ensure Unity knows the current OpenGL 
            // state.
            GL.InvalidateState();

            return timestamp;
#endif
        }