myetv-player 1.4.0 → 1.6.0

package/dist/myetv-player.min.js

@@ -23,7 +23,9 @@ class VideoPlayerI18n {
  'prev_video': 'Video precedente (P)',
  'playlist_next': 'Avanti',
  'playlist_prev': 'Indietro',
- 'settings_menu': 'Impostazioni'
+ 'settings_menu': 'Impostazioni',
+ 'loading': 'Caricamento...',
+ 'encoding_in_progress': 'Encoding in corso'
  },
 
  'en': {
@@ -44,7 +46,9 @@ class VideoPlayerI18n {
  'prev_video': 'Previous video (P)',
  'playlist_next': 'Next',
  'playlist_prev': 'Previous',
- 'settings_menu': 'Settings'
+ 'settings_menu': 'Settings',
+ 'loading': 'Loading...',
+ 'encoding_in_progress': 'Encoding in progress'
  },
 
  'es': {
@@ -65,7 +69,9 @@ class VideoPlayerI18n {
  'prev_video': 'Vídeo anterior (P)',
  'playlist_next': 'Siguiente',
  'playlist_prev': 'Anterior',
- 'settings_menu': 'Configuración'
+ 'settings_menu': 'Configuración',
+ 'loading': 'Cargando...',
+ 'encoding_in_progress': 'Codificación en curso'
  },
 
  'fr': {
@@ -78,7 +84,7 @@ class VideoPlayerI18n {
  'volume': 'Volume',
  'playback_speed': 'Vitesse de lecture',
  'video_quality': 'Qualité vidéo',
- 'picture_in_picture': 'Image dans l’image (P)',
+ 'picture_in_picture': 'Image dans l\'image(P)',
  'fullscreen': 'Plein écran (F)',
  'auto': 'Auto',
  'brand_logo': 'Logo de marque',
@@ -86,7 +92,9 @@ class VideoPlayerI18n {
  'prev_video': 'Vidéo précédente (P)',
  'playlist_next': 'Suivant',
  'playlist_prev': 'Précédent',
- 'settings_menu': 'Paramètres'
+ 'settings_menu': 'Paramètres',
+ 'loading': 'Chargement...',
+ 'encoding_in_progress': 'Encodage en cours'
  },
 
  'de': {
@@ -107,7 +115,9 @@ class VideoPlayerI18n {
  'prev_video': 'Vorheriges Video (P)',
  'playlist_next': 'Weiter',
  'playlist_prev': 'Zurück',
- 'settings_menu': 'Einstellungen'
+ 'settings_menu': 'Einstellungen',
+ 'loading': 'Laden...',
+ 'encoding_in_progress': 'Kodierung läuft'
  },
 
  'pt': {
@@ -128,7 +138,9 @@ class VideoPlayerI18n {
  'prev_video': 'Vídeo anterior (P)',
  'playlist_next': 'Próximo',
  'playlist_prev': 'Anterior',
- 'settings_menu': 'Configurações'
+ 'settings_menu': 'Configurações',
+ 'loading': 'Carregando...',
+ 'encoding_in_progress': 'Codificação em andamento'
  },
 
  'zh': {
@@ -149,7 +161,9 @@ class VideoPlayerI18n {
  'prev_video': '上一个视频 (P)',
  'playlist_next': '下一个',
  'playlist_prev': '上一个',
- 'settings_menu': '设置'
+ 'settings_menu': '设置',
+ 'loading': '加载中...',
+ 'encoding_in_progress': '编码中'
  },
 
  'ja': {
@@ -170,7 +184,9 @@ class VideoPlayerI18n {
  'prev_video': '前の動画 (P)',
  'playlist_next': '次へ',
  'playlist_prev': '前へ',
- 'settings_menu': '設定'
+ 'settings_menu': '設定',
+ 'loading': '読み込み中...',
+ 'encoding_in_progress': 'エンコード中'
  },
 
  'ru': {
@@ -191,7 +207,9 @@ class VideoPlayerI18n {
  'prev_video': 'Предыдущее видео (P)',
  'playlist_next': 'Далее',
  'playlist_prev': 'Назад',
- 'settings_menu': 'Настройки'
+ 'settings_menu': 'Настройки',
+ 'loading': 'Загрузка...',
+ 'encoding_in_progress': 'Кодирование'
  },
 
  'ar': {
@@ -212,7 +230,9 @@ class VideoPlayerI18n {
  'prev_video': 'الفيديو السابق (P)',
  'playlist_next': 'التالي',
  'playlist_prev': 'السابق',
- 'settings_menu': 'الإعدادات'
+ 'settings_menu': 'الإعدادات',
+ 'loading': 'جاري التحميل...',
+ 'encoding_in_progress': 'الترميز جارٍ'
  },
 
  'ko': {
@@ -233,7 +253,9 @@ class VideoPlayerI18n {
  'prev_video': '이전 비디오 (P)',
  'playlist_next': '다음',
  'playlist_prev': '이전',
- 'settings_menu': '설정'
+ 'settings_menu': '설정',
+ 'loading': '로딩 중...',
+ 'encoding_in_progress': '인코딩 진행 중'
  },
 
  'pl': {
@@ -254,7 +276,9 @@ class VideoPlayerI18n {
  'prev_video': 'Poprzednie wideo (P)',
  'playlist_next': 'Dalej',
  'playlist_prev': 'Wstecz',
- 'settings_menu': 'Ustawienia'
+ 'settings_menu': 'Ustawienia',
+ 'loading': 'Ładowanie...',
+ 'encoding_in_progress': 'Kodowanie w toku'
  },
 
  'hu': {
@@ -275,7 +299,9 @@ class VideoPlayerI18n {
  'prev_video': 'Előző videó (P)',
  'playlist_next': 'Következő',
  'playlist_prev': 'Előző',
- 'settings_menu': 'Beállítások'
+ 'settings_menu': 'Beállítások',
+ 'loading': 'Betöltés...',
+ 'encoding_in_progress': 'Kódolás folyamatban'
  },
 
  'tr': {
@@ -296,7 +322,9 @@ class VideoPlayerI18n {
  'prev_video': 'Önceki video (P)',
  'playlist_next': 'Sonraki',
  'playlist_prev': 'Önceki',
- 'settings_menu': 'Ayarlar'
+ 'settings_menu': 'Ayarlar',
+ 'loading': 'Yükleniyor...',
+ 'encoding_in_progress': 'Kodlama devam ediyor'
  },
 
  'nl': {
@@ -317,7 +345,9 @@ class VideoPlayerI18n {
  'prev_video': 'Vorige video (P)',
  'playlist_next': 'Volgende',
  'playlist_prev': 'Vorige',
- 'settings_menu': 'Instellingen'
+ 'settings_menu': 'Instellingen',
+ 'loading': 'Laden...',
+ 'encoding_in_progress': 'Codering bezig'
  },
 
  'hi': {
@@ -338,7 +368,9 @@ class VideoPlayerI18n {
  'prev_video': 'पिछला वीडियो (P)',
  'playlist_next': 'अगला',
  'playlist_prev': 'पिछला',
- 'settings_menu': 'सेटिंग्स'
+ 'settings_menu': 'सेटिंग्स',
+ 'loading': 'लोड हो रहा है...',
+ 'encoding_in_progress': 'एन्कोडिंग प्रगति में'
  },
 
  'sv': {
@@ -359,7 +391,9 @@ class VideoPlayerI18n {
  'prev_video': 'Föregående video (P)',
  'playlist_next': 'Nästa',
  'playlist_prev': 'Föregående',
- 'settings_menu': 'Inställningar'
+ 'settings_menu': 'Inställningar',
+ 'loading': 'Laddar...',
+ 'encoding_in_progress': 'Kodning pågår'
  },
 
  'id': {
@@ -380,7 +414,9 @@ class VideoPlayerI18n {
  'prev_video': 'Video sebelumnya (P)',
  'playlist_next': 'Berikutnya',
  'playlist_prev': 'Sebelumnya',
- 'settings_menu': 'Pengaturan'
+ 'settings_menu': 'Pengaturan',
+ 'loading': 'Memuat...',
+ 'encoding_in_progress': 'Encoding sedang berlangsung'
  }
  };
 
@@ -493,7 +529,9 @@ try {
  'fullscreen': 'Fullscreen (F)',
  'auto': 'Auto',
  'brand_logo': 'Brand logo',
- 'settings_menu': 'Settings'
+ 'settings_menu': 'Settings',
+ 'loading': 'Loading...',
+ 'encoding_in_progress': 'Encoding in progress'
  };
  return fallback[key] || key;
  },
@@ -802,6 +840,49 @@ constructor(videoElement, options = {}) {
  }
 }
 
+decodeHTMLEntities(text) {
+ if (!text) return '';
+ const textarea = document.createElement('textarea');
+ textarea.innerHTML = text;
+ return textarea.value;
+}
+
+isFireTV() {
+ const ua = navigator.userAgent.toLowerCase();
+ return ua.includes('aftm') ||
+ ua.includes('aftb') ||
+ ua.includes('afts') ||
+ ua.includes('aftmm') ||
+ ua.includes('aftt');
+}
+
+optimizeVideoForFireTV() {
+ if (!this.isFireTV() || !this.video) return;
+
+ if (this.options.debug) {
+ console.log('Fire TV detected - applying optimizations');
+ }
+
+ this.video.setAttribute('playsinline', '');
+ this.video.setAttribute('webkit-playsinline', '');
+
+ this.video.style.transform = 'translateZ(0)';
+ this.video.style.webkitTransform = 'translateZ(0)';
+ this.video.style.backfaceVisibility = 'hidden';
+ this.video.style.webkitBackfaceVisibility = 'hidden';
+ this.video.style.willChange = 'transform';
+
+ this.video.addEventListener('loadeddata', () => {
+ if (this.options.debug) {
+ console.log('Fire TV: Video loaded, forcing repaint');
+ }
+ this.video.style.display = 'none';
+ setTimeout(() => {
+ this.video.style.display = 'block';
+ }, 10);
+ }, { once: true });
+}
+
 getPlayerState() {
  return {
  isPlaying: !this.isPaused(),
@@ -1091,6 +1172,7 @@ createPlayerStructure() {
 
  this.container = wrapper;
 
+ this.optimizeVideoForFireTV();
  this.createInitialLoading();
  this.createLoadingOverlay();
  this.collectVideoQualities();
@@ -1131,13 +1213,13 @@ createTitleOverlay() {
 
  const titleText = document.createElement('h2');
  titleText.className = 'title-text';
- titleText.textContent = this.options.videoTitle || '';
+ titleText.textContent = this.decodeHTMLEntities(this.options.videoTitle) || '';
  overlay.appendChild(titleText);
 
  if (this.options.videoSubtitle) {
  const subtitleText = document.createElement('p');
  subtitleText.className = 'subtitle-text';
- subtitleText.textContent = this.options.videoSubtitle;
+ subtitleText.textContent = this.decodeHTMLEntities(this.options.videoSubtitle);
  overlay.appendChild(subtitleText);
  }
 
@@ -1192,7 +1274,7 @@ setVideoTitle(title) {
  if (this.titleOverlay) {
  const titleElement = this.titleOverlay.querySelector('.title-text');
  if (titleElement) {
- titleElement.textContent = this.options.videoTitle;
+ titleElement.textContent = this.decodeHTMLEntities(this.options.videoTitle);
  }
 
  if (title) {
@@ -1727,6 +1809,8 @@ updateDuration() {
  if (this.durationEl && this.video && this.video.duration && !isNaN(this.video.duration)) {
  this.durationEl.textContent = this.formatTime(this.video.duration);
  }
+
+ this.updateTimeDisplay();
 }
 
 changeSpeed(e) {
@@ -1992,7 +2076,7 @@ switchToVideo(newVideoElement, shouldPlay = false) {
  if (newTitle && this.options.showTitleOverlay) {
  this.options.videoTitle = newTitle;
  if (this.titleText) {
- this.titleText.textContent = newTitle;
+ this.titleText.textContent = this.decodeHTMLEntities(newTitle);
  }
  }
 
@@ -2482,12 +2566,16 @@ addEventListener(eventType, callback) {
  this.showLoading();
  }
 
+ this.updateTimeDisplay();
+
  this.triggerEvent('loadstart');
  });
 
  this.video.addEventListener('loadedmetadata', () => {
  this.updateDuration();
 
+ this.updateTimeDisplay();
+
  this.triggerEvent('loadedmetadata', {
  duration: this.getDuration(),
  videoWidth: this.video.videoWidth,
@@ -2504,6 +2592,8 @@ addEventListener(eventType, callback) {
  this.hideLoading();
  }
 
+ this.updateTimeDisplay();
+
  this.triggerEvent('loadeddata', {
  currentTime: this.getCurrentTime()
  });
@@ -2514,12 +2604,26 @@ addEventListener(eventType, callback) {
  this.hideLoading();
  }
 
+ this.updateTimeDisplay();
+
  this.triggerEvent('canplay', {
  currentTime: this.getCurrentTime(),
  duration: this.getDuration()
  });
  });
 
+ this.video.addEventListener('waiting', () => {
+ if (!this.isChangingQuality) {
+ this.showLoading();
+
+ this.updateTimeDisplay();
+
+ this.triggerEvent('waiting', {
+ currentTime: this.getCurrentTime()
+ });
+ }
+ });
+
  this.video.addEventListener('progress', () => {
  this.updateBuffer();
 
@@ -3219,7 +3323,7 @@ createControls() {
  <div class="settings-menu"></div>
  </div>
 
- ${this.options.showQualitySelector && this.originalSources && this.originalSources.length > 1 ? `
+${(this.options.showQualitySelector && this.originalSources && this.originalSources.length > 1) || this.options.adaptiveQualityControl ? `
  <div class="quality-control">
  <button class="control-btn quality-btn" data-tooltip="video_quality">
  <div class="quality-btn-text">
@@ -4011,6 +4115,11 @@ updateQualityDisplay() {
 }
 
 updateQualityButton() {
+ if (this.isAdaptiveStream) {
+ if (this.options.debug) console.log('🔒 Adaptive streaming active - quality button managed by streaming.js');
+ return;
+ }
+
  const qualityBtn = this.controls?.querySelector('.quality-btn');
  if (!qualityBtn) return;
 
@@ -4057,6 +4166,11 @@ updateQualityMenu() {
  const qualityMenu = this.controls?.querySelector('.quality-menu');
  if (!qualityMenu) return;
 
+ if (this.isAdaptiveStream) {
+ if (this.options.debug) console.log('🔒 Adaptive streaming active - quality menu managed by streaming.js');
+ return;
+ }
+
  let menuHTML = '';
 
  if (this.isAdaptiveStream && this.adaptiveQualities && this.adaptiveQualities.length > 0) {
@@ -6391,6 +6505,13 @@ async loadAdaptiveLibraries() {
 
  try {
 
+ this.selectedQuality = 'auto';
+ this.qualityEventsInitialized = false;
+
+ if (this.options.debug) {
+ console.log('🔍 initializeDash - FORCED selectedQuality to:', this.selectedQuality);
+ }
+
  if (this.dashPlayer) {
  this.dashPlayer.destroy();
  }
@@ -6542,17 +6663,67 @@ disableDashTextTracks() {
  }
  }
 
- updateAdaptiveQualities() {
+updateAdaptiveQualities() {
  this.adaptiveQualities = [];
 
  if (this.adaptiveStreamingType === 'dash' && this.dashPlayer) {
- const bitrates = this.dashPlayer.getBitrateInfoListFor('video');
- this.adaptiveQualities = bitrates.map((bitrate, index) => ({
- index: index,
- label: this.getQualityLabel(bitrate.height, bitrate.width),
+ try {
+
+ const videoTracks = this.dashPlayer.getTracksFor('video');
+
+ if (this.options.debug) {
+ console.log('✅ DASH getTracksFor result:', videoTracks);
+ }
+
+ if (videoTracks && videoTracks.length > 0) {
+
+ const allQualities = [];
+
+ videoTracks.forEach((track, trackIndex) => {
+ const bitrateList = track.bitrateList || [];
+
+ if (this.options.debug) {
+ console.log(`✅ Track ${trackIndex} (${track.codec}):`, bitrateList);
+ }
+
+ bitrateList.forEach((bitrate, index) => {
+ allQualities.push({
+ trackIndex: trackIndex,
+ bitrateIndex: index,
+ label: `${bitrate.height}p`,
  height: bitrate.height,
- bandwidth: bitrate.bandwidth
- }));
+ width: bitrate.width,
+ bandwidth: bitrate.bandwidth,
+ codec: track.codec
+ });
+ });
+ });
+
+ const uniqueHeights = [...new Set(allQualities.map(q => q.height))];
+ uniqueHeights.sort((a, b) => b - a);
+
+ this.adaptiveQualities = uniqueHeights.map((height, index) => {
+ const quality = allQualities.find(q => q.height === height);
+ return {
+ index: index,
+ label: `${height}p`,
+ height: height,
+ trackIndex: quality.trackIndex,
+ bitrateIndex: quality.bitrateIndex,
+ bandwidth: quality.bandwidth,
+ codec: quality.codec
+ };
+ });
+
+ if (this.options.debug) {
+ console.log('✅ All DASH qualities merged:', this.adaptiveQualities);
+ }
+ }
+ } catch (error) {
+ if (this.options.debug) {
+ console.error('❌ Error getting DASH qualities:', error);
+ }
+ }
  } else if (this.adaptiveStreamingType === 'hls' && this.hlsPlayer) {
  const levels = this.hlsPlayer.levels;
  this.adaptiveQualities = levels.map((level, index) => ({
@@ -6569,8 +6740,360 @@ disableDashTextTracks() {
 
  if (this.options.debug) {
  console.log('📡 Adaptive qualities available:', this.adaptiveQualities);
+ console.log('📡 Selected quality mode:', this.selectedQuality);
+ }
+}
+
+updateAdaptiveQualityMenu() {
+ const qualityMenu = this.controls?.querySelector('.quality-menu');
+ if (!qualityMenu) {
+ if (this.options.debug) console.log('❌ Quality menu not found in DOM');
+ return;
+ }
+
+ if (this.adaptiveQualities.length === 0) {
+ if (this.options.debug) console.log('❌ No adaptive qualities to display');
+ return;
+ }
+
+ const isAutoActive = this.selectedQuality === 'auto';
+ let menuHTML = `<div class="quality-option ${isAutoActive ? 'active' : ''}" data-quality="auto">Auto</div>`;
+
+ this.adaptiveQualities.forEach((quality) => {
+ const isActive = this.selectedQuality === quality.height;
+
+ if (this.options.debug) {
+ console.log('🔍 Quality item:', quality.label, 'height:', quality.height, 'active:', isActive);
+ }
+
+ menuHTML += `<div class="quality-option ${isActive ? 'active' : ''}" data-quality="${quality.height}">
+ ${quality.label}
+ <span class="quality-playing" style="display: none; color: #4CAF50; margin-left: 8px; font-size: 0.85em;">● Playing</span>
+ </div>`;
+ });
+
+ qualityMenu.innerHTML = menuHTML;
+
+ if (this.options.debug) {
+ console.log('✅ Quality menu populated with', this.adaptiveQualities.length, 'options');
+ }
+
+ if (!this.qualityEventsInitialized) {
+ this.bindAdaptiveQualityEvents();
+ this.qualityEventsInitialized = true;
+ }
+
+ this.updateAdaptiveQualityDisplay();
+}
+
+updateAdaptiveQualityDisplay() {
+ if (!this.dashPlayer && !this.hlsPlayer) return;
+
+ let currentHeight = null;
+
+ try {
+ if (this.adaptiveStreamingType === 'dash' && this.dashPlayer) {
+
+ if (this.video && this.video.videoHeight) {
+ currentHeight = this.video.videoHeight;
+ }
+
+ if (this.options.debug) {
+ console.log('📊 Current video height:', currentHeight, 'Selected mode:', this.selectedQuality);
+ }
+ } else if (this.adaptiveStreamingType === 'hls' && this.hlsPlayer) {
+ const currentLevel = this.hlsPlayer.currentLevel;
+ if (currentLevel >= 0 && this.hlsPlayer.levels[currentLevel]) {
+ currentHeight = this.hlsPlayer.levels[currentLevel].height;
+ }
+ }
+
+ const qualityBtnText = this.controls?.querySelector('.quality-btn .selected-quality');
+ if (qualityBtnText) {
+ if (this.selectedQuality === 'auto') {
+ qualityBtnText.textContent = 'Auto';
+ } else {
+ qualityBtnText.textContent = `${this.selectedQuality}p`;
+ }
+ }
+
+ const currentQualityText = this.controls?.querySelector('.quality-btn .current-quality');
+ if (currentQualityText) {
+ if (this.selectedQuality === 'auto' && currentHeight) {
+ currentQualityText.textContent = `${currentHeight}p`;
+ currentQualityText.style.display = 'block';
+ } else {
+ currentQualityText.textContent = '';
+ currentQualityText.style.display = 'none';
+ }
+ }
+
+ const qualityMenu = this.controls?.querySelector('.quality-menu');
+ if (qualityMenu) {
+
+ qualityMenu.querySelectorAll('.quality-option').forEach(opt => {
+ opt.classList.remove('active');
+ });
+
+ if (this.selectedQuality === 'auto') {
+ const autoOption = qualityMenu.querySelector('[data-quality="auto"]');
+ if (autoOption) autoOption.classList.add('active');
+ } else {
+ const selectedOption = qualityMenu.querySelector(`[data-quality="${this.selectedQuality}"]`);
+ if (selectedOption) selectedOption.classList.add('active');
+ }
+
+ qualityMenu.querySelectorAll('.quality-playing').forEach(el => {
+ el.style.display = 'none';
+ });
+
+ if (this.selectedQuality === 'auto' && currentHeight) {
+ const playingOption = qualityMenu.querySelector(`[data-quality="${currentHeight}"] .quality-playing`);
+ if (playingOption) {
+ playingOption.style.display = 'inline';
+ }
+ }
+ }
+
+ } catch (error) {
+ if (this.options.debug) console.error('❌ Error updating quality display:', error);
+ }
+}
+
+updateQualityButtonText() {
+ const qualityBtn = this.controls?.querySelector('.quality-btn .selected-quality');
+ if (!qualityBtn) return;
+
+ if (this.selectedQuality === 'auto' || !this.selectedQuality) {
+ qualityBtn.textContent = this.t('auto');
+ } else {
+ const quality = this.adaptiveQualities.find(q => q.index === parseInt(this.selectedQuality));
+ qualityBtn.textContent = quality ? quality.label : 'Auto';
+ }
+}
+
+bindAdaptiveQualityEvents() {
+ const qualityMenu = this.controls?.querySelector('.quality-menu');
+ const qualityBtn = this.controls?.querySelector('.quality-btn');
+
+ if (!qualityMenu || !qualityBtn) return;
+
+ qualityBtn.addEventListener('click', (e) => {
+ e.stopPropagation();
+ qualityMenu.classList.toggle('active');
+
+ if (qualityMenu.classList.contains('active')) {
+ this.updateAdaptiveQualityDisplay();
+ }
+ });
+
+ const closeMenuHandler = (e) => {
+ if (!qualityBtn.contains(e.target) && !qualityMenu.contains(e.target)) {
+ qualityMenu.classList.remove('active');
+ }
+ };
+ document.addEventListener('click', closeMenuHandler);
+
+ qualityMenu.addEventListener('click', (e) => {
+ const option = e.target.closest('.quality-option');
+ if (!option) return;
+
+ e.stopPropagation();
+
+ const qualityData = option.getAttribute('data-quality');
+
+ if (this.options.debug) {
+ console.log('🎬 Quality clicked - raw data:', qualityData, 'type:', typeof qualityData);
+ }
+
+ if (qualityData === 'auto') {
+
+ this.selectedQuality = 'auto';
+
+ if (this.adaptiveStreamingType === 'dash' && this.dashPlayer) {
+ this.dashPlayer.updateSettings({
+ streaming: {
+ abr: {
+ autoSwitchBitrate: { video: true }
+ }
+ }
+ });
+ if (this.options.debug) console.log('✅ Auto quality enabled');
+ } else if (this.adaptiveStreamingType === 'hls' && this.hlsPlayer) {
+ this.hlsPlayer.currentLevel = -1;
+ }
+
+ } else {
+
+ const selectedHeight = parseInt(qualityData, 10);
+
+ if (isNaN(selectedHeight)) {
+ if (this.options.debug) console.error('❌ Invalid quality data:', qualityData);
+ return;
+ }
+
+ if (this.options.debug) {
+ console.log('🎬 Setting manual quality to height:', selectedHeight);
+ }
+
+ this.selectedQuality = selectedHeight;
+
+ if (this.adaptiveStreamingType === 'dash') {
+ this.setDashQualityByHeight(selectedHeight);
+ } else if (this.adaptiveStreamingType === 'hls') {
+ const levelIndex = this.hlsPlayer.levels.findIndex(l => l.height === selectedHeight);
+ if (levelIndex >= 0) {
+ this.hlsPlayer.currentLevel = levelIndex;
+ }
+ }
+ }
+
+ this.updateAdaptiveQualityDisplay();
+
+ qualityMenu.classList.remove('active');
+ });
+
+ if (this.options.debug) {
+ console.log('✅ Quality events bound');
+ }
+}
+
+setDashQualityByHeight(targetHeight) {
+ if (!this.dashPlayer) return;
+
+ try {
+ const targetQuality = this.adaptiveQualities.find(q => q.height === targetHeight);
+ if (!targetQuality) {
+ if (this.options.debug) console.error('❌ Quality not found for height:', targetHeight);
+ return;
+ }
+
+ if (this.options.debug) {
+ console.log('🎬 Setting quality:', targetQuality);
+ }
+
+ this.dashPlayer.updateSettings({
+ streaming: {
+ abr: {
+ autoSwitchBitrate: { video: false }
+ }
+ }
+ });
+
+ const currentTrack = this.dashPlayer.getCurrentTrackFor('video');
+
+ if (!currentTrack) {
+ if (this.options.debug) console.error('❌ No current video track');
+ return;
+ }
+
+ const allTracks = this.dashPlayer.getTracksFor('video');
+ let targetTrack = null;
+
+ for (const track of allTracks) {
+ if (track.bitrateList && track.bitrateList[targetQuality.bitrateIndex]) {
+ const bitrate = track.bitrateList[targetQuality.bitrateIndex];
+ if (bitrate.height === targetHeight) {
+ targetTrack = track;
+ break;
+ }
+ }
+ }
+
+ if (!targetTrack) {
+ if (this.options.debug) console.error('❌ Target track not found');
+ return;
+ }
+
+ if (currentTrack.index !== targetTrack.index) {
+ this.dashPlayer.setCurrentTrack(targetTrack);
+ if (this.options.debug) {
+ console.log('✅ Switched to track:', targetTrack.index);
+ }
+ }
+
+ setTimeout(() => {
+ try {
+
+ this.dashPlayer.updateSettings({
+ streaming: {
+ abr: {
+ initialBitrate: { video: targetQuality.bandwidth / 1000 },
+ maxBitrate: { video: targetQuality.bandwidth / 1000 },
+ minBitrate: { video: targetQuality.bandwidth / 1000 }
+ }
+ }
+ });
+
+ if (this.options.debug) {
+ console.log('✅ Quality locked to:', targetHeight + 'p', 'bandwidth:', targetQuality.bandwidth);
+ }
+
+ const qualityBtnText = this.controls?.querySelector('.quality-btn .selected-quality');
+ if (qualityBtnText) {
+ qualityBtnText.textContent = `${targetHeight}p`;
+ }
+
+ const currentTime = this.video.currentTime;
+ this.dashPlayer.seek(currentTime + 0.1);
+ setTimeout(() => {
+ this.dashPlayer.seek(currentTime);
+ }, 100);
+
+ } catch (innerError) {
+ if (this.options.debug) console.error('❌ Error setting quality:', innerError);
+ }
+ }, 100);
+
+ } catch (error) {
+ if (this.options.debug) console.error('❌ Error in setDashQualityByHeight:', error);
+ }
+}
+
+setDashQuality(qualityIndex) {
+ if (!this.dashPlayer) return;
+
+ try {
+ const selectedQuality = this.adaptiveQualities[qualityIndex];
+ if (!selectedQuality) {
+ if (this.options.debug) console.error('❌ Quality not found at index:', qualityIndex);
+ return;
+ }
+
+ if (this.options.debug) {
+ console.log('🎬 Setting DASH quality:', selectedQuality);
+ }
+
+ this.dashPlayer.updateSettings({
+ streaming: {
+ abr: {
+ autoSwitchBitrate: { video: false }
+ }
+ }
+ });
+
+ setTimeout(() => {
+ try {
+ this.dashPlayer.setQualityFor('video', selectedQuality.bitrateIndex);
+
+ if (this.options.debug) {
+ console.log('✅ DASH quality set to bitrateIndex:', selectedQuality.bitrateIndex, 'height:', selectedQuality.height);
+ }
+
+ const qualityBtnText = this.controls?.querySelector('.quality-btn .selected-quality');
+ if (qualityBtnText) {
+ qualityBtnText.textContent = selectedQuality.label;
+ }
+
+ } catch (innerError) {
+ if (this.options.debug) console.error('❌ Error setting quality:', innerError);
  }
+ }, 100);
+
+ } catch (error) {
+ if (this.options.debug) console.error('❌ Error in setDashQuality:', error);
  }
+}
 
  handleAdaptiveError(data) {
  if (this.options.debug) console.error('📡 Fatal adaptive streaming error:', data);
@@ -6901,20 +7424,20 @@ getBufferedTime() {
  } catch (error) {
  return 0;
  }
- }
+}
 
- clearTitleTimeout() {
+clearTitleTimeout() {
  if (this.titleTimeout) {
  clearTimeout(this.titleTimeout);
  this.titleTimeout = null;
  }
- }
+}
 
- skipTime(seconds) {
+skipTime(seconds) {
  if (!this.video || !this.video.duration || this.isChangingQuality) return;
 
  this.video.currentTime = Math.max(0, Math.min(this.video.duration, this.video.currentTime + seconds));
- }
+}
 
 updateTimeDisplay() {
 
@@ -6924,20 +7447,34 @@ updateTimeDisplay() {
 
  if (this.durationEl && this.video) {
  const duration = this.video.duration;
+ const readyState = this.video.readyState;
+ const currentTime = this.video.currentTime;
+ const networkState = this.video.networkState;
+
+ const isInitialBuffering = (readyState < 2 && currentTime === 0) ||
+ (currentTime === 0 && (!duration || duration === 0) && networkState === 2);
+
+ const isDurationInvalid = !duration || isNaN(duration) || !isFinite(duration);
 
- if (!duration || isNaN(duration) || !isFinite(duration)) {
+ if (isInitialBuffering) {
 
- this.durationEl.innerHTML = '<span class="encoding-badge">Encoding in progress</span>';
+ this.durationEl.textContent = t('loading');
+ this.durationEl.classList.remove('encoding-state');
+ this.durationEl.classList.add('loading-state');
+ } else if (isDurationInvalid) {
+
+ this.durationEl.textContent = t('encoding_in_progress');
+ this.durationEl.classList.remove('loading-state');
  this.durationEl.classList.add('encoding-state');
  } else {
 
  this.durationEl.textContent = this.formatTime(duration);
- this.durationEl.classList.remove('encoding-state');
+ this.durationEl.classList.remove('encoding-state', 'loading-state');
  }
  }
 }
 
- formatTime(seconds) {
+formatTime(seconds) {
  if (isNaN(seconds) || seconds < 0) return '0:00';
 
  const hours = Math.floor(seconds / 3600);
@@ -6948,7 +7485,7 @@ updateTimeDisplay() {
  return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
  }
  return `${minutes}:${secs.toString().padStart(2, '0')}`;
- }
+}
 
 }