C:/Projekte/I2BPro/src/i2bpro/playlist/M3U.java

package i2bpro.playlist;

import i2bpro.layer.Dialogs.Utils;
import i2bpro.layer.Layer;
import java.awt.Cursor;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.HashMap;
import org.jaudiotagger.audio.AudioFile;
import org.jaudiotagger.audio.AudioFileIO;
import org.jaudiotagger.audio.exceptions.CannotReadException;
import org.jaudiotagger.audio.exceptions.CannotWriteException;
import org.jaudiotagger.audio.exceptions.InvalidAudioFrameException;
import org.jaudiotagger.audio.exceptions.ReadOnlyFileException;
import org.jaudiotagger.tag.FieldKey;
import org.jaudiotagger.tag.KeyNotFoundException;
import org.jaudiotagger.tag.TagException;



public final class M3U extends basePlayList
{
    M3U(String filename) throws FileNotFoundException, IOException, 
            CannotReadException, TagException, ReadOnlyFileException,
            InvalidAudioFrameException
    {
        //  Deklaration
        BufferedReader f;
        String line;
        String[] tmp;
        String extm3u = null;
        f = new BufferedReader( new FileReader(filename));

        playlist.clear();
        playlisttype = "m3u_1";

        while((line = f.readLine()) != null)
        {
            tmp = line.trim().toUpperCase().split(":");
            if ((tmp[0].equals("$EXTM3U")) ||
                    (tmp[0].equals("#EXTM3U")) ||
                    (tmp[0].equals("$EXTM3U")))
            {
                playlisttype = "m3u_2";
            } else {
                if (tmp[0].equals("#EXTINF"))
                {
                    extm3u = line;
                } else {
                    writeToPlayList(line, extm3u);
                    extm3u = null;
                }
            }
        }
        f.close();
    }



    public void SavePlayList(String filename, String type, HashMap<Integer,
            HashMap<String, String>> list) throws IOException
            
    {
        // Die Wiedergabeliste des Audioplayers wird auf die der
        //  übergebenen gesetzt.
        playlist = list;

        //  extm3u dient der Abfrage ob es sich um eine einfache (false) oder
        //  um eine erweiterte (true) M3U-Wiedergabeliste handelt.
        boolean extm3u = false; 
        if (type.equals("m3u_2")) extm3u = true;

        //  Anlegen des Dateischreibers. (-:
        BufferedWriter f = new BufferedWriter( new FileWriter(filename));
        if (extm3u)
        {
            //  Für den Fall einer erweiterten M3U - Wiedergabeliste
            //  ist mit der ersten Zeile die Kennung für eine erweiterte
            //  M3U-Wiedergabeliste zu speichern.
            f.write("$EXTM3U");
            f.newLine();
        }

        //  Die folgende Schleife geht alle Audiotitel der Wiedergabeliste
        for(int i=0; i<playlist.size(); i++)
        {
            if (extm3u)
            {
                //  Bei einer erweiterten M3U - Wiedergabeliste sind die
                //  zusätzlichen Zeilen zu speichern.
                f.write((String)playlist.get(i).get("extm3u"));
                f.newLine();
            }

            //  Pfadangabe zur Audiodatei als einzelne Zeile speichern
            f.write((String)playlist.get(i).get("media"));
            if (i != playlist.size() -1 ) f.newLine();

            //  Die folgenden Zeilen dienen dazu die MEtadaten aus der
            //  Wiedergabeliste auszulesen und in die Audiodateien zu schreiben.
            //  Hier werden derzeit nur mp3-Dateien berücksichtigt
            //  (siehe oben die MEthodenbeschreibung.)
            File file = new File((String)playlist.get(i).get("media"));
            try {
                AudioFile audiofile =AudioFileIO.read(file);
                audiofile.getTag().setField(FieldKey.TITLE, playlist.get(i).get("title"));
                audiofile.getTag().setField(FieldKey.ALBUM_ARTIST, playlist.get(i).get("album_artist"));
                audiofile.getTag().setField(FieldKey.ALBUM, playlist.get(i).get("album"));
                audiofile.getTag().setField(FieldKey.YEAR, playlist.get(i).get("year"));
                audiofile.getTag().setField(FieldKey.GENRE, playlist.get(i).get("genre"));
                audiofile.commit();
            }
            catch (CannotReadException ex) {}
            catch (TagException ex) {}
            catch (ReadOnlyFileException ex) {}
            catch (InvalidAudioFrameException ex) {}
            catch (KeyNotFoundException ex) {}
            catch (CannotWriteException ex) {}
            catch (NullPointerException ex) {}
        }

        //  Schließen des Dateischreibers.
        f.close();
    }



    public void InsertMedia(File[] selectedFiles) throws CannotReadException, 
            IOException, TagException, ReadOnlyFileException,
            InvalidAudioFrameException
    {
        //  Deklaration
        String filename;
        String extm3u;
        File file;

        //  Setzens des Warte-Cursors.
        Cursor old_cursor = Layer.getInstance().getCursor();
        Layer.getInstance().setCursor(new Cursor(Cursor.WAIT_CURSOR));

        //  Die folgende Schleife geht die Liste der Audiodateien durch und
        //  versucht diese der Wiedergabeliste hinzuzufügen.
        for (int i=0; i<selectedFiles.length; i++)
        {
            //  vollständigen Pfad zur datei auslesen
            filename = selectedFiles[i].getAbsolutePath();
            extm3u = null;
            if (playlisttype.equals("m3u_2"))
            {
                //  Wenn die Wiedergabeliste eine erweiterte m3u-Liste ist,
                //  dann sind die Angaben der zusätzlichen Zeile auszulesen.
                file = new File(filename);
                AudioFile audiofile = AudioFileIO.read(file);
                extm3u = "#EXTINF:";
                extm3u += audiofile.getAudioHeader().getTrackLength();
                String title = audiofile.getTag().getFirst(FieldKey.TITLE);
                extm3u += ",";

                //  Sollte kein Audiotitel in der Audiodatei gespeichert sein,
                //  so ist der Dateiname als Titel zu übernehmen.
                extm3u += (title == null) ? file.getName() : title;
            }
            //  Sind alle Angaben zur Audiodatei für die m3u-Wiedergabeliste
            //  zusammengestellt, so sind diese der MEthode writetoPlayList zu
            //  übergeben, welche diese in die Wiedergabeliste schreibt.
            writeToPlayList(filename, extm3u);
        }
        //  Alten Cursor wieder herstellen
        Layer.getInstance().setCursor(old_cursor);
    }



    protected void writeToPlayList(String line, String extm3u)
            throws CannotReadException, IOException, TagException,
            ReadOnlyFileException, InvalidAudioFrameException
    {
        //  Deklaration
        int i = playlist.size();

        //  Anlegen eines neuen Eintrags in die Wiedergabeliste
        playlist.put(i, new HashMap<String, String>());

        String extension = Utils.getExtension(new File(line));
        if (extension.equals(Utils.wav))
        {
            //  Handelt es sich um eine wav-Datei, dann die Metadaten
            //  über das WavTag-Object ermitteln und in der Wiedergabeliste
            //  speichern
            WavTag wavtag = new WavTag(line);
            playlist.get(i).putAll(wavtag.getMetaDaten());
        }
        else if (extension.equals(Utils.mp3))
        {
            // Handelt es sich um eine mp3-Datei dann die Metadaten über das
            //  ID3v2-Object ermitteln und in der Wiedergabeliste speichern
            ID3v2 id3 = new ID3v2(line);
            playlist.get(i).putAll(id3.getMetaDaten());
        }
        //  erwiterte Zeile einer erweiterten M3U-Wiedergabeliste speichern
        playlist.get(i).put("extm3u", extm3u);

        //  Pfadangabe zur Audiodatei speichern
        playlist.get(i).put("media", line);

        //  Startposition des Tracks innerhalb der Audiodatei
        playlist.get(i).put("index", "00:00:00");
    }
}