private static void WaitForIsLoaded(ITrack track, CancellationToken cancellationToken)
 {
     while (!track.IsLoaded() || cancellationToken.IsCancellationRequested)
     {
         Task.Delay(250, cancellationToken);
     }
 }

 private static void Reorder(ITrack track)
 {
     for (var i = 0; i < track.MediaItems.Count; i++)
     {
         track.MediaItems[i].Order = i;
     }
 }

 /// <summary>
 /// Sets the interval's track</summary>
 /// <param name="interval">Interval to move to a new track</param>
 /// <param name="newTrack">New track that becomes the owner of this interval,
 /// or null if there is no new owning track</param>
 /// <remarks>
 /// SetTrack DOES NOT by itself set the interval's Track property!
 /// This happens indirectly and only if ITrack is implemented correctly.
 /// 
 /// If the interval and new track are DomNodes AND Intervals are DOM-children of their track,
 /// you can implement the Track property like this:
 /// public ITrack Track { get { return GetParentAs&lt;ITrack>(); } }
 /// 
 /// Otherwise, use an ObservableCollection for your Intervals list,
 /// monitor changes and update the interval's Track property when
 /// intervals are being added to or removed from a Track.
 /// </remarks>
 public static void SetTrack(this IInterval interval, ITrack newTrack)
 {
     ITrack currentTrack = interval.Track;
     if (currentTrack != null)
         currentTrack.Intervals.Remove(interval);
     if (newTrack != null)
         newTrack.Intervals.Add(interval);
 }

        public Track(ITrack track, Dispatcher dispatcher)
        {
            InternalTrack = track;

            _album = new Lazy<Album>(() => new Album(InternalTrack.Album, dispatcher));
            _artists = new Lazy<IEnumerable<Artist>>(() => InternalTrack.Artists.Select(artist => new Artist(artist, dispatcher)));
            _duration = new Lazy<TimeSpan>(() => InternalTrack.Duration);
        }

        public void Update(TimeSpan dt, ITrack track)
        {
            _position += _velocity * dt.TotalSeconds;
            while (_position > track.Length) _position -= track.Length;

            var tmp = PositionUpdated;
            if (tmp != null) tmp(this);
        }

        public Track(ITrack track, Dispatcher dispatcher)
        {
            _dispatcher = dispatcher;
            InternalTrack = track;

            _album = new Lazy<Album>(() => new Album(InternalTrack.Album, _dispatcher));
            _artists = new Lazy<IEnumerable<Artist>>(GetArtists);
            _duration = new Lazy<TimeSpan>(() => InternalTrack.Duration);
        }

        private static object GetIcon(ITrack track)
        {
            //if (track.TargetType == MediaType.AudioMpeg)
            //{
            //    return "pack://application:,,,/Images/File Audio MP3-01.png";
            //}

            return "pack://application:,,,/Images/File Audio-01.png";
        }

        public void PlayOrQueue(ITrack track)
        {
            Append(track);

            if (Index < 0)
            {
                Index = 0;
                Play();
            }
        }

        public override void SongPlay(ITrack track)
        {
            if (_client != null)
            {
                var foundChannel = CurrentServer?.TextChannels.First(d => d.Name == "bot_tests");
                foundChannel.SendMessage("Now Playing: " + track.Name + " by " + track.Artists[0].Name);

                _providerConverted = null;
            }
        }

        public TrackStarted(IRoom room, ITrack track)
        {
            if (room == null)
                throw new ArgumentNullException(nameof(room));
            if (track == null)
                throw new ArgumentNullException(nameof(track));

            TrackId = track.Id;
            RoomId = room.Id;
        }

 public Track(ITrack track)
 {
     Name = track.Name;
     Artists = track.Artists.Select(a => new Artist(a)).ToArray();
     Album = track.Album.Name;
     Length = track.Duration;
     IsAvailable = track.IsAvailable;
     Popularity = track.Popularity;
     IsStarred = track.IsStarred;
 }

 public void AddTrack(ITrack nuTrack)
 {
     // do some checking
     // perhaps the movie needs to get longer!
     if (GetTrackByTrackId(nuTrack.TrackMetaData.TrackId) != null)
     {
         // We already have a track with that trackId. Create a new one
         nuTrack.TrackMetaData.TrackId = GetNextTrackId();
     }
     Tracks.Add(nuTrack);
 }

 public bool Equals(ITrack track)
 {
     iTunesTrack typeTrack = track as iTunesTrack;
     if (typeTrack != null &&
         typeTrack.m_track.TrackDatabaseID == m_track.TrackDatabaseID)
     {
         return true;
     }
     else
     {
         return false;
     }
 }

        private TrackViewModel BuildMediaItemsTimelineTrackViewModel(ITrack track, MediaItemsTimelineViewModel mediaItemsTimelineViewModel)
        {
            var trackViewModel = new TrackViewModel {
                MediaItems = new ObservableCollection<MediaItemViewModel>(),
                Track = track
            };

            trackViewModel.DropHandler = new TrackViewModelDropHandler(trackViewModel);

            CollectionObserver.BindCollection(trackViewModel.MediaItems,
                                              track.MediaItems,
                                              mediaItem => BuildMediaItemsTimelineMediaItemViewModel(mediaItem, mediaItemsTimelineViewModel, trackViewModel));
            return trackViewModel;
        }

 public ITrack TrackSimplifier(ITrack track)
 {
     List<ITrackSegment> simplifiedSegmnet = new List<ITrackSegment>();
     foreach (ITrackSegment segment in track.TrackSegments)
     {
         simplifiedSegmnet.Add(SimplifySegment(segment));
     }
     track.TrackSegments.Clear();
     foreach (ITrackSegment segmnet in simplifiedSegmnet)
     {
         track.TrackSegments.Add(segmnet);
     }
     return track;
 }

		protected String GenerateArguments(String tmpFilePath, ITrack track)
		{
			if (tmpFilePath == null)
			{
				throw new ArgumentNullException("tmpFilePath");
			}

			if (track == null)
			{
				throw new ArgumentNullException("track");
			}

			StringBuilder builder = new StringBuilder();

			PropertyMetaData prop;

			if (track.Args.HasArgument("inputpath"))
			{
				builder.AppendFormat("-i \"{0}\" ", track.Args.ArgumentValue("inputpath"));
			}
			else
			{
				prop = track["INPUTPATH"];
				if (prop != null)
				{
					builder.AppendFormat("-i \"{0}\" ", prop);
				}
			}

			prop = track["TitleChapter"];
			if (prop != null)
			{
				builder.AppendFormat("{0} ", prop);
			}

			builder.AppendFormat("-o \"{0}\" ", tmpFilePath);

			prop = track["HANDBRAKEOPTIONS"];
			if (prop != null)
			{
				builder.Append(prop);
			}

			if (log.IsDebugEnabled)
			{
				log.DebugFormat("HandBrake Options {0}", builder);
			}

			return builder.ToString();
		}

 public double GetAcceleration(Car car, Car next, ITrack track)
 {
     var distance = track.Distance(car, next);
     if (distance < ComfortDistance)
     {
         _targetVelocity = next.Velocity / 2;
     }
     if (distance > ComfortDistance * 5)
     {
         _targetVelocity = _comfortVelocity;
     }
     var a = (_targetVelocity - car.Velocity);
     if (a > MaxAceleration) a = MaxAceleration;
     if (a < -MaxAceleration) a = -MaxAceleration;
     return a;
 }

        public int IndexOf(ITrack track)
        {
            iTunesTrack typeTrack = track as iTunesTrack;
            if (typeTrack == null)
            {
                return -1;
            }

            for (int i = 0; i < m_playlist.Tracks.Count; ++i)
            {
                if (m_playlist.Tracks[i + 1].TrackDatabaseID == typeTrack.InternalTrack.TrackDatabaseID)
                {
                    return i;
                }
            }
            return -1;
        }

		public String GetFileExt(ITrack track)
		{
			if (track == null)
			{
				throw new ArgumentNullException("track");
			}

			var value = track["hbfileext"];
			if (value != null)
			{
				if (log.IsDebugEnabled)
				{
					log.DebugFormat("HandBrake File Extension {0}", value);
				}
				return value;
			}

			value = track["fileext"];
			if (value != null)
			{
				if (log.IsDebugEnabled)
				{
					log.DebugFormat("HandBrake File Extension {0}", value);
				}
				return value;
			}

			value = track["filename"];
			if (value != null)
			{
				FileInfo fi = new FileInfo(value);
				if (log.IsDebugEnabled)
				{
					log.DebugFormat("HandBrake File Extension {0}", fi.Extension);
				}
				return fi.Extension;
			}

			if (log.IsDebugEnabled)
			{
				log.Debug("HandBrake File Extension .mp4");
			}
			return ".mp4";
		}

 public long[] SampleNumbers(ITrack track)
 {
     var segmentStartSamples =new List<long>() {1};
     var sampleDurations = track.SampleDurations;
     var syncSamples = track.SyncSamples;
     long timescale = track.TrackMetaData.Timescale;
     double time = 0;
     for (uint i = 0; i < sampleDurations.Length; i++)
     {
         time += (double)sampleDurations[i] / timescale;
         if (time >= _fragmentLength &&
                 (syncSamples == null || syncSamples.Contains(i+1)))
         {
             if (i > 0)
             {
                 segmentStartSamples.Add(i+1);
             }
             time = 0;
         }
     }
     return segmentStartSamples.ToArray();
 }