CLASS PERMETTANT D'EXTRAIRE ET D'AFFICHER LE TAG CONTENU DANS UN MP3

import java.io.*;

public class tagMP3 {
  private byte[] octets;
  private boolean estTag;
  public tagMP3() {
    octets=new byte[128];
    estTag=false;
  }
  /**
   * Met a jour l'attribut octets de l'objet, avec les 128 derniers octets du mp3.
   * @param chemin String contenant le chemin absolu vers le fichier MP3
   * @throws FichierException si le fichier ne semble pas etre un MP3 valide
   * @throws FileNotFoundException si le fichier est introuvable
   * @throws IOException si il y a une erreur de lecture sur le flux
   */
  public void ouvrirFichier(String chemin) throws FichierException, FileNotFoundException, IOException {
    FileInputStream f_input=new FileInputStream(chemin);
    int nb_octet=f_input.available();
    if(nb_octet<=128) throw new FichierException("le fichier semble incorrect");
    else {
      int premier_octet = nb_octet - 128;
      double octet_skiped = f_input.skip(premier_octet);
      int octet_lu = f_input.read(this.octets);
      // on test pour savoir si la chaine correspond bien a un TAG
      if((this.octets[0]==84)&&(this.octets[1]==65)&&(this.octets[2]==71)) {
        this.estTag=true;
      }
      }
      f_input.close();

  }
  /**
   * Affiche les 128 octets du TAG
   * @return une string contenant les 128 octets du TAG
   */

  public String toString() {
    String retour="";
    for(int i=0;i<this.octets.length;i++) {
      retour=retour+this.octets[i];
    }
    return retour;
  }
  /**
   * Cette methode permet de tester si les 128 octets correspondent bien a un mp3 TAG
   * @return vrai si c'est bien un mp3TAG
   */
  public boolean estTagMp3() {
    return this.estTag;
  }
  /**
   * Retourne le nom de l'artiste
   * @return nom de l'artiste
   */
  public String nomArtiste() {
    byte[] chaine_artiste=new byte[30];
    for(int i=0;i<chaine_artiste.length;i++) {
      chaine_artiste[i]=this.octets[33+i];
    }
    // on est obligé d'utiliser un second tableau, de taille differente,
    // qui contient les caracteres sans les '0' a la fin.
    byte[] affichage_artiste=new byte[30-this.nbCaractereVide(chaine_artiste)];
    for (int i=0;i<affichage_artiste.length;i++) {
      affichage_artiste[i]=chaine_artiste[i];
    }
    String nom_artiste=new String(affichage_artiste);
    return nom_artiste;

  }
  /**
   * Retourne le titre d'un mp3
   * @return le titre
   */

  public String nomTitre() {
    byte[] chaine_titre=new byte[30];
    for(int i=0;i<chaine_titre.length;i++) {
      chaine_titre[i]=this.octets[3+i];
    }
    byte[] affichage_titre=new byte[30-this.nbCaractereVide(chaine_titre)];
    for(int i=0;i<affichage_titre.length;i++) {
      affichage_titre[i]=chaine_titre[i];
    }
    String titre=new String(affichage_titre);
    return titre;
  }
  /**
   * Retourne le nom de l'album
   * @return nom de l'album
   */
  public String nomAlbum() {
    byte[] chaine_album=new byte[30];
    for(int i=0;i<chaine_album.length;i++) {
      chaine_album[i]=this.octets[i+63];
    }
    byte[] affichage_album=new byte[30-this.nbCaractereVide(chaine_album)];
    for(int i=0;i<affichage_album.length;i++) {
      affichage_album[i]=chaine_album[i];
    }
    String nom_album=new String(affichage_album);
    return nom_album;
  }
  /**
   * Retourne l'annee du mp3
   * @return l'annee (Une string vide si ce n'est pas defini)
   */
  public String annee() {
    byte[] chaine_annee=new byte[4];
    for(int i=0;i<chaine_annee.length;i++) {
      chaine_annee[i]=this.octets[i+93];
    }
    String annee;
    if((chaine_annee[0]==0)&&(chaine_annee[1]==0)&&(chaine_annee[2]==0)&&(chaine_annee[3]==0)) {
      annee="";
    }
    else annee=new String(chaine_annee);
    return annee;

  }
  /**
   * Retourne le commentaire associé a un mp3
   * @return le commentaire
   */
  public String commentaire() {
    byte[] chaine_commentaire=new byte[29];
    for(int i=0;i<chaine_commentaire.length;i++) {
      chaine_commentaire[i]=this.octets[i+97];
    }
    int nb_vide=this.nbCaractereVide(chaine_commentaire);
    byte[] affichage_commentaire=new byte[29-this.nbCaractereVide(chaine_commentaire)];
    for(int i=0;i<affichage_commentaire.length;i++) {
      affichage_commentaire[i]=chaine_commentaire[i];
    }
    String commentaire=new String(affichage_commentaire);
    return commentaire;
  }
  /**
   * Cette methode calcul le nombre de caractere vide (=0) dans un tableau de byte
   * @param b le tableau de byte
   * @return le nombre de caracteres vides
   */
  public int nbCaractereVide(byte[] b) {
    int retour=0;
    for(int i=0;i<b.length;i++) {
      if(b[i]==0) retour++;
    }
    return retour;
  }

}