private boolean setAlbumArt(
      byte[] imageBytes,
      String mp3Filename,
      String mp3outputFilename,
      String username,
      String title,
      String detailsUrl) {
    try {
      AudioFile f = AudioFileIO.read(new File(mp3Filename));
      Tag tag = f.getTagOrCreateAndSetDefault();

      tag.setField(FieldKey.ALBUM, username + ": " + title + " via SoundCloud.com");
      tag.setField(FieldKey.ARTIST, username);
      tag.setField(FieldKey.TITLE, title);
      tag.setField(FieldKey.URL_OFFICIAL_RELEASE_SITE, detailsUrl);

      Artwork artwork = ArtworkFactory.getNew();
      artwork.setBinaryData(imageBytes);
      artwork.setMimeType("image/jpg");

      tag.addField(artwork);

      f.commit();

      return true;
    } catch (Throwable e) {
      return false;
    }
  }
 private void fillMetaInfo() {
   if (tag == null) {
     title = audioFile.getFile().getName();
     artist = "";
     album = "";
     album_artist = "";
     track = "";
     composer = "";
     year = "";
     diskNumber = "";
     genre = "";
   } else {
     title = tag.getFirst(FieldKey.TITLE);
     if (title.equals("")) {
       title = audioFile.getFile().getName();
     }
     artist = tag.getFirst(FieldKey.ARTIST);
     album = tag.getFirst(FieldKey.ALBUM);
     album_artist = tag.getFirst(FieldKey.ALBUM_ARTIST);
     track = tag.getFirst(FieldKey.TRACK);
     composer = tag.getFirst(FieldKey.COMPOSER);
     year = tag.getFirst(FieldKey.YEAR);
     diskNumber = tag.getFirst(FieldKey.DISC_NO);
     genre = tag.getFirst(FieldKey.GENRE);
   }
 }
  public void testWriteToRelativeMp3File() {
    File orig = new File("testdata", "testV1.mp3");
    if (!orig.isFile()) {
      System.err.println("Unable to test file - not available");
      return;
    }

    File testFile = null;
    Exception exceptionCaught = null;
    try {
      testFile = AbstractTestCase.copyAudioToTmp("testV1.mp3");

      // Copy up a level coz we need it to be in same folder as working directory so can just
      // specify filename
      File outputFile = new File(testFile.getName());
      boolean result = copy(testFile, outputFile);
      assertTrue(result);

      // make Relative
      assertTrue(outputFile.exists());
      // Read File okay
      AudioFile af = AudioFileIO.read(outputFile);

      // Create tag and Change File
      af.getTagOrCreateAndSetDefault();
      af.getTag().setField(ArtworkFactory.createArtworkFromFile(new File("testdata/coverart.jpg")));
      af.commit();

    } catch (Exception e) {
      e.printStackTrace();
      exceptionCaught = e;
    }

    assertNull(exceptionCaught);
  }
  /**
   * Parse the tmp file for tag data and create associated song
   *
   * @param dfi
   * @return song created from tag data
   */
  public static Song parseFileForSong(DiskFileItem dfi) { // TODO Think about where to move this.
    File audioFile = new File(dfi.getStoreLocation().toString().replace(".tmp", ".mp3"));
    //	"."+dfi.getContentType().substring(dfi.getContentType().indexOf("/")+1)));

    if (!dfi.getStoreLocation().renameTo(audioFile)) {
      log.error(
          "rename failed - store location:" + dfi.getStoreLocation() + ", audio file:" + audioFile);
    }

    AudioFile f = null;
    try {
      f = AudioFileIO.read(audioFile);
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    Tag tag = f.getTag();
    if (tag == null) {
      tag = f.getTagOrCreateAndSetDefault();
    }
    Song song = new Song();
    try {
      song.setArtist(tag.getFirst(FieldKey.ARTIST));
      song.setAlbum(tag.getFirst(FieldKey.ALBUM));
      song.setTitle(tag.getFirst(FieldKey.TITLE));
      song.setYear(tag.getFirst(FieldKey.YEAR));
      song.setTrack(tag.getFirst(FieldKey.TRACK));
      song.setFilename(dfi.getName());
    } catch (KeyNotFoundException knfe) {
      log.error("song key not found", knfe);
    }
    return song;
  }
  /**
   * Update the GridFSDBFile in the associated DB with the key/values in updateKeys
   *
   * @param updateKeys Map of new tag data
   * @param file GridFSDBFile to update with tag data
   * @param db
   * @param songId ID of Song to update with tag data
   * @return
   */
  public static boolean updateFile(
      Map<String, String> updateKeys,
      GridFSDBFile file,
      DB db,
      ObjectId songId) { // TODO updateKeys?
    File audioFile = null;
    try {
      audioFile = File.createTempFile("tmp", ".mp3");
    } catch (IOException e) {
      log.error("tmp file not created", e);
    }

    audioFile.deleteOnExit();
    AudioFile f = null;
    ObjectId id = (ObjectId) file.getId();
    ObjectId oid = null;
    try {
      file.writeTo(audioFile);
      f = AudioFileIO.read(audioFile);
      Tag tag = f.getTagOrCreateAndSetDefault();
      DBObject q = new BasicDBObject("_id", songId);
      DBObject o = new BasicDBObject("$set", new BasicDBObject(updateKeys));

      if (updateKeys.get("artist") != null) {
        tag.setField(FieldKey.ARTIST, updateKeys.get("artist"));
      }
      if (updateKeys.get("album") != null) {
        tag.setField(FieldKey.ALBUM, updateKeys.get("album"));
      }
      if (updateKeys.get("title") != null) {
        tag.setField(FieldKey.TITLE, updateKeys.get("title"));
      }
      if (updateKeys.get("track") != null) {
        tag.setField(FieldKey.TRACK, updateKeys.get("track"));
      }
      if (updateKeys.get("year") != null) {
        tag.setField(FieldKey.YEAR, updateKeys.get("year"));
      }
      AudioFileIO.write(f);
      GridFS myFS = new GridFS(db);
      myFS.remove(id);
      GridFSInputFile inputFile =
          putSongFileInDB(f.getFile(), db, file.getContentType(), file.getFilename(), id);
      oid = (ObjectId) inputFile.getId();
      if (oid.equals(id)) {
        db.getCollection("songs").update(q, o);
      }
    } catch (KeyNotFoundException knfe) {
      log.error("key not found", knfe);
    } catch (FieldDataInvalidException fdie) {
      log.error("tried to set field with invalid value", fdie);
    } catch (Exception e) {
      log.error("error reading/writing file", e);
    }
    return (oid.equals(id));
  }
  /**
   * Prechecks before normal write
   *
   * <p>
   *
   * <ul>
   *   <li>If the tag is actually empty, remove the tag
   *   <li>if the file is not writable, throw exception
   *   <li>
   *   <li>If the file is too small to be a valid file, throw exception
   *   <li>
   * </ul>
   *
   * @param af
   * @throws CannotWriteException
   */
  private void precheckWrite(AudioFile af) throws CannotWriteException {
    // Preliminary checks
    try {
      if (af.getTag().isEmpty()) {
        delete(af);
        return;
      }
    } catch (CannotReadException re) {
      throw new CannotWriteException(
          ErrorMessage.GENERAL_WRITE_FAILED.getMsg(af.getFile().getPath()));
    }

    if (!af.getFile().canWrite()) {
      logger.severe(ErrorMessage.GENERAL_WRITE_FAILED.getMsg(af.getFile().getPath()));
      throw new CannotWriteException(
          ErrorMessage.GENERAL_WRITE_FAILED.getMsg(af.getFile().getPath()));
    }

    if (af.getFile().length() <= MINIMUM_FILESIZE) {
      logger.severe(
          ErrorMessage.GENERAL_WRITE_FAILED_BECAUSE_FILE_IS_TOO_SMALL.getMsg(
              af.getFile().getPath()));
      throw new CannotWriteException(
          ErrorMessage.GENERAL_WRITE_FAILED_BECAUSE_FILE_IS_TOO_SMALL.getMsg(
              af.getFile().getPath()));
    }
  }
  public MetadataHelper(File f, Boolean debug)
      throws CannotReadException, IOException, TagException, ReadOnlyFileException,
          InvalidAudioFrameException {
    audioFile = AudioFileIO.read(f);

    tag = audioFile.getTag();
    audioHeader = audioFile.getAudioHeader();

    fillMetaInfo();
    fillHeaderInfo();

    if (debug) {
      printResults();
    }
  }
示例#8
0
  public pfItem(
      File mp3File, String link, String downloadPath, String description, String category) {
    if (pubDate == null) pubDate = new Date();

    _itemID = itemCount;
    itemCount++;
    try {
      AudioFile f = AudioFileIO.read(mp3File);
      Tag tag = f.getTag();

      _title = tag.getFirst(FieldKey.TITLE);
      if (_title == null || _title.trim().length() == 0) {
        _title = mp3File.getName();
      }

      String strTrackNum = tag.getFirst(FieldKey.TRACK);
      if (strTrackNum == null || strTrackNum.trim().length() == 0) {
        _trackNumber = _itemID;
      } else {
        try {
          _trackNumber = Integer.parseInt(strTrackNum);
        } catch (NumberFormatException ex) {
          _trackNumber = _itemID;
        }
      }
    } catch (CannotReadException ex) {
      Logger.getLogger(pfItem.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IOException ex) {
      Logger.getLogger(pfItem.class.getName()).log(Level.SEVERE, null, ex);
    } catch (TagException ex) {
      Logger.getLogger(pfItem.class.getName()).log(Level.SEVERE, null, ex);
    } catch (ReadOnlyFileException ex) {
      Logger.getLogger(pfItem.class.getName()).log(Level.SEVERE, null, ex);
    } catch (InvalidAudioFrameException ex) {
      Logger.getLogger(pfItem.class.getName()).log(Level.SEVERE, null, ex);
    }

    _link = link;
    _description = description;
    _length = mp3File.length();
    _category = category;

    try {
      _guid = (downloadPath + URLEncoder.encode(mp3File.getName(), "UTF-8")).replace("+", "%20");
    } catch (UnsupportedEncodingException ex) {
      Logger.getLogger(pfItem.class.getName()).log(Level.SEVERE, null, ex);
    }
  }
  /** Lets now check the value explicity are what we expect */
  public void testTagFieldKeyWrite2() {
    Exception exceptionCaught = null;
    try {
      File testFile = AbstractTestCase.copyAudioToTmp("test1.wma", new File("testwrite1.wma"));
      AudioFile f = AudioFileIO.read(testFile);
      AudioFileIO.delete(f);

      // test fields are written with correct ids
      f = AudioFileIO.read(testFile);
      Tag tag = f.getTag();
      for (FieldKey key : FieldKey.values()) {
        if (!(key == FieldKey.COVER_ART)) {
          tag.addField(tag.createField(key, key.name() + "_value"));
        }
      }
      f.commit();

      // Reread File
      f = AudioFileIO.read(testFile);
      tag = f.getTag();

      TagField tf = tag.getFirstField(AsfFieldKey.ALBUM.getFieldName());
      assertEquals("WM/AlbumTitle", tf.getId());
      assertEquals("ALBUM_value", ((TagTextField) tf).getContent());
      assertEquals("UTF-16LE", ((TagTextField) tf).getEncoding());

      tf = tag.getFirstField(AsfFieldKey.ALBUM_ARTIST.getFieldName());
      assertEquals("WM/AlbumArtist", tf.getId());
      assertEquals("ALBUM_ARTIST_value", ((TagTextField) tf).getContent());
      assertEquals("UTF-16LE", ((TagTextField) tf).getEncoding());

      tf = tag.getFirstField(AsfFieldKey.AMAZON_ID.getFieldName());
      assertEquals("ASIN", tf.getId());
      assertEquals("AMAZON_ID_value", ((TagTextField) tf).getContent());
      assertEquals("UTF-16LE", ((TagTextField) tf).getEncoding());

      tf = tag.getFirstField(AsfFieldKey.TITLE.getFieldName());
      assertEquals("TITLE", tf.getId());
      assertEquals("TITLE_value", ((TagTextField) tf).getContent());
      assertEquals("UTF-16LE", ((TagTextField) tf).getEncoding());

    } catch (Exception e) {
      e.printStackTrace();
      exceptionCaught = e;
    }
    assertNull(exceptionCaught);
  }
示例#10
0
  /** Test reading/writing artwork to Ogg */
  public void testReadWriteArtworkFieldsToOggVorbis() {

    File testFile = null;
    Exception exceptionCaught = null;
    try {
      testFile = AbstractTestCase.copyAudioToTmp("test3.ogg");

      // Read File okay
      AudioFile af = AudioFileIO.read(testFile);
      Tag tag = af.getTag();
      tag.createField(FieldKey.COVER_ART, "test");
    } catch (Exception e) {
      e.printStackTrace();
      exceptionCaught = e;
    }
    assertNull(exceptionCaught);
  }
示例#11
0
  /**
   * Fetches all the tags from the local music file: - Artist - Album - Title - Genre
   *
   * @return Song filled with tags
   * @throws InvalidAudioFrameException
   * @throws ReadOnlyFileException
   * @throws CannotReadException
   * @throws TagException
   * @throws IOException
   */
  public Song getSongTags()
      throws CannotReadException, IOException, TagException, ReadOnlyFileException,
          InvalidAudioFrameException {
    // create song
    Song song = new Song();

    // instantiate audio file
    AudioFile audio = AudioFileIO.read(this.songFile);

    Tag tag = audio.getTag();
    song.setArtist(tag.getFirst(FieldKey.ARTIST));
    song.setAlbum(tag.getFirst(FieldKey.ALBUM));
    song.setTitle(tag.getFirst(FieldKey.TITLE));
    song.setGenre(tag.getFirst(FieldKey.GENRE));

    return song;
  }
示例#12
0
  /** Test reading/writing artwork to Flac */
  public void testReadWriteArtworkFieldsToFlac() {
    File testFile = null;
    Exception exceptionCaught = null;
    try {
      testFile = AbstractTestCase.copyAudioToTmp("test.flac");

      // Read File okay
      AudioFile af = AudioFileIO.read(testFile);
      Tag tag = af.getTag();
      tag.createField(FieldKey.COVER_ART, "test");
    } catch (Exception e) {
      e.printStackTrace();
      exceptionCaught = e;
    }
    assertNotNull(exceptionCaught);
    assertTrue(exceptionCaught instanceof UnsupportedOperationException);
  }
示例#13
0
 private void insertMusicMetadata() throws IOException {
   atts.reset();
   System.out.format("Extracting music metadata from %s.\n", src.path());
   Tag tags = audio.getTag();
   AudioHeader header = audio.getAudioHeader();
   insert(FORMAT, header.getFormat());
   insert(ENCODINGTYPE, header.getEncodingType());
   insert(BITRATE, header.getBitRate());
   insert(SAMPLERATE, header.getSampleRate());
   insert(LENGTH, header.getTrackLength());
   insert(ALBUM, tags.getFirst(FieldKey.ALBUM));
   insert(ALBUMARTIST, tags.getFirst(FieldKey.ALBUM_ARTIST));
   insert(ARTIST, tags.getFirst(FieldKey.ARTIST));
   insert(TITLE, tags.getFirst(FieldKey.TITLE));
   insert(TRACKNR, tags.getFirst(FieldKey.TRACK));
   insert(DISCNR, tags.getFirst(FieldKey.DISC_NO));
   insert(YEAR, tags.getFirst(FieldKey.YEAR));
   insert(COMMENT, tags.getFirst(FieldKey.COMMENT));
 }
  /**
   * Shouldnt fail just ecause header size doesnt match file size because file plays ok in winamp
   */
  public void testReadFileWithHeaderSizeDoesntMatchFileSize() {
    File orig = new File("testdata", "test3.wma");
    if (!orig.isFile()) {
      System.err.println("Unable to test file - not available");
      return;
    }

    Exception exceptionCaught = null;
    try {
      File testFile = AbstractTestCase.copyAudioToTmp("test3.wma");
      AudioFile f = AudioFileIO.read(testFile);
      assertEquals("Glass", f.getTag().getFirst(FieldKey.TITLE));
      // Now
    } catch (Exception e) {
      e.printStackTrace();
      exceptionCaught = e;
    }
    assertNull(exceptionCaught);
  }
  /** Just create fields for all the tag field keys defined, se if we hit any problems */
  public void testTagFieldKeyWrite() {
    Exception exceptionCaught = null;
    try {
      File testFile = AbstractTestCase.copyAudioToTmp("test1.wma", new File("testwrite1.wma"));

      AudioFile f = AudioFileIO.read(testFile);
      AudioFileIO.delete(f);

      // Tests multiple iterations on same file
      for (int i = 0; i < 2; i++) {
        f = AudioFileIO.read(testFile);
        Tag tag = f.getTag();
        for (FieldKey key : FieldKey.values()) {
          if (!(key == FieldKey.COVER_ART)) {
            tag.setField(tag.createField(key, key.name() + "_value_" + i));
          }
        }
        f.commit();
        f = AudioFileIO.read(testFile);
        tag = f.getTag();
        for (FieldKey key : FieldKey.values()) {
          /*
           * Test value retrieval, using multiple access methods.
           */
          if (!(key == FieldKey.COVER_ART)) {
            String value = key.name() + "_value_" + i;
            System.out.println("Value is:" + value);

            assertEquals(value, tag.getFirst(key));
            AsfTagTextField atf = (AsfTagTextField) tag.getFields(key).get(0);
            assertEquals(value, atf.getContent());
            atf = (AsfTagTextField) tag.getFields(key).get(0);
            assertEquals(value, atf.getContent());
          }
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
      exceptionCaught = e;
    }
    assertNull(exceptionCaught);
  }
  public String getSongTitle(String songFilePath) {

    String songTitle = "Title";

    // Try to get the song title from the ID3 tag.
    File songFile = new File(songFilePath);
    AudioFile audioFile = null;
    Tag tag = null;
    try {
      audioFile = AudioFileIO.read(songFile);
    } catch (CannotReadException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (TagException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (ReadOnlyFileException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (InvalidAudioFrameException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }

    tag = audioFile.getTag();
    songTitle = tag.getFirst(FieldKey.TITLE);

    // If the ID3 tag doesn't give us the info we need, just use the file name.
    if (songTitle.equals("Title") || songTitle.isEmpty()) {
      int indexOfLastSlash = songTitle.lastIndexOf("/") + 1;
      int indexOfLastDot = songTitle.lastIndexOf(".");
      songTitle = songTitle.substring(indexOfLastSlash, indexOfLastDot);
    }

    return songTitle;
  }
 /**
  * writes bpm and key to KEY_START and BPM fields in the tag
  *
  * @param filename
  * @param formattedBpm
  * @param key
  */
 public boolean updateTags(String filename, String formattedBpm, String key) {
   File file = new File(filename);
   try {
     AudioFile f = AudioFileIO.read(file);
     if (!setCustomTag(f, "KEY_START", key)) {
       throw new IOException("Error writing Key Tag");
     }
     if (!c.noBpm) {
       Tag tag = f.getTag();
       if (tag instanceof Mp4Tag) {
         if (!setCustomTag(f, "BPM", formattedBpm)) {
           throw new IOException("Error writing BPM Tag");
         }
       }
       tag.setField(FieldKey.BPM, formattedBpm);
     }
     f.commit();
     return true;
   } catch (Exception e) {
     System.out.println("problem with tags in file " + filename);
     return false;
   }
 }
示例#18
0
  @Override
  public BufferedImage getArtwork() {
    BufferedImage image = super.getArtwork();

    if (image == null) {
      try {
        AudioFile audioFile = AudioFileIO.read(file);
        FlacTag tag = (FlacTag) audioFile.getTag();
        if (tag != null) {
          List<MetadataBlockDataPicture> images = tag.getImages();
          if (images != null && !images.isEmpty()) {
            MetadataBlockDataPicture picture = images.get(0);
            byte[] data = picture.getImageData();
            image = imageFromData(data);
          }
        }
      } catch (Throwable e) {
        LOG.error("Unable to read cover art from flac");
      }
    }

    return image;
  }
  /**
   * Create a new MusicFile objecy
   *
   * @param musicFile - source music file
   * @param documentsPath - default documents folder for the user
   */
  public MusicFile(File musicFile, String documentsPath) {

    // Set the music file and documents path
    this.musicFile = musicFile;
    this.documentsPath = documentsPath;

    // Determine the absolute path for the source music file
    absolutePath = musicFile.getAbsolutePath();

    // Retreive the file extension from the absolute path
    fileExtension = FilenameUtils.getExtension(absolutePath);

    // If this is a valid music file, retrieve the Tag, and copy the file to
    // the destination
    if (fileExtension.equals("mp3") || fileExtension.equals("m4a") || fileExtension.equals("m4p")) {
      try {
        AudioFile audioF = AudioFileIO.read(this.musicFile);
        musicFileTag = audioF.getTag();

        // Set the artist, album, and song titles
        error = setAttributes();

        // Set the destination file
        if (!error) constructDestination();
      } catch (Exception e) {
        error = true;
        errorMessage = "unidentified error.";
      }

      // Else, this is not a valid music file, set the error flag and
      // error message
    } else {
      errorMessage = "not a valid music file.";
      error = true;
    }
  }
示例#20
0
    @Override
    public FileVisitResult visitFile(final Path file, final BasicFileAttributes attrs)
        throws IOException {
      // System.out.println(file + "\t" + Thread.currentThread());
      // addSong(file);
      final File song = file.toFile();
      AudioFile f;
      Logger.getLogger("org.jaudiotagger").setLevel(Level.OFF);
      final String extension = getExtension(song.getPath());
      if (Arrays.asList(types).contains(extension)) {
        final String localUrl =
            "file:///" + AurousStringUtils.htmlEncode(song.getPath().toString().replace("\\", "/"));
        try {

          f = AudioFileIO.read(song);
          final Tag tag = f.getTag();
          if (tag != null) {
            String artist = tag.getFirst(FieldKey.ARTIST);
            String title = tag.getFirst(FieldKey.TITLE);
            String album = tag.getFirst(FieldKey.ALBUM);
            if (StringUtils.isBlank(artist)) {
              artist = "Unknown";
            }
            if (StringUtils.isBlank(title)) {
              title = "Unknown";
            }
            if (StringUtils.isBlank(album)) {
              album = "Unknown";
            }
            final int duration = f.getAudioHeader().getTrackLength();

            final String artworkBase64 = "assets/img/noalbumart.png";
            if (!DatabaseManager.isInCollection(localUrl)) {
              DatabaseManager.addSong(
                  title, artist, album, artworkBase64, duration, localUrl, "null", "null");
              //	System.out.println(localUrl);
            }
          } else {
            final int duration = f.getAudioHeader().getTrackLength();
            if (!DatabaseManager.isInCollection(localUrl)) {
              DatabaseManager.addSong(
                  "Unknown",
                  "Unknown",
                  "Unknown",
                  "assets/img/noalbumart.png",
                  duration,
                  localUrl,
                  "null",
                  "null");
            }
          }
        } catch (CannotReadException
            | IOException
            | TagException
            | ReadOnlyFileException
            | InvalidAudioFrameException e) {
          System.out.println("No headers detected");
          //	ExceptionWidget widget = new ExceptionWidget(e);
          //	widget.showWidget();
        }
      }
      return FileVisitResult.CONTINUE;
    }
示例#21
0
  private static void setID3(File mp3) {
    // populate Database with id3 tag information
    try {

      // Turn off all logging. This should be moved??

      Logger logger = Logger.getLogger("org.jaudiotagger");

      logger.setLevel(Level.OFF);

      File song = mp3;

      // FileInputStream file = new FileInputStream(song);

      AudioFile f = AudioFileIO.read(song);

      Tag tag = f.getTag();

      System.out.println("Track Length: " + f.getAudioHeader().getTrackLength());

      int bitRate = f.getAudioHeader().getSampleRateAsNumber();

      String artist = tag.getFirstArtist();
      System.out.println("here " + tag.getFirstArtist());
      String album = tag.getFirstAlbum();

      String songTitle = tag.getFirstTitle();

      InsertValues insert1 = new InsertValues();

      insert1.insertInfo(artist, songTitle, bitRate, "Audio_Files");
      // System.out.println(tag.getFirstComment());

      System.out.println("Year: " + tag.getFirstYear());

      // System.out.println(tag.getFirstTrack());

      /*

      * Removed. This is for version 1 only

      *

      * int size = (int)song.length(); file.skip(size - 128); byte[]

      * last128 = new byte[128]; file.read(last128); String id3 = new

      * String(last128); String tag = id3.substring(0, 3); if

      * (tag.equals("TAG")) { System.out.println("Title: " +

      * id3.substring(3, 32)); System.out.println("Artist: " +

      * id3.substring(33, 62)); System.out.println("Album: " +

      * id3.substring(63, 91)); System.out.println("Year: " +

      * id3.substring(93, 97)); } else //System.out.println(mp3 + " does

      * not contain" + " ID3 info.");

      */

      // file.close();

    } catch (Exception e) {

      System.out.println("file read error error message was e = " + e.toString());
    }
  }
  /**
   * Nimmt die aktuell in <code>tags</code> vorhandenen Metatags, und befŸllt die Editorfelder
   * dementsprechend, dass diese bearbeitet werden kšnne.<br>
   * Hierbei ist das bearbeiten eines einzelnen {@link Tag}s als auch das bearbeiten von mehreren
   * mšglich.
   *
   * @see #editTag(Tag)
   * @see #editTags(ArrayList)
   */
  private void updateEditorControls() {
    watchComponentsForChange = false;

    /* Felder zurücksetzen: */
    editorChanged = false;
    ((EditorComboBoxModel) comTitle.getModel()).reset();
    ((EditorComboBoxModel) comArtist.getModel()).reset();
    ((EditorComboBoxModel) comAlbum.getModel()).reset();
    ((EditorComboBoxModel) comGenre.getModel()).reset();
    txtTracknumber.setText("");
    txtTotalTracks.setText("");
    txtDiscnumber.setText("");
    txtTotalDiscs.setText("");
    txtYear.setText("");
    imgArtwork.setArtwork(null);
    imgArtwork.setChanged(false);

    if (audioFiles == null || audioFiles.size() == 0) {
      setEditorEnabled(false);
    } else {
      setEditorEnabled(true);

      if (audioFiles.size() == 1) {
        // SingleFile-Editing
        AudioFile audioFile = audioFiles.get(0);
        Tag tag = audioFile.getTag();

        /* Felder aktualisieren: */
        comTitle.addItem(tag.getFirstTitle());
        comTitle.setSelectedIndex(comTitle.getItemCount() - 1);
        comArtist.addItem(tag.getFirstArtist());
        comArtist.setSelectedIndex(comArtist.getItemCount() - 1);
        comAlbum.addItem(tag.getFirstAlbum());
        comAlbum.setSelectedIndex(comAlbum.getItemCount() - 1);

        String[] numberBuffer = splitNumberData(tag.getFirstTrack());
        txtTracknumber.setText(numberBuffer[0]);
        txtTracknumber.setEnabled(true);
        txtTotalTracks.setText(numberBuffer[1]);
        numberBuffer = splitNumberData(tag.getFirst(TagFieldKey.DISC_NO));
        txtDiscnumber.setText(numberBuffer[0]);
        txtTotalDiscs.setText(numberBuffer[1]);

        txtYear.setText(tag.getFirstYear());

        EditorComboBoxModel model = (EditorComboBoxModel) comGenre.getModel();
        String genre = tag.getFirstGenre();
        model.addIfNotExists(genre);
        comGenre.setSelectedItem(genre);

        try {
          Artwork artwork = tag.getFirstArtwork();
          BufferedImage cover = null;
          if (artwork != null)
            cover = ImageIO.read(new ByteArrayInputStream(artwork.getBinaryData()));
          imgArtwork.setArtwork(cover);
          imgArtwork.setChanged(false);
        } catch (Exception e) {
          e.printStackTrace();
        }

      } else {
        /* MutliFile-Editing: */
        // ComboBoxes befŸllen:
        // Wenn mehrere Audiodateien gewŠhlt sind, ist es meistens auch der
        // Fall, dass beispielsweise die verschiedenen Files einen verschiedenen
        // Album-Tag haben. Damit der User nicht "von null" ein Album eingeben
        // muss, hat er die Mšglichkeit, zwischen den bereits vorhandenen Varianten
        // eine auszusuchen.
        EditorComboBoxModel model = null;

        String totalTracks = "-1";
        String discnumber = "-1";
        String totalDiscs = "-1";
        for (AudioFile audioFile : audioFiles) {
          Tag tag = audioFile.getTag();

          // Title:
          model = (EditorComboBoxModel) comTitle.getModel();
          model.addIfNotExists(tag.getFirstTitle());

          // Artists:
          model = (EditorComboBoxModel) comArtist.getModel();
          model.addIfNotExists(tag.getFirstArtist());

          // Albums:
          model = (EditorComboBoxModel) comAlbum.getModel();
          model.addIfNotExists(tag.getFirstAlbum());

          // Genre.
          model = (EditorComboBoxModel) comGenre.getModel();
          model.addIfNotExists(tag.getFirstGenre());

          // Total Tracks:
          String[] splitBuffer = splitNumberData(tag.getFirstTrack());
          if (totalTracks.equals("-1") || totalTracks.equals(splitBuffer[1])) {
            totalTracks = splitBuffer[1];
          } else {
            totalTracks = "";
          }

          // Discs:
          splitBuffer = splitNumberData(tag.getFirst(TagFieldKey.DISC_NO));
          if (discnumber.equals("-1") || discnumber.equals(splitBuffer[0])) {
            discnumber = splitBuffer[0];
          } else {
            discnumber = "";
          }

          // Total Discs:
          if (totalDiscs.equals("-1") || totalDiscs.equals(splitBuffer[1])) {
            totalDiscs = splitBuffer[1];
          } else {
            totalDiscs = "";
          }
        }

        txtTracknumber.setText("");
        txtTracknumber.setEnabled(false);
        txtTotalTracks.setText(totalTracks);
        txtDiscnumber.setText(discnumber);
        txtTotalDiscs.setText(totalDiscs);
      }
    }

    watchComponentsForChange = true;
  }
  public void testReadFileWithJpgArtwork() {
    File orig = new File("testdata", "test6.wma");
    if (!orig.isFile()) {
      System.err.println("Unable to test file - not available");
      return;
    }

    Exception exceptionCaught = null;
    try {
      File testFile = AbstractTestCase.copyAudioToTmp("test6.wma");
      AudioFile f = AudioFileIO.read(testFile);
      Tag tag = f.getTag();
      assertEquals(1, tag.getFields(FieldKey.COVER_ART).size());

      TagField tagField = tag.getFields(FieldKey.COVER_ART).get(0);
      assertEquals("WM/Picture", tagField.getId());
      assertEquals(5093, tagField.getRawContent().length);

      // Should have been loaded as special field to make things easier
      assertTrue(tagField instanceof AsfTagCoverField);
      AsfTagCoverField coverartField = (AsfTagCoverField) tagField;
      assertEquals("image/jpeg", coverartField.getMimeType());
      assertEquals("coveerart", coverartField.getDescription());
      assertEquals(3, coverartField.getPictureType());
      assertEquals(200, coverartField.getImage().getWidth());
      assertEquals(200, coverartField.getImage().getHeight());
      assertEquals(5093, coverartField.getRawContent().length);
      assertEquals(5046, coverartField.getRawImageData().length);
      assertEquals(5046, coverartField.getImageDataSize());
      assertEquals(coverartField.getRawImageData().length, coverartField.getImageDataSize());

      assertEquals(BufferedImage.TYPE_3BYTE_BGR, coverartField.getImage().getType());

      /** *** TO SOME MANUAL CHECKING **************** */

      // First byte of data is immediatley after the 2 byte Descriptor value
      assertEquals(0x03, tagField.getRawContent()[0]);
      // Raw Data consists of Unknown/MimeType/Name and Actual Image, null seperated  (two bytes)

      // Skip first three unknown bytes plus two byte nulls
      int count = 5;
      String mimeType = null;
      String name = null;
      int endOfMimeType = 0;
      int endOfName = 0;
      while (count < tagField.getRawContent().length - 1) {
        if (tagField.getRawContent()[count] == 0 && tagField.getRawContent()[count + 1] == 0) {
          if (mimeType == null) {
            mimeType = new String(tagField.getRawContent(), 5, (count) - 5, "UTF-16LE");
            endOfMimeType = count + 2;
          } else if (name == null) {
            name =
                new String(
                    tagField.getRawContent(), endOfMimeType, count - endOfMimeType, "UTF-16LE");
            endOfName = count + 2;
            break;
          }
          count += 2;
        }
        count += 2; // keep on two byte word boundary
      }

      assertEquals("image/jpeg", mimeType);
      assertEquals("coveerart", name);

      BufferedImage bi =
          ImageIO.read(
              ImageIO.createImageInputStream(
                  new ByteArrayInputStream(
                      tagField.getRawContent(),
                      endOfName,
                      tagField.getRawContent().length - endOfName)));
      assertNotNull(bi);
      assertEquals(200, bi.getWidth());
      assertEquals(200, bi.getHeight());
      assertEquals(BufferedImage.TYPE_3BYTE_BGR, bi.getType());

    } catch (Exception e) {
      e.printStackTrace();
      exceptionCaught = e;
    }
    assertNull(exceptionCaught);
  }
  // TODO Creates temp file in same folder as the original file, this is safe but would impose a
  // performance
  // overhead if the original file is on a networked drive
  public synchronized void write(AudioFile af) throws CannotWriteException {
    logger.info("Started writing tag data for file:" + af.getFile().getName());

    // Prechecks
    precheckWrite(af);

    RandomAccessFile raf = null;
    RandomAccessFile rafTemp = null;
    File newFile = null;
    File result = null;

    // Create temporary File
    try {
      newFile =
          File.createTempFile(
              af.getFile().getName().replace('.', '_'),
              TEMP_FILENAME_SUFFIX,
              af.getFile().getParentFile());
    }
    // Unable to create temporary file, can happen in Vista if have Create Files/Write Data set to
    // Deny
    catch (IOException ioe) {
      logger.log(
          Level.SEVERE,
          ErrorMessage.GENERAL_WRITE_FAILED_TO_CREATE_TEMPORARY_FILE_IN_FOLDER.getMsg(
              af.getFile().getName(), af.getFile().getParentFile().getAbsolutePath()),
          ioe);
      throw new CannotWriteException(
          ErrorMessage.GENERAL_WRITE_FAILED_TO_CREATE_TEMPORARY_FILE_IN_FOLDER.getMsg(
              af.getFile().getName(), af.getFile().getParentFile().getAbsolutePath()));
    }

    // Open temporary file and actual file for Editing
    try {
      rafTemp = new RandomAccessFile(newFile, WRITE_MODE);
      raf = new RandomAccessFile(af.getFile(), WRITE_MODE);

    }
    // Unable to write to writable file, can happen in Vista if have Create Folders/Append Data set
    // to Deny
    catch (IOException ioe) {
      logger.log(
          Level.SEVERE,
          ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(
              af.getFile().getAbsolutePath()),
          ioe);

      // If we managed to open either file, delete it.
      try {
        if (raf != null) {
          raf.close();
        }
        if (rafTemp != null) {
          rafTemp.close();
        }
      } catch (IOException ioe2) {
        // Warn but assume has worked okay
        logger.log(
            Level.WARNING,
            ErrorMessage.GENERAL_WRITE_PROBLEM_CLOSING_FILE_HANDLE.getMsg(
                af.getFile(), ioe.getMessage()),
            ioe2);
      }

      // Delete the temp file ( we cannot delet until closed correpsonding rafTemp)
      if (!newFile.delete()) {
        // Non critical failed deletion
        logger.warning(
            ErrorMessage.GENERAL_WRITE_FAILED_TO_DELETE_TEMPORARY_FILE.getMsg(
                newFile.getAbsolutePath()));
      }

      throw new CannotWriteException(
          ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(
              af.getFile().getAbsolutePath()));
    }

    // Write data to File
    try {

      raf.seek(0);
      rafTemp.seek(0);
      try {
        if (this.modificationListener != null) {
          this.modificationListener.fileWillBeModified(af, false);
        }
        writeTag(af.getTag(), raf, rafTemp);
        if (this.modificationListener != null) {
          this.modificationListener.fileModified(af, newFile);
        }
      } catch (ModifyVetoException veto) {
        throw new CannotWriteException(veto);
      }
    } catch (Exception e) {
      logger.log(
          Level.SEVERE,
          ErrorMessage.GENERAL_WRITE_FAILED_BECAUSE.getMsg(af.getFile(), e.getMessage()),
          e);

      try {
        if (raf != null) {
          raf.close();
        }
        if (rafTemp != null) {
          rafTemp.close();
        }
      } catch (IOException ioe) {
        // Warn but assume has worked okay
        logger.log(
            Level.WARNING,
            ErrorMessage.GENERAL_WRITE_PROBLEM_CLOSING_FILE_HANDLE.getMsg(
                af.getFile().getAbsolutePath(), ioe.getMessage()),
            ioe);
      }

      // Delete the temporary file because either it was never used so lets just tidy up or we did
      // start writing to it but
      // the write failed and we havent renamed it back to the original file so we can just delete
      // it.
      if (!newFile.delete()) {
        // Non critical failed deletion
        logger.warning(
            ErrorMessage.GENERAL_WRITE_FAILED_TO_DELETE_TEMPORARY_FILE.getMsg(
                newFile.getAbsolutePath()));
      }
      throw new CannotWriteException(
          ErrorMessage.GENERAL_WRITE_FAILED_BECAUSE.getMsg(af.getFile(), e.getMessage()));
    } finally {
      try {
        if (raf != null) {
          raf.close();
        }
        if (rafTemp != null) {
          rafTemp.close();
        }
      } catch (IOException ioe) {
        // Warn but assume has worked okay
        logger.log(
            Level.WARNING,
            ErrorMessage.GENERAL_WRITE_PROBLEM_CLOSING_FILE_HANDLE.getMsg(
                af.getFile().getAbsolutePath(), ioe.getMessage()),
            ioe);
      }
    }

    // Result held in this file
    result = af.getFile();

    // If the temporary file was used
    if (newFile.length() > 0) {
      // Rename Original File
      // Can fail on Vista if have Special Permission 'Delete' set Deny
      File originalFileBackup =
          new File(
              af.getFile().getParentFile().getPath(),
              AudioFile.getBaseFilename(af.getFile()) + ".old");
      boolean renameResult = af.getFile().renameTo(originalFileBackup);
      if (renameResult == false) {
        logger.log(
            Level.SEVERE,
            ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_ORIGINAL_FILE_TO_BACKUP.getMsg(
                af.getFile().getPath(), originalFileBackup.getName()));
        throw new CannotWriteException(
            ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_ORIGINAL_FILE_TO_BACKUP.getMsg(
                af.getFile().getPath(), originalFileBackup.getName()));
      }

      // Rename Temp File to Original File
      renameResult = newFile.renameTo(af.getFile());
      if (!renameResult) {
        // Renamed failed so lets do some checks rename the backup back to the original file
        // New File doesnt exist
        if (!newFile.exists()) {
          logger.warning(
              ErrorMessage.GENERAL_WRITE_FAILED_NEW_FILE_DOESNT_EXIST.getMsg(
                  newFile.getAbsolutePath()));
        }

        // Rename the backup back to the original
        if (!originalFileBackup.renameTo(af.getFile())) {
          // TODO now if this happens we are left with testfile.old instead of testfile.mp4
          logger.warning(
              ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_ORIGINAL_BACKUP_TO_ORIGINAL.getMsg(
                  originalFileBackup.getAbsolutePath(), af.getFile().getName()));
        }

        logger.warning(
            ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_TO_ORIGINAL_FILE.getMsg(
                af.getFile().getAbsolutePath(), newFile.getName()));
        throw new CannotWriteException(
            ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_TO_ORIGINAL_FILE.getMsg(
                af.getFile().getAbsolutePath(), newFile.getName()));
      } else {
        // Rename was okay so we can now delete the backup of the original
        boolean deleteResult = originalFileBackup.delete();
        if (!deleteResult) {
          // Not a disaster but can't delete the backup so make a warning
          logger.warning(
              ErrorMessage.GENERAL_WRITE_WARNING_UNABLE_TO_DELETE_BACKUP_FILE.getMsg(
                  originalFileBackup.getAbsolutePath()));
        }
      }

      // Delete the temporary file if still exists
      if (newFile.exists()) {
        if (!newFile.delete()) {
          // Non critical failed deletion
          logger.warning(
              ErrorMessage.GENERAL_WRITE_FAILED_TO_DELETE_TEMPORARY_FILE.getMsg(newFile.getPath()));
        }
      }
    } else {
      // Delete the temporary file that wasn't ever used
      if (!newFile.delete()) {
        // Non critical failed deletion
        logger.warning(
            ErrorMessage.GENERAL_WRITE_FAILED_TO_DELETE_TEMPORARY_FILE.getMsg(newFile.getPath()));
      }
    }

    if (this.modificationListener != null) {
      this.modificationListener.fileOperationFinished(result);
    }
  }
  public void testDeleteFields() throws Exception {
    // Delete using generic key
    File testFile = AbstractTestCase.copyAudioToTmp("test1.wma", new File("testDeleteFields.wma"));
    AudioFile f = AudioFileIO.read(testFile);
    List<TagField> tagFields = f.getTag().getFields(FieldKey.ALBUM_ARTIST_SORT);
    assertEquals(0, tagFields.size());
    f.getTag().addField(FieldKey.ALBUM_ARTIST_SORT, "artist1");
    tagFields = f.getTag().getFields(FieldKey.ALBUM_ARTIST_SORT);
    assertEquals(1, tagFields.size());
    f.getTag().deleteField(FieldKey.ALBUM_ARTIST_SORT);
    f.commit();

    // Delete using flac id
    f = AudioFileIO.read(testFile);
    tagFields = f.getTag().getFields(FieldKey.ALBUM_ARTIST_SORT);
    assertEquals(0, tagFields.size());
    f.getTag().addField(FieldKey.ALBUM_ARTIST_SORT, "artist1");
    tagFields = f.getTag().getFields(FieldKey.ALBUM_ARTIST_SORT);
    assertEquals(1, tagFields.size());
    f.getTag().deleteField("WM/AlbumArtistSortOrder");
    tagFields = f.getTag().getFields(FieldKey.ALBUM_ARTIST_SORT);
    assertEquals(0, tagFields.size());
    f.commit();

    f = AudioFileIO.read(testFile);
    tagFields = f.getTag().getFields(FieldKey.ALBUM_ARTIST_SORT);
    assertEquals(0, tagFields.size());
  }
  /**
   * Delete the tag (if any) present in the given file
   *
   * @param af The file to process
   * @throws CannotWriteException if anything went wrong
   */
  public synchronized void delete(AudioFile af) throws CannotReadException, CannotWriteException {
    if (!af.getFile().canWrite()) {
      throw new CannotWriteException(
          ErrorMessage.GENERAL_DELETE_FAILED.getMsg(af.getFile().getPath()));
    }

    if (af.getFile().length() <= MINIMUM_FILESIZE) {
      throw new CannotWriteException(
          ErrorMessage.GENERAL_DELETE_FAILED.getMsg(af.getFile().getPath()));
    }

    RandomAccessFile raf = null;
    RandomAccessFile rafTemp = null;
    File tempF = null;

    // Will be set to true on VetoException, causing the finally block to discard the tempfile.
    boolean revert = false;

    try {

      tempF =
          File.createTempFile(
              af.getFile().getName().replace('.', '_'),
              TEMP_FILENAME_SUFFIX,
              af.getFile().getParentFile());
      rafTemp = new RandomAccessFile(tempF, WRITE_MODE);
      raf = new RandomAccessFile(af.getFile(), WRITE_MODE);
      raf.seek(0);
      rafTemp.seek(0);

      try {
        if (this.modificationListener != null) {
          this.modificationListener.fileWillBeModified(af, true);
        }
        deleteTag(raf, rafTemp);
        if (this.modificationListener != null) {
          this.modificationListener.fileModified(af, tempF);
        }
      } catch (ModifyVetoException veto) {
        throw new CannotWriteException(veto);
      }

    } catch (Exception e) {
      revert = true;
      throw new CannotWriteException("\"" + af.getFile().getAbsolutePath() + "\" :" + e, e);
    } finally {
      // will be set to the remaining file.
      File result = af.getFile();
      try {
        if (raf != null) {
          raf.close();
        }
        if (rafTemp != null) {
          rafTemp.close();
        }

        if (tempF.length() > 0 && !revert) {
          boolean deleteResult = af.getFile().delete();
          if (deleteResult == false) {
            logger.warning(
                ErrorMessage.GENERAL_WRITE_FAILED_TO_DELETE_ORIGINAL_FILE.getMsg(
                    af.getFile().getPath(), tempF.getPath()));
            throw new CannotWriteException(
                ErrorMessage.GENERAL_WRITE_FAILED_TO_DELETE_ORIGINAL_FILE.getMsg(
                    af.getFile().getPath(), tempF.getPath()));
          }
          boolean renameResult = tempF.renameTo(af.getFile());
          if (renameResult == false) {
            logger.warning(
                ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_TO_ORIGINAL_FILE.getMsg(
                    af.getFile().getPath(), tempF.getPath()));
            throw new CannotWriteException(
                ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_TO_ORIGINAL_FILE.getMsg(
                    af.getFile().getPath(), tempF.getPath()));
          }
          result = tempF;

          // If still exists we can now delete
          if (tempF.exists()) {
            if (!tempF.delete()) {
              // Non critical failed deletion
              logger.warning(
                  ErrorMessage.GENERAL_WRITE_FAILED_TO_DELETE_TEMPORARY_FILE.getMsg(
                      tempF.getPath()));
            }
          }
        } else {
          // It was created but never used
          if (!tempF.delete()) {
            // Non critical failed deletion
            logger.warning(
                ErrorMessage.GENERAL_WRITE_FAILED_TO_DELETE_TEMPORARY_FILE.getMsg(tempF.getPath()));
          }
        }
      } catch (Exception ex) {
        logger.severe(
            "AudioFileWriter exception cleaning up delete:"
                + af.getFile().getPath()
                + " or"
                + tempF.getAbsolutePath()
                + ":"
                + ex);
      }
      // Notify listener
      if (this.modificationListener != null) {
        this.modificationListener.fileOperationFinished(result);
      }
    }
  }
  public static boolean generate_audio_info_xml(
      File saveLocation, TOTorrent inTorrent, File metaFile) {

    Map<String, Properties> audio_file_properties = new HashMap<String, Properties>();

    if (inTorrent.isSimpleTorrent()) {
      Properties p = new Properties();
      InOrderType type = InOrderType.getType(saveLocation.getName());
      if (type != null) {

        if (type.getFileTypeFilter().equals(FileTypeFilter.Audio)) {
          try {
            AudioFile f = AudioFileIO.read(saveLocation);
            Tag tag = f.getTag();

            if (tag != null) {
              AudioHeader audioHeader = f.getAudioHeader();
              setPropsFromTagAndHeader(p, audioHeader, tag);
            }

            if (p.size() > 0) {
              audio_file_properties.put(saveLocation.getName(), p);
            }
          } catch (Exception e) {
            System.err.println("audio tag parse error: " + e.toString());
          }
        }
      }
    } else {
      for (TOTorrentFile torrent_file : inTorrent.getFiles()) {
        Properties p = new Properties();
        audio_file_properties.put(torrent_file.getRelativePath(), p);

        InOrderType type = InOrderType.getType(torrent_file.getRelativePath());
        if (type != null) {

          if (type.getFileTypeFilter().equals(FileTypeFilter.Audio)) {
            try {
              File file = new File(saveLocation, torrent_file.getRelativePath());
              AudioFile f = AudioFileIO.read(file);
              Tag tag = f.getTag();

              if (tag != null) {
                AudioHeader audioHeader = f.getAudioHeader();
                setPropsFromTagAndHeader(p, audioHeader, tag);

                if (p.size() > 0) {
                  audio_file_properties.put(saveLocation.getName(), p);
                }
              }
            } catch (Exception e) {
              System.err.println("audio tag parse error: " + e.toString());
            }
          } // if it's an audio type
        } // if this file has a recognizable type
      } // for over torrent files
    }

    if (audio_file_properties.size() > 0) {
      try {
        XMLEncoder encoder =
            new XMLEncoder(new BufferedOutputStream(new FileOutputStream(metaFile)));
        encoder.writeObject(audio_file_properties);
        encoder.close();
        logger.fine(
            "wrote audio properties xml for: " + (new String(inTorrent.getName(), "UTF-8")));
      } catch (Exception e) {
        try {
          logger.warning(
              "error writing audio properties for: "
                  + new String(inTorrent.getName(), "UTF-8")
                  + " / "
                  + e.toString());
        } catch (UnsupportedEncodingException e1) {
          e1.printStackTrace();
        }
        e.printStackTrace();
        return false;
      }

      return true;
    }
    return false;
  }
  /**
   * This will write a custom ID3 tag (TXXX). This works only with MP3 files (Flac with ID3-Tag not
   * tested).
   *
   * @param description The description of the custom tag i.e. "catalognr" There can only be one
   *     custom TXXX tag with that description in one MP3 file
   * @param text The actual text to be written into the new tag field
   * @return True if the tag has been properly written, false otherwise
   */
  public static boolean setCustomTag(AudioFile audioFile, String description, String text)
      throws IOException {
    FrameBodyTXXX txxxBody = new FrameBodyTXXX();
    txxxBody.setDescription(description);
    txxxBody.setText(text);

    // Get the tag from the audio file
    // If there is no ID3Tag create an ID3v2.3 tag
    Tag tag = audioFile.getTagOrCreateAndSetDefault();
    if (tag instanceof AbstractID3Tag) {
      // If there is only a ID3v1 tag, copy data into new ID3v2.3 tag
      if (!(tag instanceof ID3v23Tag || tag instanceof ID3v24Tag)) {
        Tag newTagV23 = null;
        if (tag instanceof ID3v1Tag) {
          newTagV23 =
              new ID3v23Tag((ID3v1Tag) audioFile.getTag()); // Copy old tag data
        }
        if (tag instanceof ID3v22Tag) {
          newTagV23 =
              new ID3v23Tag((ID3v22Tag) audioFile.getTag()); // Copy old tag data
        }
        audioFile.setTag(newTagV23);
        tag = newTagV23;
      }

      AbstractID3v2Frame frame = null;
      if (tag instanceof ID3v23Tag) {
        if (((ID3v23Tag) audioFile.getTag()).getInvalidFrames() > 0) {
          throw new IOException("read some invalid frames!");
        }
        frame = new ID3v23Frame("TXXX");
      } else if (tag instanceof ID3v24Tag) {
        if (((ID3v24Tag) audioFile.getTag()).getInvalidFrames() > 0) {
          throw new IOException("read some invalid frames!");
        }
        frame = new ID3v24Frame("TXXX");
      }

      frame.setBody(txxxBody);

      try {
        tag.setField(frame);
      } catch (FieldDataInvalidException e) {
        Logger.getLogger(TrackAnalyzer.class.getName()).log(Level.SEVERE, null, e);
        return false;
      }
    } else if (tag instanceof FlacTag) {
      try {
        ((FlacTag) tag).setField(description, text);
      } catch (KeyNotFoundException ex) {
        Logger.getLogger(TrackAnalyzer.class.getName()).log(Level.SEVERE, null, ex);
        return false;
      } catch (FieldDataInvalidException ex) {
        return false;
      }
    } else if (tag instanceof Mp4Tag) {
      // TagField field = new Mp4TagTextField("----:com.apple.iTunes:"+description, text);
      TagField field;
      field =
          new Mp4TagReverseDnsField(
              Mp4TagReverseDnsField.IDENTIFIER + ":" + "com.apple.iTunes" + ":" + description,
              "com.apple.iTunes",
              description,
              text);
      // TagField field = new Mp4TagTextField(description, text);
      try {
        tag.setField(field);
      } catch (FieldDataInvalidException ex) {
        Logger.getLogger(TrackAnalyzer.class.getName()).log(Level.SEVERE, null, ex);
        return false;
      }
    } else if (tag instanceof VorbisCommentTag) {
      try {
        ((VorbisCommentTag) tag).setField(description, text);
      } catch (KeyNotFoundException ex) {
        Logger.getLogger(TrackAnalyzer.class.getName()).log(Level.SEVERE, null, ex);
        return false;
      } catch (FieldDataInvalidException ex) {
        Logger.getLogger(TrackAnalyzer.class.getName()).log(Level.SEVERE, null, ex);
        return false;
      }
    } else {
      // tag not implented
      Logger.getLogger(TrackAnalyzer.class.getName())
          .log(
              Level.WARNING,
              "couldn't write key information for "
                  + audioFile.getFile().getName()
                  + " to tag, because this format is not supported.");
      return false;
    }

    // write changes in tag to file
    try {
      audioFile.commit();
    } catch (CannotWriteException e) {
      e.printStackTrace();
      return false;
    }
    return true;
  }
示例#29
0
 public void deleteTag(AudioFile f) throws CannotWriteException {
   // Because audio file is an instanceof MP3File this directs it to save
   // taking into account if the tag has been sent to null in which case it will be deleted
   f.commit();
 }
示例#30
0
 public void writeFile(AudioFile f) throws CannotWriteException {
   // Because audio file is an instanceof MP3File this directs it to save
   f.commit();
 }