j1-template 2024.3.21 → 2024.3.23

data/assets/theme/j1/modules/amplitudejs/js/tech/ytp.js

@@ -6,7 +6,7 @@ regenerate: true
 
 {% comment %}
  # -----------------------------------------------------------------------------
- # ~/assets/theme/j1/modules/amplitudejs/js/plugins/tech/ytp.31.js
+ # ~/assets/theme/j1/modules/amplitudejs/js/plugins/tech/ytp.35.js
  # AmplitudeJS V5 Tech for J1 Template
  #
  # Product/Info:
@@ -60,7 +60,7 @@ regenerate: true
 
 /*
  # -----------------------------------------------------------------------------
- # ~/assets/theme/j1/modules/amplitudejs/js/plugins/tech/ytp.31.js
+ # ~/assets/theme/j1/modules/amplitudejs/js/plugins/tech/ytp.35.js
  # AmplitudeJS V5 Plugin|Tech for J1 Template
  #
  # Product/Info:
@@ -74,6 +74,8 @@ regenerate: true
 */
 "use strict";
 
+  const isDev = (j1.env === "development" || j1.env === "dev") ? true : false;
+
   // date|time monitoring
   //----------------------------------------------------------------------------
   var startTime;
@@ -84,6 +86,21 @@ regenerate: true
 
   // YT API settings
   // ---------------------------------------------------------------------------
+
+  var YT_PLAYER_ERROR = {
+    INVALID_PARAMETER:  2,
+    INVALID_PLAYER:     5,
+    VIDEO_NOT_ALLOWED:  101,
+    VIDEO_NOT_ALLOWED:  150
+  };
+
+  var YT_PLAYER_ERROR_NAMES = {
+    2:          "invalid parameter",
+    5:          "invalid player",
+    101:        "video not allowed",
+    150:        "video not allowed"
+  };
+
   var YT_PLAYER_STATE = {
     UNSTARTED:  -1,
     ENDED:       0,
@@ -115,6 +132,7 @@ regenerate: true
   // ---------------------------------------------------------------------------
   var firstScriptTag;
   var ytPlayer;
+  var ytPlayerErrorTest               = false;
   var ytPlayerReady                   = false;
   var ytApiReady                      = false;
   var logger                          = log4javascript.getLogger('j1.adapter.amplitude.tech');
@@ -161,10 +179,7 @@ regenerate: true
   var playerType;
   var playListTitle;
   var playListName;
-  var amplitudePlayerState;
-
-  var ytPlayer;
-  
+  var amplitudePlayerState; 
   
   var songs;
   var songMetaData;
@@ -211,7 +226,7 @@ regenerate: true
     // fade-in audio (if enabled)
     if (playerFadeAudio) {
       currentVolume = player.getVolume();
-      logger.debug('\n' + `FADE-IN audio on StateChange at trackID|VideoID: ${trackID}|${videoID}`);
+      logger.debug(`FADE-IN audio on StateChange at trackID|VideoID: ${trackID}|${videoID}`);
       ytpFadeInAudio({
         playerID:     playerID,
         targetVolume: currentVolume,
@@ -227,10 +242,12 @@ regenerate: true
   // TODO: 
   // ---------------------------------------------------------------------------
   function processOnVideoEnd(player) {
-    var currentVideoTime,
-        playlist, playerID, songIndex, songs,
+    var currentVideoTime, activeSong,
+        playlist, playerID, songIndex, songs, playlistRepeat,
         trackID, activeVideoID, previousVideoID, isVideoChanged;
 
+    activeSong = getActiveSong();
+
     playlist            = activeVideoElement.playlist;
     playerID            = playlist + '_large';
     currentVideoTime    = player.getCurrentTime();
@@ -239,6 +256,7 @@ regenerate: true
     songIndex           = activeVideoElement.index;
     trackID             = songIndex + 1;
     songs               = activeVideoElement.songs;
+    playlistRepeat      = (songs[songIndex].repeat === 'true') ? true : false;
 
     // check if video is changed (to detect multiple videoIDs in playlist)
     if (songIndex > 0) {
@@ -249,21 +267,34 @@ regenerate: true
 
     // fade-out audio (if enabled)
     if (isVideoChanged && playerFadeAudio) {
-      logger.debug('\n' + `FADE-OUT audio on processOnVideoEnd at trackID|VideoID: ${trackID}|${activeVideoID}`);
+      logger.debug(`FADE-OUT audio on processOnVideoEnd at trackID|VideoID: ${trackID}|${activeVideoID}`);
       ytpFadeOutAudio({
       playerID:     playerID,
       speed:        'default'
       });
     } // END if playerFadeAudio
 
-    // if (!activeVideoElement.audio_single) {
     if (isVideoChanged) {
-      // load next video
-      logger.debug('\n' + `LOAD next VIDEO on processOnVideoEnd at trackID|playlist: ${trackID}|${playlist}`);
-      loadNextVideo(playlist, songIndex);
+      if (songIndex === songs.length - 1) {
+        // LAST index reached, continue on FIRST index
+        songIndex = 0;
+
+        logger.debug(`LOAD first VIDEO on processOnVideoEnd at trackID|playlist: ${trackID}|${playlist}`);
+        loadVideo(playlist, songIndex);
+
+        // check if REPEAT is enabled on PLAYLIST
+        if (!playlistRepeat) {
+          // set FIRST song (video) paused if playing is continued
+          ytPlayer.pauseVideo();
+        } 
+      } else {
+        // load next video
+        logger.debug(`LOAD next VIDEO on processOnVideoEnd at trackID|playlist: ${trackID}|${playlist}`);
+        loadVideo(playlist, songIndex + 1);
+      }
     } else {
-      // skip loading next video if a single video is used for playlist
-      logger.debug('\n' + `LOAD next TRACK in video on processOnVideoEnd at trackID|playlist: ${trackID}|${playlist}`);
+      // skip loading next video if a SINGLE video is used for playlist
+      logger.debug(`LOAD next TRACK in video on processOnVideoEnd at trackID|playlist: ${trackID}|${playlist}`);
     }
 
   } // END processOnVideoEnd  
@@ -275,45 +306,57 @@ regenerate: true
   // ---------------------------------------------------------------------------
   function doNothingOnStateChange(state) {
     if (state > 0) {
-      logger.warn('\n' + `DO NOTHING on StateChange for state: ${YT_PLAYER_STATE_NAMES[state]}`);
+      isDev && logger.warn(`DO NOTHING on StateChange for state: ${YT_PLAYER_STATE_NAMES[state]}`);
     } else {
-      logger.warn('\n' + `DO NOTHING on StateChange for state: ${YT_PLAYER_STATE_NAMES[6]}`);
+      isDev && logger.warn(`DO NOTHING on StateChange for state: ${YT_PLAYER_STATE_NAMES[6]}`);
     }
   } // END doNothingOnStateChange
 
   // ---------------------------------------------------------------------------
   // processOnStateChangePlaying()
   //
-  // wrraper for processing on stae PLAYING 
+  // wrapper for processing players on state PLAYING 
   // ---------------------------------------------------------------------------
   function processOnStateChangePlaying(event, playlist, songIndex) {
-    var activeSong, playlist, playerID, videoID,
-        ytPlayer, songs, songIndex,
-        currentPlayer, previousPlayer, trackID;
-
-    ytPlayer = event.target;
+    var activeSong, activePlaylist,
+        playerID, videoID, firstVideo,
+        ytPlayer, songs, songIndex, previousSongIndex,
+        currentPlayer, previousPlayer,
+        trackID, isSongIndexChanged;
 
-    // update active song settings (manually)
-    checkActiveVideoElementYTP(); 
+    ytPlayer   = event.target;
+    firstVideo = (songIndex > 0) ? false : true;
 
-    // get active song settings (manually)
-    activeSong  = getActiveSong();
-    
-    playlist        = activeSong.playlist;
+    activeSong      = getActiveSong();
+    activePlaylist  = playlist;
     playerID        = activeSong.playerID;
     videoID         = activeSong.videoID;
     songs           = activeSong.songs;
     songIndex       = activeSong.index;
     currentPlayer   = activeSong.player;
     previousPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player
+    trackID         = songIndex + 1;
+
+    logger.debug(`PLAY audio on YT Player at playlist|trackID: ${activePlaylist}|${trackID}`);
 
     // save YT player GLOBAL data for later use (e.g. events)
     j1.adapter.amplitude.data.activePlayer              = 'ytp';
     j1.adapter.amplitude.data.ytpGlobals['activeIndex'] = songIndex;
     j1.adapter.amplitude.data.ytpGlobals['videoID']     = videoID;
 
+
     // save YT player data for later use (e.g. events)
-    j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
+    // -------------------------------------------------------------------------
+    j1.modules.amplitudejs.data.activePlayer = 'ytp';
+    j1.modules.amplitudejs.data.activeIndex = songIndex;
+    j1.modules.amplitudejs.data.activePlaylist = playlist;
+    j1.modules.amplitudejs.data.ytp.activePlayer = ytPlayer;
+    j1.modules.amplitudejs.data.ytp.activeIndex = songIndex;
+    j1.modules.amplitudejs.data.ytp.activePlaylist = playlist;
+    j1.modules.amplitudejs.data.ytp.players[playerID].activeIndex = songIndex;
+    j1.modules.amplitudejs.data.ytp.players[playerID].player = ytPlayer;
+    j1.modules.amplitudejs.data.ytp.players[playerID].videoID = videoID;
+
 
     // update time container for the ACTIVE video
     // -----------------------------------------------------------------
@@ -327,18 +370,18 @@ regenerate: true
       updateProgressBarsYTP();
     }, 500);
 
-    trackID = songIndex + 1;
-    logger.debug('\n' + `PLAY video on StateChange at trackID|VideoID: ${trackID}|${videoID}`);
+    // update meta data
+    ytpUpdatMetaContainers(activeSong);    
 
     // check|process video for configured START position (if set)
     // -------------------------------------------------------------------------
     var songStartSec = activeSong.startSec;
     if (songStartSec) {
-      var tsStartSec      = seconds2timestamp(songStartSec);
+      var tsStartSec      = j1.adapter.amplitude.seconds2timestamp(songStartSec);
       var songCurrentTime = ytPlayer.getCurrentTime();
 
       if (songCurrentTime < songStartSec) {
-        logger.debug('\n' + `START video on StateChange at trackID|timestamp: ${trackID}|${tsStartSec}`);
+        logger.debug(`START video on StateChange at trackID|timestamp: ${trackID}|${tsStartSec}`);
         processOnVideoStart(ytPlayer, songStartSec);
       }
     } // END if songStartEnabled
@@ -347,13 +390,13 @@ regenerate: true
     // -------------------------------------------------------------------------
     var songEndSec = activeSong.endSec;
     if (songEndSec) {
-      var tsEndSec = seconds2timestamp(songEndSec);
+      var tsEndSec = j1.adapter.amplitude.seconds2timestamp(songEndSec);
 
       var checkOnVideoEnd = setInterval(function() {
         var songCurrentTime = ytPlayer.getCurrentTime();
 
         if (songCurrentTime >= songEndSec) {
-          logger.debug('\n' + `STOP video on StateChange at trackID|timestamp: ${trackID}|${tsEndSec}`);
+          logger.debug(`STOP video on StateChange at trackID|timestamp: ${trackID}|${tsEndSec}`);
           processOnVideoEnd(ytPlayer);
 
           clearInterval(checkOnVideoEnd);
@@ -361,83 +404,99 @@ regenerate: true
       }, 500); // END checkOnVideoEnd
     } // END if songEndEnabled
 
-    // stop active AT players running in parallel
-    // -------------------------------------------------------------------------
-    var atpPlayerState = Amplitude.getPlayerState();
-    if (atpPlayerState === 'playing') {
-      Amplitude.stop();
+    // stop active AT|YT players running in parallel except the current
+    ytpStopParallelActivePlayers(playerID);
 
-      // clear button MINI PlayerPlayPause (AT player)
-      var buttonPlayerPlayPauseMini = document.getElementsByClassName("mini-player-play-pause");
-      for (var i=0; i<buttonPlayerPlayPauseMini.length; i++) {
-        var htmlElement = buttonPlayerPlayPauseMini[i];
-        
-        if (htmlElement.dataset.amplitudeSource === 'audio') {
+    // clear button MINI PlayerPlayPause (AT player)
+    var buttonPlayerPlayPauseMini = document.getElementsByClassName("mini-player-play-pause");
+    for (var i=0; i<buttonPlayerPlayPauseMini.length; i++) {
+      var htmlElement = buttonPlayerPlayPauseMini[i];
+
+      // toggle classes on state playing
+      if (htmlElement.dataset.amplitudeSource === 'audio') {
+        if (htmlElement.classList.contains('amplitude-playing')) {        
           htmlElement.classList.remove('amplitude-playing');
           htmlElement.classList.add('amplitude-paused');
         }
-    
-      } // END for MINI buttonPlayerPlayPause
-
-      // clear button COMPACT PlayerPlayPause (AT player)
-      var buttonPlayerPlayPauseCompact = document.getElementsByClassName("compact-player-play-pause");
-      for (var i=0; i<buttonPlayerPlayPauseCompact.length; i++) {
-        var htmlElement = buttonPlayerPlayPauseCompact[i];
-        
-        if (htmlElement.dataset.amplitudeSource === 'audio') {
+      }
+  
+    } // END for MINI buttonPlayerPlayPause
+
+    // clear button COMPACT PlayerPlayPause (AT player)
+    var buttonPlayerPlayPauseCompact = document.getElementsByClassName("compact-player-play-pause");
+    for (var i=0; i<buttonPlayerPlayPauseCompact.length; i++) {
+      var htmlElement = buttonPlayerPlayPauseCompact[i];
+      
+      // toggle classes on state playing
+      if (htmlElement.dataset.amplitudeSource === 'audio') {
+        if (htmlElement.classList.contains('amplitude-playing')) {
           htmlElement.classList.remove('amplitude-playing');
           htmlElement.classList.add('amplitude-paused');
         }
-    
-      } // END for COMACT buttonPlayerPlayPause
+      }
+  
+    } // END for COMACT buttonPlayerPlayPause
 
-      // clear button LARGE PlayerPlayPause (AT player)
-      var buttonPlayerPlayPauseLarge = document.getElementsByClassName("large-player-play-pause");
-      for (var i=0; i<buttonPlayerPlayPauseLarge.length; i++) {
-        var htmlElement = buttonPlayerPlayPauseLarge[i];
-        
-        if (htmlElement.dataset.amplitudeSource === 'audio') {
+    // clear button LARGE PlayerPlayPause (AT player)
+    var buttonPlayerPlayPauseLarge = document.getElementsByClassName("large-player-play-pause");
+    for (var i=0; i<buttonPlayerPlayPauseLarge.length; i++) {
+      var htmlElement = buttonPlayerPlayPauseLarge[i];
+
+      // toggle classes on state playing
+      if (htmlElement.dataset.amplitudeSource === 'audio') {
+        if (htmlElement.classList.contains('amplitude-playing')) {
           htmlElement.classList.remove('amplitude-playing');
           htmlElement.classList.add('amplitude-paused');
         }
+      }
 
-      } // END for LARGE buttonPlayerPlayPause
-
-    } // END if atpPlayerState 'playing' 
-
-    // TODO: check if YT player stop is needed
-    // -------------------------------------------------------------------------
-    // stop active YT players running in parallel except the current
-    // if (previousPlayer.options.videoId !== videoID) {
-    //   logger.debug('\n' + `STOP all video on StateChange running in parallel at trackID|playerID: ${trackID}|${playerID}`);
-    //   var playerState   = (previousPlayer.getPlayerState() > 0) ? previousPlayer.getPlayerState() : 6;
-    //   var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
-    //
-    //   if (ytPlayerState === 'playing' || ytPlayerState === 'paused') {
-    //     previousPlayer.stopVideo();
-    //   }      
-    // }
-    //
-    // stopAllActivePlayers(playerID);
+    } // END for LARGE buttonPlayerPlayPause
 
   } // END processOnStateChangePlaying
 
-
   // ---------------------------------------------------------------------------
   // processOnStateChangeEnded()
   //
   // ---------------------------------------------------------------------------
   function processOnStateChangeEnded(event, playlist, songIndex) {
-    var videoID = event.target.options.videoId;
-    var trackID = songIndex + 1;
+    var videoID         = event.target.options.videoId;
+    var trackID         = songIndex + 1;
+    var playerID        = playlist + '_large';
+    var songs           = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
+    var songMetaData    = songs[songIndex];
+    var playlistRepeat  = (songMetaData.repeat === 'true') ? true : false;
+ 
+    if (songIndex === songs.length - 1) {
+      // LAST index reached, continue on FIRST index
+      songIndex = 0;
+
+      // save player current time data for later use
+      // ytPlayerCurrentTime = ytPlayer.getCurrentTime();
 
-    // save player current time data for later use
-    ytPlayerCurrentTime = ytPlayer.getCurrentTime();
+      // save YT player data for later use (e.g. events)
+      // ---------------------------------------------------------------------
+      j1.modules.amplitudejs.data.ytp.previousIndex = songIndex;  
+
+      logger.debug(`LOAD first VIDEO on processOnStateChangeEnded at trackID|playlist: ${trackID}|${playlist}`);
+      loadVideo(playlist, songIndex);
+
+      // check if REPEAT is enabled on PLAYLIST
+      if (!playlistRepeat) {
+        // set FIRST song (video) paused if playing is continued
+        ytPlayer.pauseVideo();
+      } 
+    } else {
+      // save player current time data for later use
+      // ytPlayerCurrentTime = ytPlayer.getCurrentTime();
 
-    logger.debug('\n' + `NEXT video on StateChange at trackID|VideoID: ${trackID}|${videoID}`);
+      // save YT player data for later use (e.g. events)
+      // ---------------------------------------------------------------------
+      j1.modules.amplitudejs.data.ytp.previousIndex = songIndex;        
 
-    // load NEXT song (video) in playlist
-    loadNextVideo(playlist, songIndex);
+      // load next video
+      logger.debug(`LOAD next VIDEO on processOnStateChangeEnded at trackID|playlist: ${trackID}|${playlist}`);
+      loadVideo(playlist, songIndex + 1);
+    }
 
   } // END processOnStateChangeEnded
 
@@ -521,50 +580,6 @@ regenerate: true
     current[lastKey] = value;
   }
 
-  // ---------------------------------------------------------------------------
-  // timestamp2seconds
-  // ---------------------------------------------------------------------------
-  function timestamp2seconds(timestamp) {
-    // split timestamp
-    const parts = timestamp.split(':');
-
-    // check timestamp format
-    if (parts.length !== 3) {
-      // return "invalid timestamp";
-      return false;
-    }
-
-    // convert parts to integers
-    const hours   = parseInt(parts[0], 10);
-    const minutes = parseInt(parts[1], 10);
-    const seconds = parseInt(parts[2], 10);
-
-    // check valid timestamp values
-    if (isNaN(hours) || isNaN(minutes) || isNaN(seconds) ||
-        hours   < 0 || hours   > 23 ||
-        minutes < 0 || minutes > 59 ||
-        seconds < 0 || seconds > 59) {
-      return "invalid timestamp";
-    }
-
-    const totalSeconds = (hours * 3600) + (minutes * 60) + seconds;
-    return totalSeconds;
-  } // END timestamp2seconds
-
-  // ---------------------------------------------------------------------------
-  // seconds2timestamp
-  // ---------------------------------------------------------------------------
-  function seconds2timestamp(seconds) {
-    const hours         = Math.floor(seconds / 3600);
-    const minutes       = Math.floor((seconds % 3600) / 60);
-    const remainSeconds = seconds % 60;
-    const tsHours       = hours.toString().padStart(2, '0');
-    const tsMinutes     = minutes.toString().padStart(2, '0');
-    const tsSeconds     = remainSeconds.toString().padStart(2, '0');
-  
-    return `${tsHours}:${tsMinutes}:${tsSeconds}`;
-  } // END seconds2timestamp
-
   // ---------------------------------------------------------------------------
   // ytpFadeInAudio
   // ---------------------------------------------------------------------------
@@ -584,7 +599,7 @@ regenerate: true
     // transition will be
     const iterationSteps = {
       'default':  150,
-      'slow': 	  250,
+      'slow':     250,
       'slower':   350,
       'slowest':  500
     };
@@ -595,18 +610,10 @@ regenerate: true
     currentStep   = 1;
 
     if (volumeSlider === undefined || volumeSlider === null) {
-      logger.warn('\n' + 'no volume slider found at playerID: ' + settings.playerID);
+      isDev && logger.warn('no volume slider found at playerID: ' + settings.playerID);
       return;
     }
 
-    // (ytPlayer.isMuted()) && ytPlayer.unMute();
-
-    // skip fade-in when volume is already at target value
-    // if (ytPlayer.getVolume() >= targetVolume) {
-    //   logger.warn('\n' + 'skipped fade-in for current video on volume: ', targetVolume);
-    //   return;
-    // }
-
     // Start the players volume muted
     ytPlayer.setVolume(0);
 
@@ -639,7 +646,7 @@ regenerate: true
     // number of iteration steps to DECREASE the volume
     const iterationSteps = {
       'default':  150,
-      'slow': 	  250,
+      'slow':     250,
       'slower':   350,
       'slowest':  500
     };
@@ -651,7 +658,7 @@ regenerate: true
     currentStep   = 0;
 
     if (volumeSlider === undefined || volumeSlider === null) {
-      logger.warn('\n' + 'no volume slider found at playerID: ' + settings.playerID);
+      isDev && logger.warn('no volume slider found at playerID: ' + settings.playerID);
       return;
     }
 
@@ -675,7 +682,7 @@ regenerate: true
   function initYtAPI() {
     startTimeModule = Date.now();
 
-    logger.info('\n' + 'Initialize plugin|tech (ytp) : started');
+    logger.info('Initialize plugin|tech (ytp) : started');
 
     // Load YT IFrame Player API asynchronously
     // -------------------------------------------------------------------------
@@ -687,46 +694,47 @@ regenerate: true
   }
 
   // ---------------------------------------------------------------------------
-  // loadNextVideo(list, index)
+  // loadVideo(list, index)
   //
   // load next video in playlist
   // ---------------------------------------------------------------------------
-  function loadNextVideo(currentPlaylist, currentIndex) {
-    var activeSongSettings, trackID, songName, playlist, playerID, playerIFrame,
-        songs, songIndex, songMetaData, songURL, ytpVideoID;
-
-    // update active song settings (manually)
-    checkActiveVideoElementYTP();   
-
-    // get active song settings (manually)
-    activeSongSettings = getActiveSong();  
-
-    playlist    = currentPlaylist;
-    playerID    = playlist + '_large';
-    songs       = activeSongSettings.songs;
-    ytPlayer    = activeSongSettings.player;
-    songIndex   = currentIndex;
-    trackID     = songIndex + 1;
-
-    songIndex++;
+  function loadVideo(currentPlaylist, currentIndex) {
+    var activeSong, trackID, songName,
+        playlist, playerID, playerIFrame,
+        songs, songIndex, songMetaData, songURL,
+        ytpVideoID, firstVideo, playlistRepeat;
 
-    ytpSongIndex  = songIndex;
+    activeSong      = getActiveSong();
+    playlist        = currentPlaylist;
+    playerID        = playlist + '_large';
+    songs           = activeSong.songs;
+    playlistRepeat  = (songs[currentIndex].repeat === 'true') ? true : false;
+    ytPlayer        = activeSong.player;
+    songIndex       = currentIndex;
+    trackID         = songIndex + 1;
     
-
-    // play sonng (video) in playlist 
+    // switch|play to songIndex in playlist
     if (songIndex <= songs.length - 1) {
       songMetaData  = songs[songIndex];
       songURL       = songMetaData.url;
-      ytVideoID     = songURL.split('=')[1];
+      ytpVideoID    = songURL.split('=')[1];
 
       // save YT player data for later use (e.g. events)
       j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
-      j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytVideoID;      
+      j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID;
 
 
-      logger.debug('\n' + `SWITCH video on loadNextVideo at trackID|VideoID: ${trackID}|${ytVideoID}`);
-      ytPlayer.loadVideoById(ytVideoID);
+      // save YT player data for later use (e.g. events)
+      // -----------------------------------------------------------------------
+      j1.modules.amplitudejs.data.ytp.previousSongIndex = songIndex;
+      j1.modules.amplitudejs.data.ytp.players[playerID].activeIndex = songIndex;
+      j1.modules.amplitudejs.data.ytp.players[playerID].previousIndex = songIndex - 1;
+      j1.modules.amplitudejs.data.ytp.players[playerID].videoID = ytpVideoID;
 
+
+      logger.debug(`SWITCH video on loadNextVideo at trackID|VideoID: ${trackID}|${ytpVideoID}`);
+      ytPlayer.loadVideoById(ytpVideoID);
+     
       // delay after switch video
       if (muteAfterVideoSwitchInterval) {
         ytPlayer.mute();
@@ -735,14 +743,16 @@ regenerate: true
         }, muteAfterVideoSwitchInterval);
       }
 
-      // update global song index
+      // save YT player data for later use (e.g. events)
+      // -----------------------------------------------------------------------
       ytpSongIndex = songIndex;
+      j1.modules.amplitudejs.data.ytp.songIndex = songIndex;
 
       // load the song cover image
       loadCoverImage(songMetaData);
 
       // update meta data
-      updatMetaContainers(songMetaData);
+      // ytpUpdatMetaContainers(songMetaData);
   
       // set song (video) active at index in playlist
       setSongActive(playlist, songIndex);
@@ -754,62 +764,10 @@ regenerate: true
       if (playerAutoScrollSongElement) {
         scrollToActiveElement(playlist);
       }
-    } else {
-      // continue on FIRST track (video) in playlist
-      //
-      songIndex         = 0;
-      var songMetaData  = songs[songIndex];
-      var songURL       = songMetaData.url;
-      var ytVideoID     = songURL.split('=')[1];
-
-      // update global song index
-      ytpSongIndex = songIndex;
-
-      // load next video (paused)
-      // -----------------------------------------------------------------------
-
-      // save YT player data for later use (e.g. events)
-      j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
-      j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID; 
 
-      logger.debug('\n' + `SWITCH video on loadNextVideo at trackID|VideoID: ${trackID}|${ytVideoID}`);
-      ytPlayer.loadVideoById(ytVideoID);
+    } // END if songIndex
 
-      // delay after switch video
-      if (muteAfterVideoSwitchInterval) {
-        ytPlayer.mute();
-        setTimeout(() => {
-          ytPlayer.unMute();
-        }, muteAfterVideoSwitchInterval);
-      }
-
-      // load the song cover image
-      loadCoverImage(songMetaData);
-  
-      // update meta data
-      updatMetaContainers(songMetaData);
-  
-      // set AJS play_pause button paused
-      var playPauseButtonClass = `large-player-play-pause-${playerID}`
-      setPlayPauseButtonPaused(playPauseButtonClass);
-
-      // set song (video) active at index in playlist
-      setSongActive(playlist, songIndex);
-
-      // reset progress bar settings
-      resetProgressBarYTP();
-
-      // scroll song active at index in player
-      if (playerAutoScrollSongElement) {
-        scrollToActiveElement(playlist);
-      }
-
-      // TODO: check if SHUFFLE is enabled on PLAYLIST (PLAYER ???)
-      // set FIRST song (video) paused
-      ytPlayer.pauseVideo();
-    }
-
-  } // END loadVideo
+  } // END loadNextVideo
 
   // ---------------------------------------------------------------------------
   // initUiEventsForAJS
@@ -840,7 +798,7 @@ regenerate: true
         {% endif %}{% endfor %}
 
         clearInterval(dependencies_ytp_ready);
-        logger.info('\n' + 'Initialize APIPlayers : ready');
+        logger.info('Initialize APIPlayers : ready');
       } // END if ready
 
     }, 10); // END dependencies_ytp_ready
@@ -881,21 +839,21 @@ regenerate: true
 
           // load individual player settings (to manage multiple players in page)
           //
-          var ytpVideoID  = activeSongMetadata.url.split('=')[1];
           var ytpAutoPlay = ('{{player.yt_player.autoplay}}'.length > 0) ? '{{player.yt_player.autoplay}}'  : '{{amplitude_defaults.player.yt_player.autoplay}}';
           var ytpLoop     = ('{{player.yt_player.loop}}'.length > 0)     ? '{{player.yt_player.loop}}'      : '{{amplitude_defaults.player.yt_player.loop}}';
           var ytpHeight   = ('{{player.yt_player.height}}'.length > 0)   ? '{{player.yt_player.height}}'    : '{{amplitude_defaults.player.yt_player.height}}';
           var ytpWidth    = ('{{player.yt_player.width}}'.length > 0)    ? '{{player.yt_player.width}}'     : '{{amplitude_defaults.player.yt_player.width}}';
 
-          logger.info('\n' + 'AJS YouTube iFrame API: ready');
-          logger.info('\n' + 'configure player on ID: #{{player.id}}');
+          logger.info('AJS YouTube iFrame API: ready');
+          logger.info('configure player on ID: #{{player.id}}');
 
-          // create a hidden YT Player iFrame container
+          // create a (hidden) ytp iframe container
           //
           ytpContainer                = document.getElementById('{{player.id}}_video');
           ytpContainer.innerHTML      = '<div id="iframe_{{player.id}}"></div>';
           ytpContainer.style.cssText  = 'display:none';
 
+          var ytpVideoID = (ytPlayerErrorTest) ? 'invalidVideoID' : activeSongMetadata.url.split('=')[1];
           ytPlayer = new YT.Player('iframe_{{player.id}}', {
             height:             ytpHeight,
             width:              ytpWidth,
@@ -905,8 +863,9 @@ regenerate: true
               loop:             ytpLoop
             },
             events: {
-              'onReady':                  {{player.id}}OnPlayerReady,
-              'onStateChange':            {{player.id}}OnPlayerStateChange
+              'onReady':        {{player.id}}OnPlayerReady,
+              'onStateChange':  {{player.id}}OnPlayerStateChange,
+              'onError':        {{player.id}}OnPlayerErrors
             }
           });
 
@@ -931,25 +890,41 @@ regenerate: true
 
           // save YT player GLOBAL data for later use (e.g. events)
           j1.adapter.amplitude.data.ytpGlobals['ytApiReady'] = ytApiReady;
-          
+
+
+          // save amplitudejs data for later use (e.g. events)
+          // -------------------------------------------------------------------
+          j1.modules.amplitudejs.data.ytp.apiReady = ytApiReady;
+
+
           // reset current player
           playerExistsInPage = false;
 
         } // END if playerExistsInPage()
 
-        function checkPlayingStatus(player) {
-          if (player.getPlayerState() === YT_PLAYER_STATE.PLAYING) {
-            // code run after video is playing
-            // console.debug("checkPlayingStatus: AJS YouTube Player state: PLAYING");
-            // do nothing
-            return;
-          } else {
-            // re-check player state required
-            // console.debug("checkPlayingStatus: AJS YouTube Player state:", player.getPlayerState());
-          }
-        } // END checkPlayingStatus
+        // AJS YouTube Player errors fired by the YT API
+        // ---------------------------------------------------------------------
+        function {{player.id}}OnPlayerErrors(event) {
+          var eventData, ytPlayer, videoID;
+
+          eventData = event.data;
+          ytPlayer  = event.target;
+          videoID   = ytPlayer.options.videoId;
+
+          logger.error(`YT API Error '${YT_PLAYER_ERROR_NAMES[eventData]}' for VideoID: '${videoID}'`);
+
+          // save YT player GLOBAL data for later use (e.g. events)
+          j1.adapter.amplitude.data.ytpGlobals['ytApiError'] = eventData;
+
+
+          // save amplitudejs data for later use (e.g. events)
+          // ------------------------------------------------------------------
+          j1.modules.amplitudejs.data.ytp.apiError = eventData;
 
-        // run AJS YouTube Player initialization
+
+        }
+
+        // AJS YouTube Player initialization fired by the YT API
         // ---------------------------------------------------------------------
         function {{player.id}}OnPlayerReady(event) {
           var hours, minutes, seconds,
@@ -960,7 +935,7 @@ regenerate: true
           ytPlayerReady       = true;
           playerVolumePreset  = parseInt({{player.volume_slider.preset_value}});
 
-            logger.debug('\n' + `FOUND video ready at ID: {{player.id}}`);
+          logger.debug(`FOUND video ready at ID: {{player.id}}`);
 
           // set video playback quality to a minimum
           ytPlayer.setPlaybackQuality('small');
@@ -985,13 +960,19 @@ regenerate: true
             }
           }
 
-          logger.info('\n' + 'AJS YouTube Player on ID {{player.id}}: ready');
+          logger.info('yt player on ID {{player.id}}: ready');
 
           // save YT player GLOBAL data for later use (e.g. events)
           j1.adapter.amplitude.data.ytpGlobals['ytPlayerReady'] = ytPlayerReady;
+          j1.adapter.amplitude.data.ytpGlobals['ytApiError']    = 0;          
+
+
+          // save amplitudejs data for later use (e.g. events)
+          // -------------------------------------------------------------------
+          j1.modules.amplitudejs.data.ytp.apiError = 0;
+          j1.modules.amplitudejs.data.ytp.players.{{player.id}} = {};
+          j1.modules.amplitudejs.data.ytp.players.{{player.id}}.playerReady = ytPlayerReady;
 
-          // save YT player data for later use (e.g. events)
-          // j1.adapter.amplitude.data.ytPlayers.{{player.id}}.playerReady = ytPlayerReady;
 
           // get duration hours (if configured)
           if ({{player.display_hours}} ) {
@@ -1023,12 +1004,12 @@ regenerate: true
           // -------------------------------------------------------------------
           endTimeModule = Date.now();
 
-          logger.info('\n' + 'Initialize plugin|tech (ytp) : finished');
+          logger.info('Initialize plugin|tech (ytp) : finished');
 
           if (playerCounter > 0) {
-            logger.info('\n' + 'Found players of type video (YTP) in page: ' + playerCounter);
+            logger.info('Found players of type video (YTP) in page: ' + playerCounter);
           } else {
-            logger.warn('\n' + 'Found NO players of type video (YTP) in page');
+            isDev && logger.warn('Found NO players of type video (YTP) in page');
           }
 
           // update activeVideoElement data structure for the ACTIVE video
@@ -1038,7 +1019,7 @@ regenerate: true
           }, checkActiveVideoInterval);
           // END checkActiveVideoElementYTP
 
-          logger.info('\n' + 'plugin|tech initializing time: ' + (endTimeModule-startTimeModule) + 'ms');
+          logger.info('plugin|tech initializing time: ' + (endTimeModule-startTimeModule) + 'ms');
 
         } // END onPlayerReady()
 
@@ -1053,6 +1034,8 @@ regenerate: true
         // are being set; e.g. start|stop positions for a video (when)
         // configured.
         // ---------------------------------------------------------------------
+        // AJS YouTube Player state changes fired by the YT API
+        // ---------------------------------------------------------------------
         function {{player.id}}OnPlayerStateChange(event) {
           var currentTime, playlist, ytPlayer, ytVideoID,
               songs, songIndex, trackID, playerID, songMetaData;
@@ -1076,6 +1059,19 @@ regenerate: true
           j1.adapter.amplitude.data.ytPlayers.{{player.id}}.player      = ytPlayer;
           j1.adapter.amplitude.data.ytPlayers.{{player.id}}.activeIndex = songIndex;
 
+
+          // save amplitudejs data for later use (e.g. events)
+          // -------------------------------------------------------------------
+          j1.modules.amplitudejs.data.activePlayer = 'ytp';
+          j1.modules.amplitudejs.data.activeIndex = songIndex;
+          j1.modules.amplitudejs.data.activePlaylist = playlist;          
+          j1.modules.amplitudejs.data.ytp.activePlayer = ytPlayer;
+          j1.modules.amplitudejs.data.ytp.activeIndex = songIndex;
+          j1.modules.amplitudejs.data.ytp.activePlaylist = playlist;
+          j1.modules.amplitudejs.data.ytp.players.{{player.id}}.player = ytPlayer;
+          j1.modules.amplitudejs.data.ytp.players.{{player.id}}.activeIndex = songIndex;
+
+
           // reset time container|progressbar for the ACTIVE song (video)
           // -------------------------------------------------------------------          
           resetCurrentTimeContainerYTP(ytPlayer, playlist);
@@ -1104,7 +1100,7 @@ regenerate: true
               processOnStateChangeEnded(event, playlist, songIndex);
               break;
             default:
-              logger.error('\n' + `UNKNOWN event on StateChange fired: ${event.data}`);
+              logger.error(`UNKNOWN event on StateChange fired: ${event.data}`);
           } // END switch event.data
 
         } // END {{player.id}}OnPlayerStateChange
@@ -1114,7 +1110,6 @@ regenerate: true
 
   } // END onYouTubeIframeAPIReady
 
-
   // ---------------------------------------------------------------------------
   // main
   // ===========================================================================
@@ -1126,6 +1121,13 @@ regenerate: true
   // ---------------------------------------------------------------------------
   initYtAPI();
 
+  // save YT player data for later use (e.g. events)
+  // ---------------------------------------------------------------------
+  var url = '//youtube.com/iframe_api'
+  if (document.querySelectorAll(`script[src="${url}"]`).length > 0) {
+    j1.modules.amplitudejs.data.ytp.plugin = 'loaded';
+  }
+
   // ---------------------------------------------------------------------------
   // initUiEventsForAJS
   //
@@ -1133,28 +1135,27 @@ regenerate: true
   // ---------------------------------------------------------------------------
   initUiEventsForAJS();
 
-
   // ---------------------------------------------------------------------------
   // Base AJS Player functions
   // ===========================================================================
   
   // ---------------------------------------------------------------------------
-  // updatMetaContainers(metaData)
+  // ytpUpdatMetaContainers(metaData)
   //
   // update song name in meta-containers
   // ---------------------------------------------------------------------------  
-  function updatMetaContainers(metaData) {
-    var playerID, playlist, songName, artistName, albumName,
-        largePlayerSongAudioRating;
+  function ytpUpdatMetaContainers(metaData) {
+    var playerID, playlist, trackID, rating;
 
-    playlist = metaData.playlist;
-    playerID = playlist + '_large';
+    playlist  = metaData.playlist;
+    playerID  = playlist + '_large';
+    rating    = metaData.rating;
+    trackID   = metaData.index + 1;
 
-    var trackID = metaData.index + 1;
-    logger.debug('\n' + `UPDATE metadata on updatMetaContainers for trackID|playlist at: ${trackID}|${playlist}`);
+    logger.debug(`UPDATE metadata on ytpUpdatMetaContainers for trackID|playlist at: ${trackID}|${playlist}`);
 
     // update song name in meta-containers
-    songName = document.getElementsByClassName("song-name");
+    var songName = document.getElementsByClassName("song-name");
     if (songName.length) {
       for (var i=0; i<songName.length; i++) {    
         var currentPlaylist = songName[i].dataset.amplitudePlaylist;
@@ -1165,10 +1166,10 @@ regenerate: true
     }
 
     // update artist name in meta-containers
-    artistName = document.getElementsByClassName("artist");
+    var artistName = document.getElementsByClassName("artist");
     if (artistName.length) {
       for (var i=0; i<artistName.length; i++) {    
-        var currentPlaylist = songName[i].dataset.amplitudePlaylist;
+        var currentPlaylist = artistName[i].dataset.amplitudePlaylist;
         if (currentPlaylist === playlist) {
           artistName[i].innerHTML = metaData.artist;
         }
@@ -1176,7 +1177,7 @@ regenerate: true
     }
 
     // update album name in meta-containers
-    albumName = document.getElementsByClassName("album");
+    var albumName = document.getElementsByClassName("album");
     if (albumName.length) {
       for (var i=0; i<albumName.length; i++) {    
         var currentPlaylist = songName[i].dataset.amplitudePlaylist;
@@ -1187,27 +1188,32 @@ regenerate: true
     }
 
     // update song rating in screen controls
-    largePlayerSongAudioRating = document.getElementsByClassName("audio-rating-screen-controls");
-    if (largePlayerSongAudioRating.length) {
-      for (var i=0; i<largePlayerSongAudioRating.length; i++) {
-        var currentPlaylist = largePlayerSongAudioRating[i].dataset.amplitudePlaylist;
+    var songAudioRating = document.getElementsByClassName("audio-rating-screen-controls");
+    if (songAudioRating.length) {
+      for (var i=0; i<songAudioRating.length; i++) {
+        var currentPlaylist = songAudioRating[i].dataset.amplitudePlaylist;
         if (currentPlaylist === playlist) {
           if (metaData.rating) {
-            var trackID = metaData.index + 1;
-
-            // save YT player data for later use (e.g. events)
-            j1.adapter.amplitude.data.ytPlayers[playerID].videoID = metaData.videoID;
+            songAudioRating[i].innerHTML = `<img src="/assets/image/pattern/rating/scalable/${metaData.rating}-star.svg" alt="song rating">`;
+          }
+        }
+      }
+    } // END if songAudioRating
 
-            logger.debug('\n' + `UPDATE song rating on updatMetaContainers for trackID|playlist at: ${trackID}|${playlist} with a value of: ${metaData.rating}`);
-            largePlayerSongAudioRating[i].innerHTML = '<img src="/assets/image/pattern/rating/scalable/' + metaData.rating + '-star.svg"' + 'alt="song rating">';
-          } else {
-            largePlayerSongAudioRating[i].innerHTML = '';
+    // update song info in screen controls
+    var songAudioInfo = document.getElementsByClassName("audio-info-link-screen-controls");
+    if (songAudioInfo.length) {
+      for (var i=0; i<songAudioInfo.length; i++) {
+        var currentPlaylist = songAudioInfo[i].dataset.amplitudePlaylist;
+        if (currentPlaylist === playlist) {
+          if (metaData.audio_info) {
+            songAudioInfo[i].setAttribute("href", metaData.audio_info);
           }
         }
       }
-    } // END if largePlayerSongAudioRating
+    } // END if songAudioInfo
 
-  } // END updatMetaContainers
+  } // END ytpUpdatMetaContainers
 
   // ---------------------------------------------------------------------------
   // loadCoverImage(metaData)
@@ -1221,46 +1227,68 @@ regenerate: true
     selector       = ".cover-image-" + metaData.playlist;
     coverImage     = document.querySelector(selector);
     coverImage.src = metaData.cover_art_url;
+
   } // END loadCoverImage
 
   // ---------------------------------------------------------------------------
-  // stopAllActivePlayers(exceptPlayer)
+  // ytpStopParallelActivePlayers(exceptPlayer)
   //
   // if multiple players used on a page, stop ALL active AT|YT players
-  // running in parallel execpet the exceptPlayer
+  // running in parallel skipping the exceptPlayer
   // ---------------------------------------------------------------------------  
-  function stopAllActivePlayers(exceptPlayer) {
+  function ytpStopParallelActivePlayers(exceptPlayer) {
 
-    // stop active AT players
+    // stop active AT players running in parallel
     // -------------------------------------------------------------------------
-    var atpPlayerState = Amplitude.getPlayerState();
-    if (atpPlayerState === 'playing') {
+    var atPlayerState = Amplitude.getPlayerState();
+    if (atPlayerState === 'playing' || atPlayerState === 'paused') {
       Amplitude.stop();
     } // END stop active AT players
 
-    // stop active YT players
+    // stop active YT players running in parallel
     // -------------------------------------------------------------------------
     const ytPlayers = Object.keys(j1.adapter.amplitude.data.ytPlayers);
     for (let i=0; i<ytPlayers.length; i++) {
-      const ytPlayerID = ytPlayers[i];
-      const playerProperties = j1.adapter.amplitude.data.ytPlayers[ytPlayerID];
+      const ytPlayerID        = ytPlayers[i];
+      const playerProperties  = j1.adapter.amplitude.data.ytPlayers[ytPlayerID];
 
       if (ytPlayerID !== exceptPlayer) {    
         var player        = j1.adapter.amplitude['data']['ytPlayers'][ytPlayerID]['player'];
         var playerState   = (player.getPlayerState() > 0) ? player.getPlayerState() : 6;
         var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
 
-        // if (ytPlayerState === 'playing' || ytPlayerState === 'paused' || ytPlayerState === 'buffering' || ytPlayerState === 'cued' || ytPlayerState === 'unstarted') {
-        if (ytPlayerState === 'playing' || ytPlayerState === 'paused' || ytPlayerState === 'buffering' || ytPlayerState === 'cued' || ytPlayerState === 'unstarted') {
-          logger.debug('\n' + `STOP player at stopAllActivePlayers for id: ${ytPlayerID}`);
-          // player.mute();
+        // toggle PlayPause buttons playing => puased
+        // ---------------------------------------------------------------------
+        var isValidPlayerState = /playing|paused/.test(ytPlayerState);
+        if (isValidPlayerState) {
+          logger.debug(`STOP player at ytpStopParallelActivePlayers for id: ${ytPlayerID}`);
           player.stopVideo();
-          j1.adapter.amplitude.data.ytpGlobals.activeIndex = 0;
-        }
-      }
-    } // END stop active YT players
+          var ytpButtonPlayerPlayPause = document.getElementsByClassName("large-player-play-pause-" + ytPlayerID);
+          for (var j=0; j<ytpButtonPlayerPlayPause.length; j++) {
+
+            var htmlElement = ytpButtonPlayerPlayPause[j];
+            if (htmlElement.dataset.amplitudeSource === 'youtube') {
+              if (htmlElement.classList.contains('amplitude-playing')) {        
+                htmlElement.classList.remove('amplitude-playing');
+                htmlElement.classList.add('amplitude-paused');
+              }
+              // if (htmlElement.classList.contains('amplitude-paused')) {        
+              //   htmlElement.classList.remove('amplitude-paused');
+              //   htmlElement.classList.add('amplitude-playing');
+              // }              
+            }
+
+          } // END for ytpButtonPlayerPlayPause
+
+        } // END if ytPlayerState
+      } // END if ytPlayerID
 
-  } // END stopAllActivePlayers
+      // save AT player data for later use (e.g. events)
+      // ---------------------------------------------------------------------
+      j1.adapter.amplitude.data.ytpGlobals.activeIndex = 0;
+
+    } // END stop active YT players
+  } // END ytpStopParallelActivePlayers
 
   // ---------------------------------------------------------------------------
   // getSongPlayed
@@ -1313,7 +1341,7 @@ regenerate: true
       }
     }
 
-  } // END setSongPlayed
+  } // END setSongActive
 
   // ---------------------------------------------------------------------------
   // getProgressBarSelectedPositionPercentage
@@ -1368,20 +1396,18 @@ regenerate: true
         activeVideoElement.album          = activeSong.album;
         activeVideoElement.artist         = activeSong.artist;
         activeVideoElement.audio_info     = activeSong.audio_info;
-        activeVideoElement.audio_single   = activeSong.audio_single;
         activeVideoElement.currentTime    = parseFloat(activeVideoElement.player.getCurrentTime());
         activeVideoElement.cover_art_url  = activeSong.cover_art_url;
         activeVideoElement.duration       = activeSong.duration;
-        activeVideoElement.endSec         = timestamp2seconds(activeSong.end);
+        activeVideoElement.endSec         = j1.adapter.amplitude.timestamp2seconds(activeSong.end);
         activeVideoElement.endTS          = activeSong.end;
         activeVideoElement.name           = activeSong.name;
-        activeVideoElement.rating         = activeSong.album;
-        activeVideoElement.startSec       = timestamp2seconds(activeSong.start);
+        activeVideoElement.rating         = activeSong.rating;
+        activeVideoElement.startSec       = j1.adapter.amplitude.timestamp2seconds(activeSong.start);
         activeVideoElement.startTS        = activeSong.start;
         activeVideoElement.url            = activeSong.url;
 
         var videoArray                    = activeSong.url.split('=');
-
         activeVideoElement.videoID        = videoArray[1];
 
       }
@@ -1440,7 +1466,7 @@ regenerate: true
         activeClass   = 'large-player-progress-' + playlist;
 
         if (activePlayer === undefined) {
-          logger.error('\n' + 'YT player not defined');
+          logger.error('YT player not defined');
           return;
         }
 
@@ -1467,33 +1493,13 @@ regenerate: true
   function updateDurationTimeContainerYTP(player, playlist) {
     var hours, minutes, seconds;
     var durationHours, durationMinutes, durationSeconds;
-    var activeSongSettings, ytPlayer, activePlaylist;
-
-    // update active song settings (manually)
-    checkActiveVideoElementYTP(); 
-
-    // get active song settings (manually)
-    activeSongSettings = getActiveSong();
-    if (!activeSongSettings) {
-      return false;
-    }
-
-    ytPlayer        = activeSongSettings.player;
-    activePlaylist  = activeSongSettings.playlist;
-
-    // if (activeSongSettings) {
-    //   ytPlayer        = activeSongSettings.player;
-    //   activePlaylist  = activeSongSettings.playlist;
-    // } else {
-    //   ytPlayer        = player; 
-    //   activePlaylist  = playlist; 
-    // }
+    var activePlaylist;
 
     // get current hours|minutes|seconds
     // -------------------------------------------------------------------------
-    hours   = ytpGetDurationHours(ytPlayer);
-    minutes = ytpGetDurationMinutes(ytPlayer);
-    seconds = ytpGetDurationSeconds(ytPlayer);
+    hours   = ytpGetDurationHours(player);
+    minutes = ytpGetDurationMinutes(player);
+    seconds = ytpGetDurationSeconds(player);
 
     // update current duration|hours
     // -------------------------------------------------------------------------
@@ -1501,7 +1507,7 @@ regenerate: true
     if (durationHours.length && !isNaN(hours)) {
       for (var i=0; i<durationHours.length; i++) {    
         var currentPlaylist = durationHours[i].dataset.amplitudePlaylist;
-        if (currentPlaylist === activePlaylist) {
+        if (currentPlaylist === playlist) {
           durationHours[i].innerHTML = hours;
         }
       }
@@ -1513,7 +1519,7 @@ regenerate: true
     if (durationMinutes.length && !isNaN(minutes)) {
       for (var i=0; i<durationMinutes.length; i++) {    
         var currentPlaylist = durationMinutes[i].dataset.amplitudePlaylist;
-        if (currentPlaylist === activePlaylist) {
+        if (currentPlaylist === playlist) {
           durationMinutes[i].innerHTML = minutes;
         }
       }
@@ -1525,7 +1531,7 @@ regenerate: true
     if (durationSeconds.length && !isNaN(seconds)) {
       for (var i=0; i<durationSeconds.length; i++) {    
         var currentPlaylist = durationSeconds[i].dataset.amplitudePlaylist;
-        if (currentPlaylist === activePlaylist) {
+        if (currentPlaylist === playlist) {
           durationSeconds[i].innerHTML = seconds;
         }
       }
@@ -1693,7 +1699,6 @@ regenerate: true
 
   } // END ytpSeekTo
 
-
   // ---------------------------------------------------------------------------
   // ytpGetBuffered
   //
@@ -1719,7 +1724,6 @@ regenerate: true
     return activeIndex;
   } // END ytpGetActiveIndex
 
-
   // ---------------------------------------------------------------------------
   // ytpSetActiveIndex
   //
@@ -1779,10 +1783,13 @@ regenerate: true
   // Returns the duration of the video
   // ---------------------------------------------------------------------------
   function ytpGetDuration(player) {
-    var playerState, duration;
+    var duration;
 
-    playerState = player.getPlayerState();
-    if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.BUFFERING || playerState === YT_PLAYER_STATE.PAUSED || playerState === YT_PLAYER_STATE.CUED) {
+    var playerState   = player.getPlayerState();
+    var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
+
+    var isValidPlayerState = /playing|paused|buffering|cued/.test(ytPlayerState);
+    if (isValidPlayerState) {
       duration = player.getDuration();
 
       return duration;
@@ -1797,18 +1804,20 @@ regenerate: true
   // Returns the current time of the video played
   // ---------------------------------------------------------------------------
   function ytpGetCurrentTime(player) {
-    var currentTime, playerState;
+    var currentTime;
+
+    var playerState   = player.getPlayerState();
+    var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
 
-    if (player !== undefined && player.getPlayerState !== undefined) {
-      playerState = player.getPlayerState();
-      if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED || playerState === YT_PLAYER_STATE.CUED) {
+    var isValidPlayerState = /playing|paused|cued|unstarted/.test(ytPlayerState);
+    if (isValidPlayerState) {
         currentTime = player.getCurrentTime();
 
         return currentTime;
-      } else {
+    } else {
         return 0;
-      }
     }
+
   } // END ytpGetCurrentTime
 
   // ---------------------------------------------------------------------------
@@ -1817,21 +1826,23 @@ regenerate: true
   // Returns the duration hours of the video
   // ---------------------------------------------------------------------------
   function ytpGetDurationHours(player) {
-    var playerState, duration, hours, d, h;
+    var duration, hours, d, h;
+
+    var playerState   = player.getPlayerState();
+    var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
 
-    if (player !== undefined && player.getPlayerState !== undefined) {
-      playerState = player.getPlayerState();
-      if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED || playerState === YT_PLAYER_STATE.CUED ) {
+    var isValidPlayerState = /playing|paused|cued/.test(ytPlayerState);
+    if (isValidPlayerState) {
         duration  = ytpGetDuration(player);
         d         = Number(duration);
         h         = Math.floor(d / 3600);
         hours     = h.toString().padStart(2, '0');
 
         return hours;
-      } else {
+    } else {
         return '00';
-      }
     }
+
   } // END ytpGetDurationHours
 
   // ---------------------------------------------------------------------------
@@ -1840,23 +1851,24 @@ regenerate: true
   // Returns the duration minutes of the video
   // ---------------------------------------------------------------------------
   function ytpGetDurationMinutes(player) {
-    var playerState, duration, minutes, d, m;
+    var duration, minutes, d, m;
 
-    if (player !== undefined && player.getPlayerState !== undefined) {
-      playerState = player.getPlayerState();
-      if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED || playerState === YT_PLAYER_STATE.CUED) {
+    var playerState   = player.getPlayerState();
+    var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
+
+    var isValidPlayerState = /playing|paused|cued/.test(ytPlayerState);
+    if (isValidPlayerState) {
         duration  = ytpGetDuration(player);
         d         = Number(duration);
         m         = Math.floor(d % 3600 / 60);
         minutes   = m.toString().padStart(2, '0');
 
         return minutes;
-      } else {
+    } else {
         return '00';
-      }
     }
-  } // END ytpGetDurationMinutes
 
+  } // END ytpGetDurationMinutes
 
   // ---------------------------------------------------------------------------
   // ytpGetDurationSeconds
@@ -1864,21 +1876,23 @@ regenerate: true
   // Returns the duration seconds of the video
   // ---------------------------------------------------------------------------
   function ytpGetDurationSeconds(player) {
-    var playerState, duration, seconds, d, s;
+    var duration, seconds, d, s;
+
+    var playerState   = player.getPlayerState();
+    var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
 
-    if (player !== undefined && player.getPlayerState !== undefined) {
-      playerState = player.getPlayerState();
-      if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED || playerState === YT_PLAYER_STATE.CUED ) {
+    var isValidPlayerState = /playing|paused|cued/.test(ytPlayerState);
+    if (isValidPlayerState) {
         duration  = ytpGetDuration(player);
         d         = Number(duration);
         s         = Math.floor(d % 60);
         seconds   = s.toString().padStart(2, '0');
 
         return seconds;
-      } else {
+    } else {
         return '00';
-      }
     }
+
   } // END ytpGetDurationSeconds
 
   // ---------------------------------------------------------------------------
@@ -1887,21 +1901,23 @@ regenerate: true
   // Returns the current hours the user is into the video
   // ---------------------------------------------------------------------------
   function ytpGetCurrentHours(player) {
-    var playerState, currentTime, hours, d, h;
+    var currentTime, hours, d, h;
+
+    var playerState   = player.getPlayerState();
+    var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
 
-    if (player !== undefined && player.getPlayerState !== undefined) {
-      playerState = player.getPlayerState();
-      if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED || playerState === YT_PLAYER_STATE.CUED) {
+    var isValidPlayerState = /playing|paused/.test(ytPlayerState);
+    if (isValidPlayerState) {
         currentTime = ytpGetCurrentTime(player);
         d           = Number(currentTime);
         h           = Math.floor(d / 3600);
         hours       = h.toString().padStart(2, '0');
 
         return hours;
-      } else {
+    } else {
         return '00';
-      }
     }
+
   } // END ytpGetCurrentHours
 
   // ---------------------------------------------------------------------------
@@ -1910,21 +1926,23 @@ regenerate: true
   // Returns the current minutes the user is into the video
   // ---------------------------------------------------------------------------
   function ytpGetCurrentMinutes (player) {
-    var playerState, currentTime, minutes, d, m;
+    var currentTime, minutes, d, m;
+
+    var playerState   = player.getPlayerState();
+    var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
 
-    if (player !== undefined && player.getPlayerState !== undefined) {
-      playerState = player.getPlayerState();
-      if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED || playerState === YT_PLAYER_STATE.CUED) {
+    var isValidPlayerState = /playing|paused/.test(ytPlayerState);
+    if (isValidPlayerState) {
         currentTime = ytpGetCurrentTime(player);
         d           = Number(currentTime);
         m           = Math.floor(d % 3600 / 60);
         minutes     = m.toString().padStart(2, '0');
 
         return minutes;
-      } else {
+    } else {
         return '00';
-      }
     }
+
   } // END ytpGetCurrentMinutes
 
   // ---------------------------------------------------------------------------
@@ -1933,21 +1951,23 @@ regenerate: true
   // Returns the current seconds the user is into the video
   // ---------------------------------------------------------------------------
   function ytpGetCurrentSeconds(player) {
-    var playerState, currentTime, seconds, d, s;
+    var currentTime, seconds, d, s;
 
-    if (player !== undefined && player.getPlayerState !== undefined) {
-      playerState = player.getPlayerState();
-      if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED || playerState === YT_PLAYER_STATE.CUED ) {
+    var playerState   = player.getPlayerState();
+    var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
+
+    var isValidPlayerState = /playing|paused/.test(ytPlayerState);
+    if (isValidPlayerState) {
         currentTime = ytpGetCurrentTime(player);
         d           = Number(currentTime);
         s           = Math.floor(d % 60);
         seconds     = s.toString().padStart(2, '0');
 
         return seconds;
-      } else {
+    } else {
         return '00';
-      }
     }
+
   } // END ytpGetCurrentSeconds
 
   // ---------------------------------------------------------------------------
@@ -1980,10 +2000,6 @@ regenerate: true
   // setPlayPauseButtonPaused 
   // ---------------------------------------------------------------------------
   function setPlayPauseButtonPaused(element) {
-    var button, htmlElement;
-
-    // button      = document.getElementsByClassName(elementClass);
-    // htmlElement = button[0];
 
     element.classList.remove('amplitude-playing');
     element.classList.add('amplitude-paused');
@@ -1993,14 +2009,10 @@ regenerate: true
   // ---------------------------------------------------------------------------
   // setPlayPauseButtonPlaying 
   // ---------------------------------------------------------------------------
-  function setPlayPauseButtonPlaying(elementClass) {
-    var button, htmlElement;
-
-    button      = document.getElementsByClassName(elementClass);
-    htmlElement = button[0];
+  function setPlayPauseButtonPlaying(element) {
 
-    htmlElement.classList.remove('amplitude-paused');
-    htmlElement.classList.add('amplitude-playing');
+    element.classList.remove('amplitude-paused');
+    element.classList.add('amplitude-playing');
 
   } // END setPlayPauseButtonPlaying
 
@@ -2070,8 +2082,7 @@ regenerate: true
           });
         }          
 
-        // Overload AJS play_pause button for YT
-        // TODO: Fix for multiple players in page
+        // Overload ytp play_pause button for YT
         // ---------------------------------------------------------------------
         var largePlayerPlayPauseButton = document.getElementsByClassName(playerButton);
         for (var i=0; i<largePlayerPlayPauseButton.length; i++) {          
@@ -2080,111 +2091,117 @@ regenerate: true
 
           if (classString.includes(ytPlayerID)) {
             largePlayerPlayPauseButton[i].addEventListener('click', function(event) {
-              var activeSongSettings, songs, songMetaData, ytPlayer,
-                  playlist, playerID, songIndex;
-
-              playlist            = this.getAttribute("data-amplitude-playlist");
-              playerID            = playlist + '_large';
+              var activeSong, songs, songMetaData, playerData,
+                  ytPlayer, playerState, ytPlayerState, playlist,
+                  playerID, songIndex;
 
-              // update active song settings (manually)
-              checkActiveVideoElementYTP();
+              playlist    = this.getAttribute("data-amplitude-playlist");
+              playerID    = playlist + '_large';
+              activeSong  = getActiveSong();
 
-              // get active song settings (manually)
-              activeSongSettings  = getActiveSong();
-
-              // TODO: Extend getSongIndex() for singleAudio
-              // var songIndex      = (singleAudio) ? ytpSongIndex : getSongIndex(songs, ytVideoID);
-              if (!activeSongSettings) {
+              if (!activeSong) {
                 songIndex     = 0;
                 ytpSongIndex  = 0;
               } else {
-                
-                // ytPlayerCurrentTime = activeSongSettings.currentTime;
-
-                if (activeSongSettings.playlist !== playlist) {
+                if (activeSong.playlist !== playlist) {
                   songIndex    = 0;
                   ytpSongIndex = 0;
-
-                  // reset previous player settings
-                  if (activeSongSettings.player !== undefined) {
-                    activeSongSettings.player.stopVideo();
-                    var playPauseButtonClass = `large-player-play-pause-${activeSongSettings.playerID}`;
-                    togglePlayPauseButton(playPauseButtonClass);                    
-                  }
                 } else {
                   songIndex = ytpSongIndex;
                 }
-              }
-
-              // set song (video) active at index in playlist
-              setSongActive(playlist, songIndex);
+              } // END if activeSong
 
-              // reset progress bar settings
-              resetProgressBarYTP();
+              if (j1.adapter.amplitude.data.ytpGlobals.ytApiError > 0) {
+                // do nothing on API errors
+                var trackID = songIndex + 1;
+                logger.error(`DISABLED player for playlist|trackID: ${playlist}|${trackID} on API error '${YT_PLAYER_ERROR_NAMES[j1.adapter.amplitude.data.ytpGlobals.ytApiError]}'`);
 
-              // scroll song active at index in player
-              if (playerAutoScrollSongElement) {
-                scrollToActiveElement(playlist);
+                return;
               }
 
-              // update activeAudio data (manually)
-              checkActiveVideoElementYTP();
-
-              // get active song settings (manually)
-              activeSongSettings  = getActiveSong();
-
-              songs               = activeSongSettings.songs;
-              songMetaData        = songs[songIndex];
-              ytPlayer            = activeSongSettings.player;
-
-              // update meta data
-              updatMetaContainers(songMetaData);              
+              playerData    = j1.adapter.amplitude.data.ytPlayers[playerID];
+              ytPlayer      = playerData.player;
+              songIndex     = playerData.activeIndex;
+              songs         = playerData.songs;           
 
               // save player GLOBAL data for later use (e.g. events)
               j1.adapter.amplitude.data.activePlayer                 = 'ytp';
               j1.adapter.amplitude.data.ytpGlobals['activeIndex']    = songIndex;
               j1.adapter.amplitude.data.ytpGlobals['activePlaylist'] = playlist;
 
-              // YT play|pause video
+              // toggle YT play|pause video
               // ---------------------------------------------------------------
-              var playerState   = ytPlayer.getPlayerState();
-              if (playerState < 0) {
-                var ytPlayerState = YT_PLAYER_STATE_NAMES[6];
-              } else {
-                var ytPlayerState = YT_PLAYER_STATE_NAMES[playerState];
-              }
+              playerState   = ytPlayer.getPlayerState();
+              ytPlayerState = (playerState < 0) ? YT_PLAYER_STATE_NAMES[6] : YT_PLAYER_STATE_NAMES[playerState];
+
+              // NOTE:
+              // ---------------------------------------------------------------
+              // unclear why player state 'cued' occurs
+              // ---------------------------------------------------------------              
+              // load (cued) video
+              if (ytPlayerState === 'cued' || ytPlayerState === 'unstarted' ) {
+                ytPlayer.playVideo();
+
+                // wait for API error state
+                setTimeout(() => {
+                  if (j1.adapter.amplitude.data.ytpGlobals.ytApiError > 0) {
+                    var trackID = songIndex + 1;
+                    logger.error(`DISABLED player for playlist|trackID: ${playlist}|${trackID} on API error '${YT_PLAYER_ERROR_NAMES[j1.adapter.amplitude.data.ytpGlobals.ytApiError]}'`);
+
+                    // do nothing on API errors
+                    return;
+                  }
+
+                  // reset progress bar settings
+                  resetProgressBarYTP();                    
 
-              // var playPauseButtonsMini = document.getElementsByClassName('mini-player-play-pause');
-              // setPlayPauseButtonPaused(playPauseButtonsMini);
+                  var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
+                  togglePlayPauseButton(playPauseButtonClass);
 
-              if (ytPlayerState === 'playing') {
+                  // set song at songIndex active in playlist
+                  setSongActive(playlist, songIndex);
+
+                  // scroll song active at index in player
+                  if (playerAutoScrollSongElement) {
+                    scrollToActiveElement(playlist);
+                  }
+
+                  // reset|update time settings
+                  resetCurrentTimeContainerYTP(ytPlayer, playlist);
+                  updateDurationTimeContainerYTP(ytPlayer, playlist);
+
+                }, 100);
+
+                return;
+              } // END if ytPlayerState === 'cued'              
+
+              // NOTE:
+              // ---------------------------------------------------------------
+              // unclear why player state 'cued'
+              // is folloed by 'unstarted'|'buffering' on playing
+              // ---------------------------------------------------------------
+              // TOGGLE state 'playing' => 'paused'
+              var isValidPlayerState = /playing|unstarted|buffering/.test(ytPlayerState);
+              if (isValidPlayerState) {
                 ytPlayer.pauseVideo();
 
                 ytPlayerCurrentTime = ytPlayer.getCurrentTime();
-                
-                // var trackID = songIndex + 1;
-                // logger.debug('\n' + `PAUSE video for PlayPauseButton on playlist|trackID: ${playlist}|${trackID} at: ${ytPlayerCurrentTime}`);                
 
-                // var playPauseButtonsMini = document.getElementsByClassName('mini-player-play-pause');
-                // setPlayPauseButtonPaused(playPauseButtonsMini);
-
-                // var playPauseButtonClassCompact = `compact-player-play-pause -${ytPlayerID}`;
-                // togglePlayPauseButton(playPauseButtonClassCompact);
-                // //                 
-                // var playPauseButtonClassLarge = `large-player-play-pause-${ytPlayerID}`;
-                // togglePlayPauseButton(playPauseButtonClassLarge);
+                var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
+                togglePlayPauseButton(playPauseButtonClass);
 
                 // reset|update time settings
                 resetCurrentTimeContainerYTP(ytPlayer, playlist);
                 updateDurationTimeContainerYTP(ytPlayer, playlist);                
               }
 
+              // TOGGLE state 'paused' => 'playing'
               if (ytPlayerState === 'paused') {
                 ytPlayer.playVideo();
                 ytpSeekTo(ytPlayer, ytPlayerCurrentTime, true);
 
                 var trackID =  songIndex + 1;
-                logger.debug('\n' + `PLAY video for PlayPauseButton on playlist|trackID: ${playlist}|${trackID} at: ${ytPlayerCurrentTime}`);
+                logger.debug(`PLAY video for PlayPauseButton on playlist|trackID: ${playlist}|${trackID} at: ${ytPlayerCurrentTime}`);
 
                 var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
                 togglePlayPauseButton(playPauseButtonClass);
@@ -2192,47 +2209,16 @@ regenerate: true
                 // reset|update time settings
                 resetCurrentTimeContainerYTP(ytPlayer, playlist);
                 updateDurationTimeContainerYTP(ytPlayer, playlist);                  
-              }
-
-              if (ytPlayerState === 'cued') {
-                ytPlayer.playVideo();
-                var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
-                togglePlayPauseButton(playPauseButtonClass);
-
-                // set song at songIndex active in playlist
-                setSongActive(playlist, songIndex);
-
-                // scroll song active at index in player
-                if (playerAutoScrollSongElement) {
-                  scrollToActiveElement(playlist);
-                }
-
-                // reset|update time settings
-                resetCurrentTimeContainerYTP(ytPlayer, playlist);
-                updateDurationTimeContainerYTP(ytPlayer, playlist);                  
-              }
-
-              // TODO: unclear why state 'unstarted' is generated
-              // on LAST item
-              // workaround sofar
-              if (ytPlayerState === 'unstarted') {
-                ytPlayer.playVideo();
-                // ytPlayer.mute();              
-                
-                var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
-                togglePlayPauseButton(playPauseButtonClass);
-                resetCurrentTimeContainerYTP(ytPlayer, playlist);
-                updateDurationTimeContainerYTP(ytPlayer, playlist);                  
-              }
+              } // if ytPlayerState === 'paused'
 
               // deactivate AJS events (if any)
               event.stopImmediatePropagation();
-            }); // END EventListener largePlayerPlayPauseButton 'click'
-          }
+
+            }); // END EventListener largePlayerPlayPauseButton 'click
+          } // END if classString
         } // END for largePlayerPlayPauseButton
 
         // Overload AJS largePlayerSkipBackward button for YT
-        // TODO: Fix for multiple players in page
         // ---------------------------------------------------------------------
         var largePlayerSkipForwardButtons = document.getElementsByClassName("large-player-skip-forward");
         for (var i=0; i<largePlayerSkipForwardButtons.length; i++) {
@@ -2252,19 +2238,17 @@ regenerate: true
               currentVideoTime  = ytPlayer.getCurrentTime();
 
               if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED) {
-                logger.debug('\n' + `SKIP forward on Button skipForward for ${skipOffset} seconds`);
+                logger.debug(`SKIP forward on Button skipForward for ${skipOffset} seconds`);
                 ytpSeekTo(ytPlayer, currentVideoTime + skipOffset, true);
-
               }
 
             // deactivate AJS events (if any)
             event.stopImmediatePropagation();
-            }); // END Listener 'click'
-          } // END if skip-forward button
-        } // END for  
+            }); // END eventListener
+          } // END if classString.includes(ytPlayerID
+        } // END for largePlayerSkipForwardButtons 
 
         // Overload AJS largePlayerSkipBackward button for YT
-        // TODO: Fix for multiple players in page
         // ---------------------------------------------------------------------
         var largePlayerSkipBackwardButtons = document.getElementsByClassName("large-player-skip-backward");
         for (var i=0; i<largePlayerSkipBackwardButtons.length; i++) {
@@ -2284,7 +2268,7 @@ regenerate: true
               currentVideoTime  = ytPlayer.getCurrentTime();
 
               if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED) {
-                logger.debug('\n' + `SKIP backward on Button skipBackward for ${skipOffset} seconds`);
+                logger.debug(`SKIP backward on Button skipBackward for ${skipOffset} seconds`);
                 ytpSeekTo(ytPlayer, currentVideoTime - skipOffset, true);
               }
 
@@ -2295,8 +2279,6 @@ regenerate: true
         } // END for
 
         // Overload AJS largePlayerNext button for YT
-        // click on (player) next button
-        // TODO: Fix for multiple players in page
         // ---------------------------------------------------------------------
         var largePlayerNextButton = document.getElementsByClassName("large-player-next");
         for (var i=0; i<largePlayerNextButton.length; i++) {
@@ -2315,12 +2297,17 @@ regenerate: true
               songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
               ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;
 
-              if (ytPlayer === undefined) {
-                logger.error('\n' + 'YT player not defined');
+              if (j1.adapter.amplitude.data.ytpGlobals.ytApiError > 0) {
+                // do nothing on API errors
+                var trackID = songIndex + 1;
+                logger.error(`DISABLED player for playlist|trackID: ${playlist}|${trackID} on API error '${YT_PLAYER_ERROR_NAMES[j1.adapter.amplitude.data.ytpGlobals.ytApiError]}'`);
+
+                return;
               }
 
-              // stop active AT|YT players except the current
-              // stopAllActivePlayers(playerID);
+              if (ytPlayer === undefined) {
+                logger.error('YT player not defined');
+              }
 
               // select video
               if (songIndex < songs.length-1) {
@@ -2350,8 +2337,16 @@ regenerate: true
               j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
               j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID;
 
+              // save amplitudejs data for later use (e.g. events)
+              // ---------------------------------------------------------------
+              j1.modules.amplitudejs.data.ytp.activeIndex = songIndex;
+              j1.modules.amplitudejs.data.ytp.activePlaylist = playlist;
+              j1.modules.amplitudejs.data.ytp.players[playerID].player = ytPlayer;
+              j1.modules.amplitudejs.data.ytp.players[playerID].activeIndex = songIndex;
+
+
               trackID = songIndex + 1;
-              logger.debug('\n' + `SWITCH video for PlayerNextButton at trackID|VideoID: ${trackID}|${ytpVideoID}`);
+              logger.debug(`SWITCH video for PlayerNextButton at trackID|VideoID: ${trackID}|${ytpVideoID}`);
               ytPlayer.loadVideoById(ytpVideoID);
 
               // delay after switch video
@@ -2375,7 +2370,6 @@ regenerate: true
 
                 // set AJS play_pause button paused
                 var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
-                // setPlayPauseButtonPlaying(playPauseButtonClass);
                 togglePlayPauseButton(playPauseButtonClass);
               } else {
                 // toggle AJS play_pause button
@@ -2392,7 +2386,7 @@ regenerate: true
               loadCoverImage(songMetaData);
 
               // update meta data
-              updatMetaContainers(songMetaData);
+              // ytpUpdatMetaContainers(songMetaData);
 
               // set song at songIndex active in playlist
               setSongActive(playlist, songIndex);
@@ -2406,13 +2400,11 @@ regenerate: true
               event.stopImmediatePropagation();
 
             }); // END EventListener 'click' next button
-          } // END if
+          } // END if classString.includes(ytPlayerID)
 
       } // END for largePlayerNextButton
 
       // Overload AJS largePlayerPrevious button for YT
-      // click on (player) previous button
-      // TODO: Fix for multiple players in page
       // -----------------------------------------------------------------------
       var largePlayePreviousButton = document.getElementsByClassName("large-player-previous");
       for (var i=0; i<largePlayePreviousButton.length; i++) {
@@ -2431,12 +2423,17 @@ regenerate: true
             songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
             ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;
 
-            if (ytPlayer === undefined) {
-              logger.error('\n' + 'YT player not defined');
+            if (j1.adapter.amplitude.data.ytpGlobals.ytApiError > 0) {
+              // do nothing on API errors
+              var trackID = songIndex + 1;
+              logger.error(`DISABLED player for playlist|trackID: ${playlist}|${trackID} on API error '${YT_PLAYER_ERROR_NAMES[j1.adapter.amplitude.data.ytpGlobals.ytApiError]}'`);
+
+              return;
             }
 
-            // stop active AT|YT players except the current
-            // stopAllActivePlayers(playerID);
+            if (ytPlayer === undefined) {
+              logger.error('YT player not defined');
+            }
 
             // select video
             if (songIndex > 0 && songIndex <= songs.length - 1) {
@@ -2459,7 +2456,20 @@ regenerate: true
             j1.adapter.amplitude.data.ytpGlobals['activeIndex']    = songIndex;
             j1.adapter.amplitude.data.ytpGlobals['activePlaylist'] = playlist;
 
-            // load next video
+
+            // save amplitudejs data for later use (e.g. events)
+            // -----------------------------------------------------------------
+            j1.modules.amplitudejs.data.activePlayer = songIndex;
+            j1.modules.amplitudejs.data.activeIndex = songIndex;
+            j1.modules.amplitudejs.data.activePlaylist = songIndex;
+            j1.modules.amplitudejs.data.ytp.activeIndex = songIndex;
+            j1.modules.amplitudejs.data.ytp.activePlaylist = playlist;
+            j1.modules.amplitudejs.data.ytp.players[playerID].player = ytPlayer;
+            j1.modules.amplitudejs.data.ytp.players[playerID].activeIndex = songIndex;   
+
+
+
+            // load previous video
             // -----------------------------------------------------------------
 
             // save YT player data for later use (e.g. events)
@@ -2468,7 +2478,7 @@ regenerate: true
             j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID; 
 
             trackID = songIndex + 1;
-            logger.debug('\n' + `SWITCH video for PlayePreviousButton at trackID|VideoID: ${trackID}|${ytpVideoID}`);
+            logger.debug(`SWITCH video for PlayePreviousButton at trackID|VideoID: ${trackID}|${ytpVideoID}`);
             ytPlayer.loadVideoById(ytpVideoID);
 
             // delay after switch video
@@ -2492,7 +2502,6 @@ regenerate: true
 
               // set AJS play_pause button paused
               var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
-              // setPlayPauseButtonPlaying(playPauseButtonClass);
               togglePlayPauseButton(playPauseButtonClass);
             } else {
               // toggle AJS play_pause button
@@ -2509,7 +2518,7 @@ regenerate: true
             loadCoverImage(songMetaData);
 
             // update meta data
-            updatMetaContainers(songMetaData);
+            // ytpUpdatMetaContainers(songMetaData);
 
             // set song at songIndex active in playlist
             setSongActive(playlist, songIndex);
@@ -2523,12 +2532,11 @@ regenerate: true
             event.stopImmediatePropagation();
 
           }); // END EventListener 'click' next button
-        } // END if
+        } // END if classString.includes(ytPlayerID)
 
     } // END for largePlayerNextButton
 
     // click on song container
-    // TODO: Fix for multiple players in page
     // -------------------------------------------------------------------------
     var largePlayerSongContainer = document.getElementsByClassName("amplitude-song-container");
     for (var i=0; i<largePlayerSongContainer.length; i++) {
@@ -2537,62 +2545,98 @@ regenerate: true
 
       if (classString.includes(ytPlayerID)) {
         largePlayerSongContainer[i].addEventListener('click', function(event) {
-          var activeSongSettings, playlist, playerID, playerState,
+          var activeSong, playlist, playerID,
+              playerState, ytPlayerState,
               songs, songIndex, songName, singleAudio, trackID,
-              ytPlayer, ytpVideoID;
+              ytPlayer, ytpVideoID, activeSongIndex, isSongIndexChanged;
 
           // set (current) playlist|song data
-          playlist    = this.getAttribute("data-amplitude-playlist");
-          playerID    = playlist + '_large';
-          songIndex   = parseInt(this.getAttribute("data-amplitude-song-index"));
-          trackID     = songIndex + 1;
+          // -------------------------------------------------------------------
+          playlist            = this.getAttribute("data-amplitude-playlist");
+          playerID            = playlist + '_large';
+          songIndex           = parseInt(this.getAttribute("data-amplitude-song-index"));
+          trackID             = songIndex + 1;
+          activeSongIndex     = j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex;
+          isSongIndexChanged  = (activeSongIndex !== songIndex) ? true : false;
+
+          // set (current) song meta data
+          // -------------------------------------------------------------------
+          songs               = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
+          songMetaData        = songs[songIndex];
+          songURL             = songMetaData.url;
+          ytpVideoID          = (ytPlayerErrorTest) ? 'invalidVideoID' : songURL.split('=')[1];
+          ytPlayer            = j1.adapter.amplitude.data.ytPlayers[playerID].player;
+          playerState         = ytPlayer.getPlayerState();
+          ytPlayerState       = (playerState < 0) ? YT_PLAYER_STATE_NAMES[6] : YT_PLAYER_STATE_NAMES[playerState];              
+
+          // NOTE:
+          // -------------------------------------------------------------------
+          // unclear why player state 'cued' occurs
+          // -------------------------------------------------------------------              
+          // load (cued) video
+          if (ytPlayerState === 'cued') {
+            ytPlayer.playVideo();
 
-          // update active song settings (manually)
-          checkActiveVideoElementYTP(); 
+            // wait for API error state
+            setTimeout(() => {
+              if (j1.adapter.amplitude.data.ytpGlobals.ytApiError > 0) {
+                var trackID = songIndex + 1;
+                logger.error(`DISABLED player for playlist|trackID: ${playlist}|${trackID} on API error '${YT_PLAYER_ERROR_NAMES[j1.adapter.amplitude.data.ytpGlobals.ytApiError]}'`);
 
-          // get active song settings (manually)
-          activeSongSettings = getActiveSong();
+                // do nothing on API errors
+                return;
+              }
 
-          if (activeSongSettings) {
-            // ytpCurrentTime = activeSongSettings.currentTime;
-            if (activeSongSettings.playlist !== playlist) {
-              // set current player settings
-              songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
-              ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;              
+              // reset progress bar settings
+              resetProgressBarYTP();                    
 
-              // reset previous player settings
-              if (activeSongSettings.player !== undefined) {
-                activeSongSettings.player.stopVideo();
-                var playPauseButtonClass = `large-player-play-pause-${activeSongSettings.playerID}`;
-                togglePlayPauseButton(playPauseButtonClass);                    
+              var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
+              togglePlayPauseButton(playPauseButtonClass);
+
+              // set song at songIndex active in playlist
+              setSongActive(playlist, songIndex);
+
+              // scroll song active at index in player
+              if (playerAutoScrollSongElement) {
+                scrollToActiveElement(playlist);
               }
-            } else {
-              // set current player settings
-              songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
-              ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;
-            }
-          } else {
-            // set current player settings
-            songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
-            ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;
-          }
 
-          // set (current) song meta data
-          songMetaData  = songs[songIndex];
-          songURL       = songMetaData.url;
-          ytpVideoID    = songURL.split('=')[1];
-          playerState   = ytPlayer.getPlayerState();
+              // reset|update time settings
+              resetCurrentTimeContainerYTP(ytPlayer, playlist);
+              updateDurationTimeContainerYTP(ytPlayer, playlist);
 
-          // TOGGLE state 'playing'|'paused' if video (audio) NOT changed
-          var isItemChanged = (j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex !== songIndex) ? true : false;
-          if (!isItemChanged && (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED)) {                    
+            }, 100);
+
+            return;
+          } // END if ytPlayerState === 'cued'
+
+          // TOGGLE state 'playing' => 'paused' if video (audio) NOT changed
+          if (!isSongIndexChanged && ytPlayerState === 'playing') {
+            ytPlayer.pauseVideo();
+              // get active song settings (manually)
+              activeSong = getActiveSong();
+
+              if (activeSong) {
+                // ytpCurrentTime = activeSong.currentTime;
+                if (activeSong.playlist !== playlist) {
+                  // set current player settings
+                  songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
+                  ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;              
+                } else {
+                  // set current player settings
+                  songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
+                  ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;
+                }
+              } else {
+                // set current player settings
+                songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
+                ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;
+              }
 
-            if (playerState === YT_PLAYER_STATE.PLAYING) {
-              ytPlayer.pauseVideo();
               ytPlayerCurrentTime = ytPlayer.getCurrentTime();
 
               var trackID = songIndex + 1;
-              logger.debug('\n' + `PAUSE video for PlayerSongContainer on playlist|trackID: ${playlist}|${trackID} at: ${ytPlayerCurrentTime}`);
+              logger.debug(`PAUSE video for PlayerSongContainer on playlist|trackID: ${playlist}|${trackID} at: ${ytPlayerCurrentTime}`);
 
               var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
               togglePlayPauseButton(playPauseButtonClass);
@@ -2600,92 +2644,191 @@ regenerate: true
               // reset|update time settings
               resetCurrentTimeContainerYTP(ytPlayer, playlist);
               updateDurationTimeContainerYTP(ytPlayer, playlist);
-              return;               
-            }
 
-            if (playerState === YT_PLAYER_STATE.PAUSED) {
+              // save YT player data for later use (e.g. events)
+              // ---------------------------------------------------------------
+              ytpSongIndex = songIndex;
+              j1.modules.amplitudejs.data.ytp.songIndex = songIndex;
+
+              // save YT player GLOBAL data for later use (e.g. events)
+              j1.adapter.amplitude.data.activePlayer                 = 'ytp';
+              j1.adapter.amplitude.data.ytpGlobals['activeIndex']    = songIndex;
+              j1.adapter.amplitude.data.ytpGlobals['activePlaylist'] = playlist;            
+
+              // save YT player data for later use (e.g. events)
+              j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
+              j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID;
+
+
+              // save amplitudejs data for later use (e.g. events)
+              // -----------------------------------------------------------------
+              j1.modules.amplitudejs.data.activePlayer = ytPlayer;
+              j1.modules.amplitudejs.data.activeIndex = songIndex;
+              j1.modules.amplitudejs.data.activePlaylist = playlist;
+              j1.modules.amplitudejs.data.ytp.activeIndex = songIndex;
+              j1.modules.amplitudejs.data.ytp.activePlaylist = playlist;
+              j1.modules.amplitudejs.data.ytp.players[playerID].player = ytPlayer;
+              j1.modules.amplitudejs.data.ytp.players[playerID].activeIndex = songIndex;
+              j1.modules.amplitudejs.data.ytp.players[playerID].ytpVideoID = ytpVideoID;
+
+
+              // reset|update current time settings
+              resetCurrentTimeContainerYTP(ytPlayer, playlist);
+              updateDurationTimeContainerYTP(ytPlayer, playlist);
+              resetProgressBarYTP();
+
+              // load the song cover image
+              loadCoverImage(songMetaData);
+
+              // update meta data
+              // ytpUpdatMetaContainers(songMetaData);
+
+              // set song at songIndex active in playlist
+              setSongActive(playlist, songIndex);
+
+              // scroll song active at index in player
+              if (playerAutoScrollSongElement) {
+                scrollToActiveElement(playlist);
+              }
+
+              // save YT player data for later use (e.g. events)
+              j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
+              j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID;   
+
+              return;
+            } // END if playerState === PLAYING
+
+            // TOGGLE state 'paused' => 'playing' if video (audio) NOT changed
+            if (!isSongIndexChanged && ytPlayerState === 'paused') {
               ytPlayer.playVideo();
               ytpSeekTo(ytPlayer, ytPlayerCurrentTime, true);
 
+              activeSong = getActiveSong();
+              if (activeSong) {
+                // ytpCurrentTime = activeSong.currentTime;
+                if (activeSong.playlist !== playlist) {
+                  // set current player settings
+                  songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
+                  ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;              
+                } else {
+                  // set current player settings
+                  songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
+                  ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;
+                }
+              } else {
+                // set current player settings
+                songs     = j1.adapter.amplitude.data.ytPlayers[playerID].songs;
+                ytPlayer  = j1.adapter.amplitude.data.ytPlayers[playerID].player;
+              }
+
               var trackID = songIndex + 1;
-              logger.debug('\n' + `PLAY video for PlayerSongContainer on playlist|trackID: ${playlist}|${trackID} at: ${ytPlayerCurrentTime}`);
+              logger.debug(`PLAY video for PlayerSongContainer on playlist|trackID: ${playlist}|${trackID} at: ${ytPlayerCurrentTime}`);
 
               var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
               togglePlayPauseButton(playPauseButtonClass);
 
+              // update meta data
+              // ytpUpdatMetaContainers(songMetaData);
+
               // reset|update time settings
               resetCurrentTimeContainerYTP(ytPlayer, playlist);
               updateDurationTimeContainerYTP(ytPlayer, playlist);
-              return;                
-            }
 
-          } // END !changedAudio
+              // set song at songIndex active in playlist
+              setSongActive(playlist, songIndex);
 
-          // update global song index (start at 0)
-          ytpSongIndex  = songIndex;
+              return;
+            } // END if playerState === PAUSED
+        
+            if (isSongIndexChanged) {
+              // load (next) video
+              // -------------------------------------------------------------------
+              trackID = songIndex + 1;
+              logger.debug(`SWITCH video for PlayerSongContainer at trackID|VideoID: ${trackID}|${ytpVideoID}`);
+              loadVideo(playlist, songIndex) 
 
-          // stop active AT|YT players
-          // stopAllActivePlayers(playerID);
+              // wait for API error state
+              setTimeout(() => {
+                if (j1.adapter.amplitude.data.ytpGlobals.ytApiError > 0) {
+                  var trackID = songIndex + 1;
+                  logger.error(`DISABLED player for playlist|trackID: ${playlist}|${trackID} on API error '${YT_PLAYER_ERROR_NAMES[j1.adapter.amplitude.data.ytpGlobals.ytApiError]}'`);
 
-          // save YT player GLOBAL data for later use (e.g. events)
-          j1.adapter.amplitude.data.activePlayer                 = 'ytp';
-          j1.adapter.amplitude.data.ytpGlobals['activeIndex']    = songIndex;
-          j1.adapter.amplitude.data.ytpGlobals['activePlaylist'] = playlist;            
+                  // do nothing on API errors
+                  return;
+                }
 
-          // save YT player data for later use (e.g. events)
-          j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
-          j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID;
+                // save YT player data for later use (e.g. events)
+                // -------------------------------------------------------------
+                ytpSongIndex = songIndex;
+                j1.modules.amplitudejs.data.ytp.songIndex = songIndex;
 
-          // reset|update current time settings
-          resetCurrentTimeContainerYTP(ytPlayer, playlist);
-          updateDurationTimeContainerYTP(ytPlayer, playlist);
-          resetProgressBarYTP();
+                // save YT player GLOBAL data for later use (e.g. events)
+                j1.adapter.amplitude.data.activePlayer = 'ytp';
+                j1.adapter.amplitude.data.ytpGlobals['activeIndex'] = songIndex;
+                j1.adapter.amplitude.data.ytpGlobals['activePlaylist'] = playlist;            
 
-          // load the song cover image
-          loadCoverImage(songMetaData);
+                // save YT player data for later use (e.g. events)
+                j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
+                j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID;
 
-          // update meta data
-          updatMetaContainers(songMetaData);
 
-          // set AJS play_pause button playing
-          var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
-          setPlayPauseButtonPlaying(playPauseButtonClass)
+                // save amplitudejs data for later use (e.g. events)
+                // -------------------------------------------------------------
+                j1.modules.amplitudejs.data.activePlayer = 'ytp';
+                j1.modules.amplitudejs.data.activeIndex = songIndex;
+                j1.modules.amplitudejs.data.activePlaylist = playlist;
+                j1.modules.amplitudejs.data.ytp.songIndex = songIndex;
+                j1.modules.amplitudejs.data.ytp.activeIndex = songIndex;
+                j1.modules.amplitudejs.data.ytp.activePlaylist = playlist;
+                j1.modules.amplitudejs.data.ytp.players[playerID].player = ytPlayer;
+                j1.modules.amplitudejs.data.ytp.players[playerID].activeIndex = songIndex;
+                j1.modules.amplitudejs.data.ytp.players[playerID].ytpVideoID = ytpVideoID;
 
-          // set song at songIndex active in playlist
-          setSongActive(playlist, songIndex);
 
-          // scroll song active at index in player
-          if (playerAutoScrollSongElement) {
-            scrollToActiveElement(playlist);
-          }
+                // reset|update current time settings
+                resetCurrentTimeContainerYTP(ytPlayer, playlist);
+                updateDurationTimeContainerYTP(ytPlayer, playlist);
+                resetProgressBarYTP();
 
-          // save YT player data for later use (e.g. events)
-          j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
-          j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID;          
+                // load the song cover image
+                loadCoverImage(songMetaData);
 
-          // load next video
-          // -------------------------------------------------------------------
-          trackID = songIndex + 1;
-          logger.debug('\n' + `SWITCH video for PlayerSongContainer at trackID|VideoID: ${trackID}|${ytpVideoID}`);
-          ytPlayer.loadVideoById(ytpVideoID);
+                // update meta data
+                // ytpUpdatMetaContainers(songMetaData);
 
-          // mute sound after next video load
-          // -------------------------------------------------------------------
-          if (muteAfterVideoSwitchInterval) {
-            ytPlayer.mute();
-            setTimeout(() => {
-              ytPlayer.unMute();
-            }, muteAfterVideoSwitchInterval);
-          }
+                var playPauseButtonClass = `large-player-play-pause-${ytPlayerID}`;
+                togglePlayPauseButton(playPauseButtonClass);
 
-          // deactivate AJS events (if any)
-          event.stopImmediatePropagation();           
-        }); // END EventListener 'click' SongContainer
-      } // END ifSWITCH video
-    } // END for
+                // set song at songIndex active in playlist
+                setSongActive(playlist, songIndex);
+
+                // scroll song active at index in player
+                if (playerAutoScrollSongElement) {
+                  scrollToActiveElement(playlist);
+                }
+
+                // save YT player data for later use (e.g. events)
+                // j1.adapter.amplitude.data.ytPlayers[playerID].activeIndex = songIndex;
+                // j1.adapter.amplitude.data.ytPlayers[playerID].videoID     = ytpVideoID;   
+
+                // mute sound after next video load
+                // -------------------------------------------------------------------
+                if (muteAfterVideoSwitchInterval) {
+                  ytPlayer.mute();
+                  setTimeout(() => {
+                    ytPlayer.unMute();
+                  }, muteAfterVideoSwitchInterval);
+                }
+              }, 100); // END timeout
+            } // END if isSongIndexChanged
+
+            // deactivate AJS events (if any)
+            event.stopImmediatePropagation();           
+        }); // END EventListener
+      } // END if classString
+    } // END for largePlayerSongContainer
 
     // add listeners to all progress bars found
-    // TODO: Fix for multiple players in page
     // -------------------------------------------------------------------------
     var progressBars = document.getElementsByClassName("large-player-progress");
     if (progressBars.length) {
@@ -2705,30 +2848,24 @@ regenerate: true
             j1.adapter.amplitude.data.ytPlayers[playerID].progressBar = progressBar;
 
             progressBars[i].addEventListener('click', function(event) {
-              var activeSongSettings, playlist, ytPlayer,
-                  playerState, progressBar, percentage, time;
+              var activeSong, playlist, ytPlayer,
+                  playerState, progressBar, percentage, time;               
 
-              // update active song settings (manually)
-              checkActiveVideoElementYTP();                   
-
-              // get active song settings (manually)
-              activeSongSettings = getActiveSong();
-
-              if (!activeSongSettings) {
-                // do nothing if current video (audio) item is NOT selected|active
+              activeSong = getActiveSong();
+              if (!activeSong) {
+                 // do nothing if activeSong data is missing (failsafe)
                 return;
               }
 
               playlist = this.getAttribute("data-amplitude-playlist");
-              if (activeSongSettings.playlist !== playlist) {
-                // do nothing on PREVIOUS playlist (player)
+              if (activeSong.playlist !== playlist) {
+                // do nothing on PREVIOUS playlist
                 return;              
               }
 
-              ytPlayer    = activeSongSettings.player; 
+              ytPlayer    = activeSong.player; 
               playerState = ytPlayer.getPlayerState();
 
-              //if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.BUFFERING) {
               if (playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED || playerState === YT_PLAYER_STATE.BUFFERING) {
                 progressBar = this;
                 percentage  = getProgressBarSelectedPositionPercentage(event, progressBar);
@@ -2753,96 +2890,82 @@ regenerate: true
     } // END if progressBars
 
     // add listeners to all volume sliders found
-    // TODO: Fix for multiple players in page
     // -------------------------------------------------------------------------
     var volumeSliders = document.getElementsByClassName("amplitude-volume-slider");
     for (var i=0; i<volumeSliders.length; i++) {
       if (volumeSliders[i].dataset.amplitudeSource === 'audio') {
         // do nothing (managed by adapter)
-        var bla = 1;
       } else {
         if (volumeSliders[i]) {
-          // for (var i=0; i<volumeSliders.length; i++) {
-            var volumeSlider  = volumeSliders[i];
-            var sliderID      = volumeSliders[i].id;
-            var playerID      = sliderID.split('volume_slider_')[1];
+          var volumeSlider  = volumeSliders[i];
+          var sliderID      = volumeSliders[i].id;
+          var playerID      = sliderID.split('volume_slider_')[1];
 
-            // save YT player data for later use (e.g. events)
-            // j1.adapter.amplitude.data.ytPlayers[playerID].volumeSlider = volumeSlider;
+          // save YT player data for later use (e.g. events)
+          if (volumeSlider.dataset.amplitudeSource === 'youtube') {
+            j1.adapter.amplitude.data.ytPlayers[playerID].volumeSlider = volumeSlider;
+          }
 
-            volumeSliders[i].addEventListener('click', function(event) {
+          volumeSliders[i].addEventListener('click', function(event) {
+            var activeSong = getActiveSong();
 
-              // update active song settings (manually)
-              checkActiveVideoElementYTP(); 
-              
-              // get active song settings (manually)
-              var activeSongSettings = getActiveSong();
+            if (!activeSong) {
+               // do nothing if activeSong data is missing (failsafe)
+              return;
+            } 
 
-              if (!activeSongSettings) {
-                // do nothing if current video (audio) item is NOT selected|active
-                return;
-              } 
-              
-              var ytPlayer    = activeSongSettings.player; 
-              var playerState = ytPlayer.getPlayerState();
+            var ytPlayer    = activeSong.player; 
+            var playerState = ytPlayer.getPlayerState();
 
-              if ((playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED) && ytPlayer !== undefined) {
-                var volumeSlider, volumeValue;
-                var currenVolume = ytPlayer.getVolume();
+            if ((playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED) && ytPlayer !== undefined) {
+              var volumeSlider, volumeValue;
+              var currenVolume = ytPlayer.getVolume();
 
-                volumeSlider = this;
-                volumeValue  = 50;  // default
+              volumeSlider = this;
+              volumeValue  = 50;  // default
 
-                if (volumeSlider !== null) {
-                  volumeValue = parseInt(volumeSlider.value);
-                }
+              if (volumeSlider !== null) {
+                volumeValue = parseInt(volumeSlider.value);
+              }
 
-                ytPlayer.setVolume(volumeValue);
-              } // END if ytPlayer
+              ytPlayer.setVolume(volumeValue);
+            } // END if ytPlayer
 
-            }); // END EventListener 'click'
-          // } // END for
+          }); // END EventListener 'click'
         } // END if volumeSliders
       } // END if volumeSliders
     } // END for volumeSliders
 
     // add listeners to all mute buttons found
-    // TODO: Fix for multiple buttons in page
     // -------------------------------------------------------------------------
     var volumeMutes = document.getElementsByClassName("amplitude-mute");
     for (var i=0; i<volumeMutes.length; i++) {
       if (volumeMutes[i].dataset.amplitudeSource === 'audio') {
         // do nothing (managed by adapter)
-        var bla = 1;
       } else {    
         if (volumeMutes[i]) {
           var volumMute = volumeMutes[i];
           var sliderID  = volumeMutes[i].id;
           var playerID  = sliderID.split('amplitude-mute_')[1];
 
-          // save YT player data for later use (e.g. events)
-          // j1.adapter.amplitude.data.ytPlayers[playerID].volumMute = volumMute;
-
           volumeMutes[i].addEventListener('click', function(event) {
+            var activeSong = getActiveSong();
 
-            // update active song settings (manually)
-            checkActiveVideoElementYTP();
-
-            // get active song settings (manually)
-            var activeSongSettings = getActiveSong();
-
-            if (!activeSongSettings) {
-              // do nothing if current video (audio) item is NOT selected|active
+            if (!activeSong) {
+              // do nothing if activeSong data is missing (failsafe)
               return;
             } 
   
-            var ytPlayer            = activeSongSettings.player;
+            var ytPlayer            = activeSong.player;
             var playerState         = ytPlayer.getPlayerState();
             var volumeSlider        = j1.adapter.amplitude.data.ytPlayers[playerID].volumeSlider;
             var currenVolume        = ytPlayer.getVolume();
             var playerVolumePreset  = parseInt(j1.adapter.amplitude.data.ytPlayers[playerID].playerSettings.volume_slider.preset_value);
-    
-            if ((playerState === YT_PLAYER_STATE.PLAYING || playerState === YT_PLAYER_STATE.PAUSED) && ytPlayer !== undefined) {
+            var playerState         = (ytPlayer.getPlayerState() > 0) ? ytPlayer.getPlayerState() : 6;
+            var ytPlayerState       = YT_PLAYER_STATE_NAMES[playerState];
+
+            var isValidPlayerState = /playing|paused/.test(ytPlayerState);
+            if (isValidPlayerState && ytPlayer !== undefined) {
               if (currenVolume > 0) {
                 volumeSlider.value = 0;
                 ytPlayer.setVolume(0);                
@@ -2860,8 +2983,7 @@ regenerate: true
 
   } // END if playerSettings.type 'large'
 
- }
-
+ } // END if j1.adapter.amplitude['data']['ytPlayers'][ytPlayerID] !== undefined
 } // END mimikYTPlayerUiEventsForAJS
 
 {%- endcapture -%}