Référence API

const player = new M3U8Player(options);

const options = {
  container: '#player', // Sélecteur du conteneur du lecteur
  autoplay: false, // Lecture automatique
  muted: true, // État muet
  preload: 'metadata', // Configuration de préchargement
  width: '100%', // Largeur du lecteur
  height: 'auto', // Hauteur du lecteur
  controls: true, // Afficher les contrôles
  fluid: true, // Responsive
  responsive: true, // Support responsive
  playbackRates: [0.5, 1, 1.25, 1.5, 2], // Vitesses de lecture
  defaultPlaybackRate: 1, // Vitesse de lecture par défaut
  language: 'fr', // Configuration de langue
  techOrder: ['html5'], // Ordre de priorité des technologies
  html5: {
    vhs: {
      overrideNative: true, // Remplacer HLS natif
      enableLowInitialPlaylist: true,
      smoothQualityChange: true,
      handlePartialData: true,
    },
  },
};

player.load(url);

try {
  await player.load('https://example.com/stream.m3u8');
  console.log('Stream chargé avec succès');
} catch (error) {
  console.error('Erreur lors du chargement du stream:', error);
}

player.play();

player.pause();

// Obtenir le temps actuel
const currentTime = player.currentTime();

// Définir le temps
player.currentTime(120); // Définir à 2 minutes

const duration = player.duration();

// Obtenir le volume (0.0 - 1.0)
const volume = player.volume();

// Définir le volume
player.volume(0.5); // Définir à 50%

// Obtenir l'état muet
const isMuted = player.muted();

// Définir l'état muet
player.muted(true); // Couper le son
player.muted(false); // Remettre le son

const isPaused = player.paused();

const isEnded = player.ended();

const readyState = player.readyState();

const networkState = player.networkState();

player.on('loadstart', () => {
  console.log('Début du chargement du stream');
});

player.on('loadedmetadata', () => {
  console.log('Métadonnées chargées');
  console.log('Durée:', player.duration());
});

player.on('loadeddata', () => {
  console.log('Premier frame chargé');
});

player.on('canplay', () => {
  console.log('Prêt à lire');
});

player.on('canplaythrough', () => {
  console.log("Prêt à lire jusqu'à la fin");
});

player.on('play', () => {
  console.log('Lecture démarrée');
});

player.on('pause', () => {
  console.log('Lecture en pause');
});

player.on('ended', () => {
  console.log('Lecture terminée');
});

player.on('timeupdate', () => {
  const currentTime = player.currentTime();
  const duration = player.duration();
  const progress = (currentTime / duration) * 100;
  console.log(`Progression: ${progress.toFixed(1)}%`);
});

player.on('volumechange', () => {
  console.log('Volume:', player.volume());
  console.log('Muet:', player.muted());
});

player.on('error', (error) => {
  console.error('Erreur du lecteur:', error);
});

const hls = player.hls;

const levels = player.hls.levels;
console.log('Niveaux de qualité disponibles:', levels);

// Obtenir le niveau actuel
const currentLevel = player.hls.currentLevel;

// Définir le niveau
player.hls.currentLevel = 2; // Définir au troisième niveau

const nextLevel = player.hls.nextLevel;

const loadLevel = player.hls.loadLevel;

const bandwidth = player.hls.bandwidth;
console.log('Bande passante estimée:', bandwidth, 'bps');

// Définir le niveau initial
player.hls.startLevel = 1;

player.hls.startLoad();

player.hls.stopLoad();

player.hls.swapAudioCodec();

player.hls.recoverMediaError();

player.on('hlsEvent', (event, data) => {
  console.log('Événement HLS:', event, data);
});

player.on('levelLoaded', (event, data) => {
  console.log('Niveau de qualité chargé:', data);
});

player.on('levelSwitched', (event, data) => {
  console.log('Niveau de qualité changé:', data);
});

player.on('fragLoaded', (event, data) => {
  console.log('Fragment chargé:', data);
});

player.on('eventName', callback);

player.off('eventName', callback);

player.one('eventName', callback);

player.trigger('customEvent', data);

player.on('qualitychange', (event, data) => {
  console.log('Changement de qualité:', {
    from: data.from,
    to: data.to,
    reason: data.reason,
  });
});

player.on('bufferwarning', (event, data) => {
  console.log('Avertissement de buffer:', data);
});

player.on('error', (error) => {
  if (error.code === 1) {
    console.log('Erreur de média: Abandonné');
  } else if (error.code === 2) {
    console.log('Erreur de média: Réseau');
  } else if (error.code === 3) {
    console.log('Erreur de média: Décodage');
  } else if (error.code === 4) {
    console.log('Erreur de média: Source non supportée');
  }
});

player.on('error', (error) => {
  if (error.type === 'networkError') {
    console.log('Erreur de réseau');
  } else if (error.type === 'mediaError') {
    console.log('Erreur de média');
  }
});

player.on('error', (error) => {
  console.log('Erreur survenue:', error);
  // Le lecteur tente automatiquement de récupérer
});

player.on('error', (error) => {
  if (error.type === 'mediaError') {
    // Pour les erreurs de média, tenter une récupération manuelle
    player.hls.recoverMediaError();
  }
});

function formatTime(seconds) {
  const hours = Math.floor(seconds / 3600);
  const minutes = Math.floor((seconds % 3600) / 60);
  const secs = Math.floor(seconds % 60);

  if (hours > 0) {
    return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
  } else {
    return `${minutes}:${secs.toString().padStart(2, '0')}`;
  }
}

// Exemple d'utilisation
const currentTime = player.currentTime();
console.log('Temps actuel:', formatTime(currentTime));

function getQualityLevels() {
  return player.hls.levels.map((level, index) => ({
    index: index,
    height: level.height,
    width: level.width,
    bitrate: level.bitrate,
    name: `${level.height}p`,
  }));
}

const qualityLevels = getQualityLevels();
console.log('Niveaux de qualité disponibles:', qualityLevels);

function setQualityLevel(levelIndex) {
  if (levelIndex >= 0 && levelIndex < player.hls.levels.length) {
    player.hls.currentLevel = levelIndex;
    console.log(`Niveau de qualité défini à ${levelIndex}`);
  } else {
    console.error('Niveau de qualité invalide');
  }
}