ArabDesert/Assets/USharpVideo/Scripts/USharpVideoPlayer.cs


#define USE_SERVER_TIME_MS // Uses GetServerTimeMilliseconds instead of the server datetime which in theory is less reliable

using JetBrains.Annotations;
using UdonSharp;
using UnityEngine;
using VRC.SDK3.Components.Video;
using VRC.SDKBase;
using TMPro;

namespace UdonSharp.Video
{
    [AddComponentMenu("Udon Sharp/Video/USharp Video Player")]
    [UdonBehaviourSyncMode(BehaviourSyncMode.Manual)]
    public class USharpVideoPlayer : UdonSharpBehaviour
    {
        // Video player references
        VideoPlayerManager _videoPlayerManager;

        public name_gen _name_gen;


        [Tooltip("Whether to allow video seeking with the progress bar on the video")]
        [PublicAPI]
        public bool allowSeeking = true;

        [Tooltip("If enabled defaults to unlocked so anyone can put in a URL")]
        [SerializeField]
        bool defaultUnlocked = true;



        [Tooltip("If enabled allows the instance creator to always control the video player regardless of if they are master or not")]
        [PublicAPI]
        public bool allowInstanceCreatorControl = true;

        [Tooltip("How often the video player should check if it is more than Sync Threshold out of sync with the video time")]
        [PublicAPI]
        public float syncFrequency = 8.0f;
        [Tooltip("How many seconds desynced from the owner the client needs to be to trigger a resync")]
        [PublicAPI]
        public float syncThreshold = 0.85f;

        [Range(0f, 1f)]
        [Tooltip("The default volume for the volume slider on the video player")]
        [SerializeField]
        float defaultVolume = 0.5f;

#pragma warning disable CS0414
        [Tooltip("The max range of the audio sources on this video player")]
        [SerializeField]
        float audioRange = 40f;

#pragma warning restore CS0414

        /// <summary>
        /// Local offset from the network time to sync the video
        /// Can be used for things like making a video player sync up with someone singing
        /// </summary>
        [PublicAPI, System.NonSerialized]
        public float localSyncOffset = 0f;

        [Tooltip("List of urls to play automatically when the world is loaded until someone puts in another URL")]
        public VRCUrl[] playlist = new VRCUrl[0];

        [Tooltip("Should default to the stream player? This is usually used when you want to put a live stream in the default playlist.")]
        [SerializeField]
        bool defaultStreamMode = false;

        [Tooltip("If the default playlist should loop")]
        [PublicAPI]
        public bool loopPlaylist = false;

        [Tooltip("If the default playlist should be shuffled upon world load")]
        public bool shufflePlaylist = false;

        /// <summary>
        /// The URL that we should currently be playing and that other people are playing
        /// </summary>
        [UdonSynced]
        VRCUrl _syncedURL = VRCUrl.Empty;

        /// <summary>
        /// The video sequence identifier, gets incremented whenever a new video is put in. Used to determine in combination with _currentVideoIdx if we need to load the new URL
        /// </summary>
        [UdonSynced]
        int _syncedVideoIdx;
        int _currentVideoIdx;

        /// <summary>
        /// If we're locked so only the master may put in URLs
        /// </summary>
        [UdonSynced]
        bool _isMasterOnly = true;

        [UdonSynced]
        int _nextPlaylistIndex = 0;

#if USE_SERVER_TIME_MS
        [UdonSynced]
        int _networkTimeVideoStart;
        int _localNetworkTimeStart;
#else
        [UdonSynced]
        double _videoStartNetworkTime;
        double _localVideoStartTime;

        [UdonSynced]
        long _networkTimeStart;
        System.DateTime _localNetworkTimeStart;
#endif

        [UdonSynced]
        bool _ownerPlaying;

        [UdonSynced]
        bool _ownerPaused;
        bool _locallyPaused;

        [UdonSynced]
        bool _loopVideo = false;
        bool _localLoopVideo = false;

        [UdonSynced]
        int _shuffleSeed;

        // The last unpaused time in the video
        float _lastVideoTime;

        VideoControlHandler[] _registeredControlHandlers;
        VideoScreenHandler[] _registeredScreenHandlers;
        UdonSharpBehaviour[] _registeredCallbackReceivers;

        // Video loading state
        const int MAX_RETRY_COUNT = 4;
        const float DEFAULT_RETRY_TIMEOUT = 35.0f;
        const float RATE_LIMIT_RETRY_TIMEOUT = 5.5f;
        const float VIDEO_ERROR_RETRY_TIMEOUT = 5f;
        const float PLAYLIST_ERROR_RETRY_COUNT = 4;

        bool _loadingVideo = false;
        float _currentLoadingTime = 0f; // Counts down to 0 while loading
        int _currentRetryCount = 0;
        float _videoTargetStartTime = 0f;
        int _playlistErrorCount = 0;

        bool _waitForSync = false;

        // Player mode tracking
        const int PLAYER_MODE_UNITY = 0;
        const int PLAYER_MODE_AVPRO = 1;

        [UdonSynced]
        int currentPlayerMode = PLAYER_MODE_UNITY;
        int _localPlayerMode = PLAYER_MODE_UNITY;

        bool _videoSync = true;

        bool _ranInit = false;

        void Start()
        {

            if (_ranInit)
                return;

            _ranInit = true;

            _videoPlayerManager = GetVideoManager();
            _videoPlayerManager.Start();

            if (_registeredControlHandlers == null)
                _registeredControlHandlers = new VideoControlHandler[0];

            if (_registeredCallbackReceivers == null)
                _registeredCallbackReceivers = new UdonSharpBehaviour[0];

            if (Networking.IsOwner(gameObject))
            {
                if (defaultUnlocked)
                    _isMasterOnly = false;

                if (defaultStreamMode)
                {
                    SetPlayerMode(PLAYER_MODE_AVPRO);
                    _nextPlaylistIndex = 0; // SetPlayerMode sets this to -1, but we want to be able to keep it intact so reset to 0
                }

                _shuffleSeed = Random.Range(0, 10000);
            }

            _lastMasterLocked = _isMasterOnly;

            SetUILocked(_isMasterOnly);

#if !USE_SERVER_TIME_MS
            _networkTimeStart = Networking.GetNetworkDateTime().Ticks;
            _localNetworkTimeStart = new System.DateTime(_networkTimeStart, System.DateTimeKind.Utc);
#endif

            PlayNextVideoFromPlaylist();

            SetVolume(defaultVolume);

            // Serialize the default setup state from the master once regardless of if a video has played
            QueueSerialize();


        }

        public override void OnVideoReady()
        {
            ResetVideoLoad();
            _playlistErrorCount = 0;

            if (IsUsingAVProPlayer())
            {
                float duration = _videoPlayerManager.GetDuration();

                if (duration == float.MaxValue || float.IsInfinity(duration) || IsRTSPStream())
                    _videoSync = false;
                else
                    _videoSync = true;
            }
            else
                _videoSync = true;

            if (_videoSync)
            {
                if (Networking.IsOwner(gameObject))
                {
                    _waitForSync = false;
                    _videoPlayerManager.Play();
                }
                else
                {
                    if (_ownerPlaying)
                    {
                        _waitForSync = false;
                        _locallyPaused = false;
                        _videoPlayerManager.Play();

                        SyncVideo();
                    }
                    else
                    {
#if USE_SERVER_TIME_MS
                        if (_networkTimeVideoStart == 0)
#else
                        if (_videoStartNetworkTime == 0f || _videoStartNetworkTime > GetNetworkTime() - _videoPlayerManager.GetDuration()) // Todo: remove the 0f check and see how this actually gets set to 0 while the owner is playing
#endif
                        {
                            _waitForSync = true;
                            SetStatusText("Waiting for owner sync...");
                        }
                        else
                        {
                            _waitForSync = false;
                            SyncVideo();
                            SetStatusText("");
#if USE_SERVER_TIME_MS
                            LogMessage($"Loaded into world with complete video, duration: {_videoPlayerManager.GetDuration()}, start net time: {_networkTimeVideoStart}");
#else
                            LogMessage($"Loaded into world with complete video, duration: {_videoPlayerManager.GetDuration()}, start net time: {_videoStartNetworkTime}, subtracted net time {GetNetworkTime() - _videoPlayerManager.GetDuration()}");
#endif
                        }
                    }
                }
            }
            else // Live streams should start asap
            {
                _waitForSync = false;
                _videoPlayerManager.Play();
            }
        }

        public override void OnVideoStart()
        {
            if (Networking.IsOwner(gameObject))
            {
                SetPausedInternal(false, false);

#if USE_SERVER_TIME_MS
                _networkTimeVideoStart = Networking.GetServerTimeInMilliseconds() - (int)(_videoTargetStartTime * 1000f);
#else
                _videoStartNetworkTime = GetNetworkTime() - _videoTargetStartTime;
#endif

                _videoPlayerManager.SetTime(_videoTargetStartTime);

                _ownerPlaying = true;

                QueueSerialize();

                LogMessage($"Started video: {_syncedURL}");
            }
            else if (!_ownerPlaying) // Watchers pause and wait for sync from owner
            {
                _videoPlayerManager.Pause();
                _waitForSync = true;
            }
            else
            {
                SetPausedInternal(_ownerPaused, false);
                SyncVideo();
                LogMessage($"Started video: {_syncedURL}");
            }

            SetStatusText("");

            _videoTargetStartTime = 0f;

            SetUIPaused(_locallyPaused);

            UpdateRenderTexture();

            SendCallback("OnUSharpVideoPlay");
        }

        bool IsRTSPStream()
        {
            string urlStr = _syncedURL.ToString();

            return IsUsingAVProPlayer() &&
                   _videoPlayerManager.GetDuration() == 0f &&
                   IsRTSPURL(urlStr);
        }

        bool IsRTSPURL(string urlStr)
        {
            return urlStr.StartsWith("rtsp://", System.StringComparison.OrdinalIgnoreCase) ||
                   urlStr.StartsWith("rtmp://", System.StringComparison.OrdinalIgnoreCase) || // RTMP isn't really supported in VRC's context and it's probably never going to be, but we'll just be safe here
                   urlStr.StartsWith("rtspt://", System.StringComparison.OrdinalIgnoreCase) || // rtsp over TCP
                   urlStr.StartsWith("rtspu://", System.StringComparison.OrdinalIgnoreCase); // rtsp over UDP
        }

        public override void OnVideoEnd()
        {
            // VRC falsely throws OnVideoEnd instantly on RTSP streams since they report 0 length
            if (!IsRTSPStream())
            {
                if (Networking.IsOwner(gameObject))
                {
                    _ownerPlaying = false;
                    _ownerPaused = _locallyPaused = false;

                    SetStatusText("");
                    SetUIPaused(false);

                    PlayNextVideoFromPlaylist();
                    QueueSerialize();
                }

                SendCallback("OnUSharpVideoEnd");

                UpdateRenderTexture();
            }
        }

        // Workaround for bug that needs to be addressed in U# where calling built in methods with parameters will get the parameters overwritten when called from other UdonBehaviours
        public void _OnVideoErrorCallback(VideoError videoError)
        {
            OnVideoError(videoError);
        }

        public override void OnVideoError(VideoError videoError)
        {
            if (videoError == VideoError.RateLimited)
            {
                SetStatusText("Rate limited, retrying...");
                LogWarning("Rate limited, retrying...");
                _currentLoadingTime = RATE_LIMIT_RETRY_TIMEOUT;
                return;
            }
            else if (videoError == VideoError.PlayerError)
            {
                SetStatusText("Video error, retrying...");
                LogError("Video player error when trying to load " + _syncedURL);
                _loadingVideo = true; // Apparently OnVideoReady gets fired erroneously??
                _currentLoadingTime = VIDEO_ERROR_RETRY_TIMEOUT;
                return;
            }

            ResetVideoLoad();
            _videoTargetStartTime = 0f;

            _videoPlayerManager.Stop();

            LogError($"Video '{_syncedURL}' failed to play with error {videoError}");

            switch (videoError)
            {
                case VideoError.InvalidURL:
                    SetStatusText("Invalid URL");
                    break;
                case VideoError.AccessDenied:
                    SetStatusText("Video blocked, enabled untrusted URLs");
                    break;
                default:
                    SetStatusText("Failed to load video");
                    break;
            }

            ++_playlistErrorCount;
            PlayNextVideoFromPlaylist();

            SendCallback("OnUSharpVideoError");
        }

        public override void OnVideoPause() { }
        public override void OnVideoPlay() { }

        public override void OnVideoLoop()
        {
#if USE_SERVER_TIME_MS
            _localNetworkTimeStart = _networkTimeVideoStart = Networking.GetServerTimeInMilliseconds();
#else
            _localVideoStartTime = _videoStartNetworkTime = GetNetworkTime();
#endif

            QueueSerialize();
        }

        float _lastCurrentTime;

        private void Update()
        {
            if (_loadingVideo)
                UpdateVideoLoad();

            if (_locallyPaused)
            {
                if (IsInVideoMode())
                {
                    // Keep the target time the same while paused
#if USE_SERVER_TIME_MS
                    _networkTimeVideoStart = Networking.GetServerTimeInMilliseconds() - (int)(_videoPlayerManager.GetTime() * 1000f);
#else
                    _videoStartNetworkTime = GetNetworkTime() - _videoPlayerManager.GetTime();
#endif
                }
            }
            else
                _lastCurrentTime = _videoPlayerManager.GetTime();

            if (Networking.IsOwner(gameObject) || !_waitForSync)
            {
                SyncVideoIfTime();
            }
            else if (_ownerPlaying)
            {
                _videoPlayerManager.Play();
                LogMessage($"Started video: {_syncedURL}");
                _waitForSync = false;
                SyncVideo();
            }

            UpdateRenderTexture(); // Needed because AVPro can swap textures whenever
        }

        /// <summary>
        /// Uncomment this to prevent people from taking ownership of the video player when they shouldn't be able to
        /// </summary>
        //public override bool OnOwnershipRequest(VRCPlayerApi requestingPlayer, VRCPlayerApi requestedOwner)
        //{
        //    return !_isMasterOnly || IsPrivlegedUser(requestedOwner);
        //}

        bool _lastMasterLocked = false;

        public override void OnDeserialization()
        {
            if (Networking.IsOwner(gameObject))
                return;

#if !USE_SERVER_TIME_MS
            _localNetworkTimeStart = new System.DateTime(_networkTimeStart, System.DateTimeKind.Utc);
#endif

            SetPausedInternal(_ownerPaused, false);
            SetLoopingInternal(_loopVideo);

            if (_localPlayerMode != currentPlayerMode)
                SetPlayerMode(currentPlayerMode);

            if (_isMasterOnly != _lastMasterLocked)
                SetLockedInternal(_isMasterOnly);

            if (_currentVideoIdx != _syncedVideoIdx)
            {
                _currentVideoIdx = _syncedVideoIdx;

                _videoPlayerManager.Stop();
                StartVideoLoad(_syncedURL);

#if USE_SERVER_TIME_MS
                _localNetworkTimeStart = _networkTimeVideoStart;
#else
                _localVideoStartTime = _videoStartNetworkTime;
#endif

                LogMessage("Playing synced " + _syncedURL);
            }
#if USE_SERVER_TIME_MS
            else if (_networkTimeVideoStart != _localNetworkTimeStart) // Detect seeks
            {
                _localNetworkTimeStart = _networkTimeVideoStart;
#else
            else if (_videoStartNetworkTime != _localVideoStartTime) // Detect seeks
            {
                _localVideoStartTime = _videoStartNetworkTime;
#endif
                SyncVideo();
            }

            if (!_locallyPaused && IsInVideoMode())
            {
                float duration = GetVideoManager().GetDuration();

                // If the owner did a seek on the video after it finished, we need to start playing it again
#if USE_SERVER_TIME_MS
                if ((Networking.GetServerTimeInMilliseconds() - _networkTimeVideoStart) / 1000f < duration - 3f)
#else
                if (GetNetworkTime() - _videoStartNetworkTime < duration - 3f)
#endif
                    _videoPlayerManager.Play();
            }

            SendCallback("OnUSharpVideoDeserialization");
        }

        public override void OnOwnershipTransferred(VRCPlayerApi player)
        {
            SendUIOwnerUpdate();

            SendCallback("OnUSharpVideoOwnershipChange");
        }

        // Supposedly there's some case where late joiners don't receive data, so do a serialization just in case here.
        //public override void OnPlayerJoined(VRCPlayerApi player)
        //{
        //    if (!player.isLocal)
        //        QueueSerialize();
        //}

        /// <summary>
        /// Stops playback of the video completely and clears data
        /// </summary>
        [PublicAPI]
        public void StopVideo()
        {
            if (!Networking.IsOwner(gameObject))
                return;

#if USE_SERVER_TIME_MS
            _networkTimeVideoStart = 0;
#else
            _videoStartNetworkTime = 0f;
#endif
            _ownerPlaying = false;
            _locallyPaused = _ownerPaused = false;
            _videoTargetStartTime = 0f;
            _lastCurrentTime = 0f;

            SetUIPaused(false);
            ResetVideoLoad();

            QueueSerialize();

            SendCallback("OnUSharpVideoStop");
        }

        /// <summary>
        /// Play a video with the specified URL, only works if the player is allowed to use the video player
        /// </summary>
        /// <param name="url"></param>
        [PublicAPI]
        public void PlayVideo(VRCUrl url)
        {
            PlayVideoInternal(url, true);
        }

        /// <summary>
        /// Returns the URL that the video player currently has loaded
        /// </summary>
        /// <returns></returns>
        [PublicAPI]
        public VRCUrl GetCurrentURL() => _syncedURL;

        void PlayVideoInternal(VRCUrl url, bool stopPlaylist)
        {
            if (!CanControlVideoPlayer())
                return;

            string urlStr = url.Get();

            if (!ValidateURL(urlStr))
                return;

            bool wasOwner = Networking.IsOwner(gameObject);

            TakeOwnership();

            if (stopPlaylist)
                _nextPlaylistIndex = -1;

            _videoPlayerManager.Stop();
            StopVideo();

            _syncedURL = url;

            if (wasOwner)
                ++_syncedVideoIdx;
            else // Add two to avoid having conflicts where the old owner increases the count
                _syncedVideoIdx += 2;

            _currentVideoIdx = _syncedVideoIdx;

            StartVideoLoad(url);
            _ownerPlaying = false;
#if USE_SERVER_TIME_MS
            _networkTimeVideoStart = 0;
#endif

            _videoTargetStartTime = GetVideoStartTime(urlStr);

            QueueSerialize();

            SendCallback("OnUSharpVideoLoadStart");
        }

        void ResetVideoLoad()
        {
            _loadingVideo = false;
            _currentRetryCount = 0;
            _currentLoadingTime = DEFAULT_RETRY_TIMEOUT;
        }

        void UpdateVideoLoad()
        {
            //if (_loadingVideo) // Checked in caller now since it's cheaper
            {
                _currentLoadingTime -= Time.deltaTime;

                if (_currentLoadingTime <= 0f)
                {
                    _currentLoadingTime = DEFAULT_RETRY_TIMEOUT;

                    if (++_currentRetryCount > MAX_RETRY_COUNT)
                    {
                        OnVideoError(VideoError.Unknown);
                    }
                    else
                    {
                        LogMessage("Retrying load");

                        SetStatusText("Retrying load...");
                        _videoPlayerManager.LoadURL(_syncedURL);
                    }
                }
            }
        }

        float _lastSyncTime;

        void SyncVideoIfTime()
        {
            float timeSinceStartup = Time.realtimeSinceStartup;

            if (timeSinceStartup - _lastSyncTime > syncFrequency)
            {
                _lastSyncTime = timeSinceStartup;
                SyncVideo();
            }
        }

        /// <summary>
        /// Syncs the video time if it's too far diverged from the network time
        /// </summary>
        [PublicAPI]
        public void SyncVideo()
        {
            if (IsInVideoMode())
            {
#if USE_SERVER_TIME_MS
                float offsetTime = Mathf.Clamp((Networking.GetServerTimeInMilliseconds() - _networkTimeVideoStart) / 1000f + localSyncOffset, 0f, _videoPlayerManager.GetDuration());
#else
                float offsetTime = Mathf.Clamp((float)(GetNetworkTime() - _videoStartNetworkTime) + localSyncOffset, 0f, _videoPlayerManager.GetDuration());
#endif

                if (Mathf.Abs(_videoPlayerManager.GetTime() - offsetTime) > syncThreshold)
                {
                    _videoPlayerManager.SetTime(offsetTime);
                    LogMessage($"Syncing video to {offsetTime:N2}");
                }
            }
        }

        /// <summary>
        /// Syncs the video time regardless of how far diverged it is from the network time, can be used as a less aggressive audio resync in some cases
        /// </summary>
        [PublicAPI]
        public void ForceSyncVideo()
        {
            if (IsInVideoMode())
            {
#if USE_SERVER_TIME_MS
                float offsetTime = Mathf.Clamp((Networking.GetServerTimeInMilliseconds() - _networkTimeVideoStart) / 1000f + localSyncOffset, 0f, _videoPlayerManager.GetDuration());
#else
                float offsetTime = Mathf.Clamp((float)(GetNetworkTime() - _videoStartNetworkTime) + localSyncOffset, 0f, _videoPlayerManager.GetDuration());
#endif

                float syncNudgeTime = Mathf.Max(0f, offsetTime - 1f);
                _videoPlayerManager.SetTime(syncNudgeTime); // Seek to slightly earlier before syncing to the real time to get the video player to jump cleanly
                _videoPlayerManager.SetTime(offsetTime);
                LogMessage($"Syncing video to {offsetTime:N2}");
            }
        }

        void StartVideoLoad(VRCUrl url)
        {
#if UNITY_EDITOR
            LogMessage($"Started video load for URL: {url}");
#else
            LogMessage($"Started video load for URL: {url}, requested by {Networking.GetOwner(gameObject).displayName}");
#endif

            SetStatusText("Loading video...");
            ResetVideoLoad();
            _loadingVideo = true;
            _videoPlayerManager.LoadURL(url);

            AddUIUrlHistory(url);
        }

        void SetPausedInternal(bool paused, bool updatePauseTime)
        {
            if (Networking.IsOwner(gameObject))
                _ownerPaused = paused;

            if (_locallyPaused != paused)
            {
                _locallyPaused = paused;

                if (IsInVideoMode())
                {
                    if (_ownerPaused)
                        _videoPlayerManager.Pause();
                    else
                    {
                        _videoPlayerManager.Play();
                        if (updatePauseTime)
                            _videoTargetStartTime = _lastCurrentTime;
                    }
                }
                else
                {
                    if (_ownerPaused)
                        _videoPlayerManager.Stop();
                    else
                        StartVideoLoad(_syncedURL);
                }

                SetUIPaused(paused);

                if (_locallyPaused)
                    SendCallback("OnUSharpVideoPause");
                else
                    SendCallback("OnUSharpVideoUnpause");
            }

            QueueRateLimitedSerialize();
        }

        /// <summary>
        /// Pauses the video if we have control of the video player.
        /// </summary>
        /// <param name="paused"></param>
        [PublicAPI]
        public void SetPaused(bool paused)
        {
            if (Networking.IsOwner(gameObject))
                SetPausedInternal(paused, true);
        }

        [PublicAPI]
        public bool IsPaused()
        {
            return _ownerPaused;
        }

        void SetLoopingInternal(bool loop)
        {
            if (loop == _localLoopVideo)
                return;

            _loopVideo = _localLoopVideo = loop;

            _videoPlayerManager.SetLooping(loop);

            SetUILooping(loop);

            QueueRateLimitedSerialize();
        }

        /// <summary>
        /// Sets whether the currently playing video should loop and restart once it ends.
        /// </summary>
        /// <param name="loop"></param>
        [PublicAPI]
        public void SetLooping(bool loop)
        {
            if (Networking.IsOwner(gameObject))
                SetLoopingInternal(loop);
        }

        [PublicAPI]
        public bool IsLooping()
        {
            return _localLoopVideo;
        }

        [PublicAPI]
        public float GetVolume() => _videoPlayerManager.GetVolume();

        /// <summary>
        /// Sets the audio source volume for the audio sources used by this video player.
        /// </summary>
        /// <param name="volume"></param>
        [PublicAPI]
        public void SetVolume(float volume)
        {
            volume = Mathf.Clamp01(volume);
            if (volume == _videoPlayerManager.GetVolume())
                return;

            _videoPlayerManager.SetVolume(volume);
            SetUIVolume(volume);
        }

        [PublicAPI]
        public bool IsMuted() => _videoPlayerManager.IsMuted();

        /// <summary>
        /// Mutes audio from this video player
        /// </summary>
        /// <param name="muted"></param>
        [PublicAPI]
        public void SetMuted(bool muted)
        {
            _videoPlayerManager.SetMuted(muted);
            SetUIMuted(muted);
        }

        bool _delayedSyncAllowed = true;
        int _finalSyncCounter = 0;

        /// <summary>
        /// Takes a float in the range 0 to 1 and seeks the video to that % through the time
        /// Is intended to be used with progress bar-type-things
        /// </summary>
        /// <param name="progress"></param>
        [PublicAPI]
        public void SeekTo(float progress)
        {
            if (!allowSeeking || !Networking.IsOwner(gameObject))
                return;

            float newTargetTime = _videoPlayerManager.GetDuration() * progress;
            _lastVideoTime = newTargetTime;
            _lastCurrentTime = newTargetTime;

#if USE_SERVER_TIME_MS
            _localNetworkTimeStart = _networkTimeVideoStart = Networking.GetServerTimeInMilliseconds() - (int)(newTargetTime * 1000f);
#else
            _videoStartNetworkTime = GetNetworkTime() - newTargetTime;
            _localVideoStartTime = _videoStartNetworkTime;
#endif

            if (!_locallyPaused && !GetVideoManager().IsPlaying())
                GetVideoManager().Play();

            SyncVideo();
            QueueRateLimitedSerialize();
        }

        /// <summary>
        /// Used on things that are easily spammable to prevent flooding the network unintentionally.
        /// Will allow 1 sync every half second and then will send a final sync to propagate the final changed values of things at the end
        /// </summary>
        void QueueRateLimitedSerialize()
        {
            //QueueSerialize(); // Debugging line :D this serialization method can potentially hide some issues so we want to disable it sometimes and verify stuff works right

            if (_delayedSyncAllowed)
            {
                QueueSerialize();
                _delayedSyncAllowed = false;
                SendCustomEventDelayedSeconds(nameof(_UnlockDelayedSync), 0.5f);
            }

            ++_finalSyncCounter;
            SendCustomEventDelayedSeconds(nameof(_SendFinalSync), 0.8f);
        }

        public void _UnlockDelayedSync()
        {
            _delayedSyncAllowed = true;
        }

        // Handles running a final sync after doing a QueueRateLimitedSerialize, so that the final changes of the seek time get propagated
        public void _SendFinalSync()
        {
            if (--_finalSyncCounter == 0)
                QueueSerialize();
        }

        /// <summary>
        /// Determines if the local player can control this video player. This means the player is either the master, the instance creator, or the video player is unlocked.
        /// </summary>
        /// <returns></returns>
        [PublicAPI]
        public bool CanControlVideoPlayer()
        {
            return !_isMasterOnly || IsPrivilegedUser(Networking.LocalPlayer) || _name_gen.istrust();
        }

        /// <summary>
        /// If the given player is allowed to take important actions on this video player such as changing the video or locking the video player.
        /// This is what you would extend if you want to add an access control list or something similar.
        /// </summary>
        /// <param name="player"></param>
        /// <returns></returns>
        [PublicAPI]
        public bool IsPrivilegedUser(VRCPlayerApi player)
        {
#if UNITY_EDITOR
            if (player == null)
                return true;
#endif

            return player.isMaster || (allowInstanceCreatorControl && player.isInstanceOwner) || _name_gen.istrust();
        }

        /// <summary>
        /// Takes ownership of the video player if allowed
        /// </summary>
        [PublicAPI]
        public void TakeOwnership()
        {
            if (Networking.IsOwner(gameObject))
                return;

            if (CanControlVideoPlayer())
                Networking.SetOwner(Networking.LocalPlayer, gameObject);
        }

        [PublicAPI]
        public void QueueSerialize()
        {
            if (!Networking.IsOwner(gameObject))
                return;

            RequestSerialization();
        }

        bool _shuffled;

        /// <summary>
        /// Plays the next video from the video player's built-in playlist
        /// </summary>
        [PublicAPI]
        public void PlayNextVideoFromPlaylist()
        {
            if (_nextPlaylistIndex == -1 || playlist.Length == 0 || !Networking.IsOwner(gameObject))
                return;

            if (loopPlaylist && _playlistErrorCount > PLAYLIST_ERROR_RETRY_COUNT)
            {
                LogError("Maximum number of retries for playlist video looping hit. Stopping playlist playback.");
                _nextPlaylistIndex = -1;
                return;
            }

            if (shufflePlaylist && !_shuffled)
            {
                Random.InitState(_shuffleSeed);

                int n = playlist.Length - 1;
                for (int i = 0; i < n; ++i)
                {
                    int r = Random.Range(i + 1, n);
                    VRCUrl flipVal = playlist[r];
                    playlist[r] = playlist[i];
                    playlist[i] = flipVal;
                }

                _shuffled = true;
            }

            int currentIdx = _nextPlaylistIndex++;

            if (currentIdx >= playlist.Length)
            {
                if (loopPlaylist)
                {
                    _nextPlaylistIndex = 1;
                    currentIdx = 0;
                }
                else
                {
                    // We reached the end of the playlist
                    _nextPlaylistIndex = -1;
                    return;
                }
            }

            PlayVideoInternal(playlist[currentIdx], false);
        }

        [PublicAPI]
        public int GetPlaylistIndex() => _nextPlaylistIndex > 0 ? _nextPlaylistIndex - 1 : -1;

        [PublicAPI]
        public void SetNextPlaylistVideo(int nextPlaylistIdx)
        {
            _nextPlaylistIndex = nextPlaylistIdx;
        }

        /// <summary>
        /// Sets whether this video player is locked to the master which means only the master has the ability to put new videos in.
        /// </summary>
        /// <param name="locked"></param>
        [PublicAPI]
        public void SetLocked(bool locked)
        {
            if (Networking.IsOwner(gameObject))
                SetLockedInternal(locked);
        }

        private void SetLockedInternal(bool locked)
        {
            _isMasterOnly = locked;
            _lastMasterLocked = _isMasterOnly;

            SetUILocked(locked);

            QueueSerialize();

            SendCallback("OnUSharpVideoLockChange");
        }

        [PublicAPI]
        public bool IsLocked()
        {
            return _isMasterOnly;
        }

        /// <summary>
        /// Sets the video player to use the Unity video player as a backend
        /// </summary>
        [PublicAPI]
        public void SetToUnityPlayer()
        {
            if (CanControlVideoPlayer())
            {
                TakeOwnership();
                SetPlayerMode(PLAYER_MODE_UNITY);
            }
        }

        /// <summary>
        /// Sets the video player to use AVPro as the backend.
        /// AVPro supports streams so this is aliased in UI as the "Stream" player to avoid confusion
        /// </summary>
        [PublicAPI]
        public void SetToAVProPlayer()
        {
            if (CanControlVideoPlayer())
            {
                TakeOwnership();
                SetPlayerMode(PLAYER_MODE_AVPRO);
            }
        }

        void SetPlayerMode(int newPlayerMode)
        {
            if (_localPlayerMode == newPlayerMode)
                return;

            StopVideo();

            if (Networking.IsOwner(gameObject))
                _syncedURL = VRCUrl.Empty;

            currentPlayerMode = newPlayerMode;

            _locallyPaused = _ownerPaused = false;

            _nextPlaylistIndex = -1;

            _localPlayerMode = newPlayerMode;

            ResetVideoLoad();

            if (IsUsingUnityPlayer())
            {
                _videoPlayerManager.SetToVideoPlayerMode();
                SetUIToVideoMode();
            }
            else
            {
                _videoPlayerManager.SetToStreamPlayerMode();
                SetUIToStreamMode();
            }

            QueueSerialize();

            UpdateRenderTexture();

            SendCallback("OnUSharpVideoModeChange");
        }

        /// <summary>
        /// Are we playing a standard video where we know the length and need to sync its time across clients?
        /// </summary>
        /// <returns></returns>
        [PublicAPI]
        public bool IsInVideoMode()
        {
            return _videoSync;
        }

        /// <summary>
        /// Are we playing some type of live stream where we do not know the length of the stream and do not need to sync time across clients?
        /// </summary>
        /// <returns></returns>
        [PublicAPI]
        public bool IsInStreamMode()
        {
            return !_videoSync;
        }

        [PublicAPI]
        public bool IsUsingUnityPlayer()
        {
            return _localPlayerMode == PLAYER_MODE_UNITY;
        }

        [PublicAPI]
        public bool IsUsingAVProPlayer()
        {
            return _localPlayerMode == PLAYER_MODE_AVPRO;
        }

        /// <summary>
        /// Reloads the video on the video player, usually used if the video playback has encountered some internal issue or if the audio has gotten desynced from the video
        /// </summary>
        [PublicAPI]
        public void Reload()
        {
            if ((_ownerPlaying || Networking.IsOwner(gameObject)) && !_loadingVideo)
            {
                StartVideoLoad(_syncedURL);

                if (Networking.IsOwner(gameObject))
                    _videoTargetStartTime = GetVideoManager().GetTime();

                SendCallback("OnUSharpVideoReload");
            }
        }

        public VideoPlayerManager GetVideoManager()
        {
            if (_videoPlayerManager)
                return _videoPlayerManager;

            _videoPlayerManager = GetComponentInChildren<VideoPlayerManager>(true);
            if (_videoPlayerManager == null)
                LogError("Video Player Manager not found, make sure you have a manager setup properly");

            return _videoPlayerManager;
        }

        #region Utilities
        /// <summary>
        /// Parses the start time of a YouTube video from the URL.
        /// If no time is found or given URL is not a YouTube URL, returns 0.0
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        float GetVideoStartTime(string url)
        {
            // Attempt to parse out a start time from YouTube links with t= or start=
            if (url.Contains("youtube.com/watch") ||
                url.Contains("youtu.be/"))
            {
                int tIndex = url.IndexOf("?t=", System.StringComparison.Ordinal);
                if (tIndex == -1) tIndex = url.IndexOf("&t=", System.StringComparison.Ordinal);
                if (tIndex == -1) tIndex = url.IndexOf("?start=", System.StringComparison.Ordinal);
                if (tIndex == -1) tIndex = url.IndexOf("&start=", System.StringComparison.Ordinal);

                if (tIndex == -1)
                    return 0f;

                char[] urlArr = url.ToCharArray();
                int numIdx = url.IndexOf('=', tIndex) + 1;

                string intStr = "";

                while (numIdx < urlArr.Length)
                {
                    char currentChar = urlArr[numIdx];
                    if (!char.IsNumber(currentChar))
                        break;

                    intStr += currentChar;

                    ++numIdx;
                }

                if (string.IsNullOrWhiteSpace(intStr))
                    return 0f;

                int secondsCount = 0;
                if (int.TryParse(intStr, out secondsCount))
                    return secondsCount;
            }

            return 0f;
        }

        /// <summary>
        /// Checks for URL sanity and throws warnings if it's not nice.
        /// </summary>
        /// <param name="url"></param>
        bool ValidateURL(string url)
        {
            if (url.Contains("youtube.com/watch") ||
                url.Contains("youtu.be/"))
            {
                if (url.IndexOf("&list=", System.StringComparison.OrdinalIgnoreCase) != -1)
                    LogWarning($"URL '{url}' input with playlist link, this can slow down YouTubeDL link resolves significantly see: https://vrchat.canny.io/feature-requests/p/add-no-playlist-to-ytdl-arguments-for-url-resolution");
            }

            if (string.IsNullOrWhiteSpace(url)) // Don't do anything if the player entered an empty URL by accident
                return false;

            //if (!url.StartsWith("https://", System.StringComparison.OrdinalIgnoreCase) &&
            //    !url.StartsWith("http://", System.StringComparison.OrdinalIgnoreCase) &&
            //    !IsRTSPURL(url))
            int idx = url.IndexOf("://", System.StringComparison.Ordinal);
            if (idx < 1 || idx > 8) // I'm not sure exactly what rule VRC uses so just check for the :// in an expected spot since it seems like VRC checks that it has a protocol at least.
            {
                LogError($"Invalid URL '{url}' provided");
                SetStatusText("Invalid URL");
                SendCustomEventDelayedSeconds(nameof(_LateClearStatusInternal), 2f);
                return false;
            }

            // Longer than most browsers support, see: https://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers. I'm not sure if this length will even play in the video player.
            // Most CDN's keep their URLs under 1000 characters so this should be more than reasonable
            // Prevents people from pasting a book and breaking sync on the video player xd
            if (url.Length > 4096)
            {
                LogError($"Video URL is too long! url: '{url}'");
                SetStatusText("Invalid URL");
                SendCustomEventDelayedSeconds(nameof(_LateClearStatusInternal), 2f);
                return false;
            }

            return true;
        }

        public void _LateClearStatusInternal()
        {
            if (_videoPlayerManager.IsPlaying() && !_loadingVideo)
            {
                SetStatusText("");
            }
        }

#if !USE_SERVER_TIME_MS
        /// <summary>
        /// Gets network time with some degree of ms resolution unlike GetServerTimeInSeconds which is 1 second resolution
        /// </summary>
        /// <returns></returns>
        double GetNetworkTime()
        {
            //return Networking.GetServerTimeInSeconds();
            return (Networking.GetNetworkDateTime() - _localNetworkTimeStart).TotalSeconds;
        }
#endif

        void LogMessage(string message)
        {
            Debug.Log("[<color=#9C6994>USharpVideo</color>] " + message, this);
        }

        void LogWarning(string message)
        {
            Debug.LogWarning("[<color=#FF00FF>USharpVideo</color>] " + message, this);
        }

        void LogError(string message)
        {
            Debug.LogError("[<color=#FF00FF>USharpVideo</color>] " + message, this);
        }
        #endregion

        #region UI Control handling
        public void RegisterControlHandler(VideoControlHandler newControlHandler)
        {
            if (_registeredControlHandlers == null)
                _registeredControlHandlers = new VideoControlHandler[0];

            foreach (VideoControlHandler controlHandler in _registeredControlHandlers)
            {
                if (newControlHandler == controlHandler)
                    return;
            }

            VideoControlHandler[] newControlHandlers = new VideoControlHandler[_registeredControlHandlers.Length + 1];
            _registeredControlHandlers.CopyTo(newControlHandlers, 0);
            _registeredControlHandlers = newControlHandlers;

            _registeredControlHandlers[_registeredControlHandlers.Length - 1] = newControlHandler;

            newControlHandler.SetLocked(_isMasterOnly);
            newControlHandler.SetLooping(_localLoopVideo);
            newControlHandler.SetPaused(_locallyPaused);
            newControlHandler.SetStatusText(_lastStatusText);

            VideoPlayerManager manager = GetVideoManager();
            newControlHandler.SetVolume(manager.GetVolume());
            newControlHandler.SetMuted(manager.IsMuted());
        }

        public void UnregisterControlHandler(VideoControlHandler controlHandler)
        {
            if (_registeredControlHandlers == null)
                _registeredControlHandlers = new VideoControlHandler[0];

            int controlHandlerCount = _registeredControlHandlers.Length;
            for (int i = 0; i < controlHandlerCount; ++i)
            {
                VideoControlHandler handler = _registeredControlHandlers[i];

                if (controlHandler == handler)
                {
                    VideoControlHandler[] newControlHandlers = new VideoControlHandler[controlHandlerCount - 1];

                    for (int j = 0; j < i; ++j)
                        newControlHandlers[j] = _registeredControlHandlers[j];

                    for (int j = i + 1; j < controlHandlerCount; ++j)
                        newControlHandlers[j - 1] = _registeredControlHandlers[j];

                    _registeredControlHandlers = newControlHandlers;

                    return;
                }
            }
        }

        string _lastStatusText = "";

        void SetStatusText(string statusText)
        {
            if (statusText == _lastStatusText)
                return;

            _lastStatusText = statusText;

            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.SetStatusText(statusText);
        }

        void SetUIPaused(bool paused)
        {
            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.SetPaused(paused);
        }

        void SetUILocked(bool locked)
        {
            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.SetLocked(locked);
        }

        void AddUIUrlHistory(VRCUrl url)
        {
            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.AddURLToHistory(url);
        }

        void SetUIToVideoMode()
        {
            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.SetToVideoPlayerMode();
        }

        void SetUIToStreamMode()
        {
            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.SetToStreamPlayerMode();
        }

        void SendUIOwnerUpdate()
        {
            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.OnVideoPlayerOwnerTransferred();
        }

        void SetUILooping(bool looping)
        {
            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.SetLooping(looping);
        }

        void SetUIVolume(float volume)
        {
            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.SetVolume(volume);
        }

        void SetUIMuted(bool muted)
        {
            foreach (VideoControlHandler handler in _registeredControlHandlers)
                handler.SetMuted(muted);
        }
        #endregion

        #region Video Screen Handling
        public void RegisterScreenHandler(VideoScreenHandler newScreenHandler)
        {
            if (_registeredScreenHandlers == null)
                _registeredScreenHandlers = new VideoScreenHandler[0];

            foreach (VideoScreenHandler controlHandler in _registeredScreenHandlers)
            {
                if (newScreenHandler == controlHandler)
                    return;
            }

            VideoScreenHandler[] newControlHandlers = new VideoScreenHandler[_registeredScreenHandlers.Length + 1];
            _registeredScreenHandlers.CopyTo(newControlHandlers, 0);
            _registeredScreenHandlers = newControlHandlers;

            _registeredScreenHandlers[_registeredScreenHandlers.Length - 1] = newScreenHandler;
        }

        public void UnregisterScreenHandler(VideoScreenHandler screenHandler)
        {
            if (_registeredScreenHandlers == null)
                _registeredScreenHandlers = new VideoScreenHandler[0];

            int controlHandlerCount = _registeredScreenHandlers.Length;
            for (int i = 0; i < controlHandlerCount; ++i)
            {
                VideoScreenHandler handler = _registeredScreenHandlers[i];

                if (screenHandler == handler)
                {
                    VideoScreenHandler[] newControlHandlers = new VideoScreenHandler[controlHandlerCount - 1];

                    for (int j = 0; j < i; ++j)
                        newControlHandlers[j] = _registeredScreenHandlers[j];

                    for (int j = i + 1; j < controlHandlerCount; ++j)
                        newControlHandlers[j - 1] = _registeredScreenHandlers[j];

                    _registeredScreenHandlers = newControlHandlers;

                    return;
                }
            }
        }

        Texture _lastAssignedRenderTexture;

        void UpdateRenderTexture()
        {
            if (_registeredScreenHandlers == null)
                return;

            Texture renderTexture = _videoPlayerManager.GetVideoTexture();

            if (_lastAssignedRenderTexture == renderTexture)
                return;

            foreach (VideoScreenHandler handler in _registeredScreenHandlers)
            {
                if (Utilities.IsValid(handler))
                    handler.UpdateVideoTexture(renderTexture, IsUsingAVProPlayer());
            }

            _lastAssignedRenderTexture = renderTexture;

            SendCallback("OnUSharpVideoRenderTextureChange");
        }
        #endregion

        #region Callback Receivers
        /// <summary>
        /// Registers an UdonSharpBehaviour as a callback receiver for events that happen on this video player.
        /// Callback receivers can be used to react to state changes on the video player without needing to check periodically.
        /// </summary>
        /// <param name="callbackReceiver"></param>
        [PublicAPI]
        public void RegisterCallbackReceiver(UdonSharpBehaviour callbackReceiver)
        {
            if (!Utilities.IsValid(callbackReceiver))
                return;

            if (_registeredCallbackReceivers == null)
                _registeredCallbackReceivers = new UdonSharpBehaviour[0];

            foreach (UdonSharpBehaviour currReceiver in _registeredCallbackReceivers)
            {
                if (callbackReceiver == currReceiver)
                    return;
            }

            UdonSharpBehaviour[] newControlHandlers = new UdonSharpBehaviour[_registeredCallbackReceivers.Length + 1];
            _registeredCallbackReceivers.CopyTo(newControlHandlers, 0);
            _registeredCallbackReceivers = newControlHandlers;

            _registeredCallbackReceivers[_registeredCallbackReceivers.Length - 1] = callbackReceiver;
        }

        [PublicAPI]
        public void UnregisterCallbackReceiver(UdonSharpBehaviour callbackReceiver)
        {
            if (!Utilities.IsValid(callbackReceiver))
                return;

            if (_registeredCallbackReceivers == null)
                _registeredCallbackReceivers = new UdonSharpBehaviour[0];

            int callbackReceiverCount = _registeredControlHandlers.Length;
            for (int i = 0; i < callbackReceiverCount; ++i)
            {
                UdonSharpBehaviour currHandler = _registeredCallbackReceivers[i];

                if (callbackReceiver == currHandler)
                {
                    UdonSharpBehaviour[] newCallbackReceivers = new UdonSharpBehaviour[callbackReceiverCount - 1];

                    for (int j = 0; j < i; ++j)
                        newCallbackReceivers[j] = _registeredCallbackReceivers[j];

                    for (int j = i + 1; j < callbackReceiverCount; ++j)
                        newCallbackReceivers[j - 1] = _registeredCallbackReceivers[j];

                    _registeredCallbackReceivers = newCallbackReceivers;

                    return;
                }
            }
        }

        void SendCallback(string callbackName)
        {
            foreach (UdonSharpBehaviour callbackReceiver in _registeredCallbackReceivers)
            {
                if (Utilities.IsValid(callbackReceiver))
                {
                    callbackReceiver.SendCustomEvent(callbackName);
                }
            }
        }
        #endregion
    }
}