Coverage Report

Coverage Report - org.jaudiotagger.tag.mp4.Mp4Tag

Classes in this File

Line Coverage

Branch Coverage

Complexity

Mp4Tag

87%

175/199

50%

73/144

8.278

Mp4Tag$1

100%

1/1

N/A

8.278

 /*
  * Entagged Audio Tag library
  * Copyright (c) 2003-2005 Raphael Slinckx <raphael@slinckx.net>
  * 
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *  
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  * 
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 package org.jaudiotagger.tag.mp4;
 
 import org.jaudiotagger.audio.generic.AbstractTag;
 import org.jaudiotagger.audio.mp4.atom.Mp4BoxHeader;
 import org.jaudiotagger.logging.ErrorMessage;
 import org.jaudiotagger.tag.*;
 import org.jaudiotagger.tag.datatype.Artwork;
 import static org.jaudiotagger.tag.mp4.Mp4FieldKey.*;
 import org.jaudiotagger.tag.mp4.field.*;
 
 import java.util.ArrayList;
 import java.util.EnumMap;
 import java.util.List;
 
 /**
  * A Logical representation of Mp4Tag, i.e the meta information stored in an Mp4 file underneath the
  * moov.udt.meta.ilst atom.
  */
 public class Mp4Tag extends AbstractTag
 {
 
     private static final EnumMap<FieldKey, Mp4FieldKey> tagFieldToMp4Field = new EnumMap<FieldKey, Mp4FieldKey>(FieldKey.class);
 
     //Mapping from generic key to mp4 key
     static
     {
         tagFieldToMp4Field.put(FieldKey.ARTIST, Mp4FieldKey.ARTIST);
         tagFieldToMp4Field.put(FieldKey.ALBUM, Mp4FieldKey.ALBUM);
         tagFieldToMp4Field.put(FieldKey.TITLE, Mp4FieldKey.TITLE);
         tagFieldToMp4Field.put(FieldKey.TRACK, Mp4FieldKey.TRACK);
         tagFieldToMp4Field.put(FieldKey.YEAR, Mp4FieldKey.DAY);
         tagFieldToMp4Field.put(FieldKey.GENRE, Mp4FieldKey.GENRE);
         tagFieldToMp4Field.put(FieldKey.COMMENT, Mp4FieldKey.COMMENT);
         tagFieldToMp4Field.put(FieldKey.ALBUM_ARTIST, Mp4FieldKey.ALBUM_ARTIST);
         tagFieldToMp4Field.put(FieldKey.COMPOSER, Mp4FieldKey.COMPOSER);
         tagFieldToMp4Field.put(FieldKey.GROUPING, Mp4FieldKey.GROUPING);
         tagFieldToMp4Field.put(FieldKey.DISC_NO, Mp4FieldKey.DISCNUMBER);
         tagFieldToMp4Field.put(FieldKey.BPM, Mp4FieldKey.BPM);
         tagFieldToMp4Field.put(FieldKey.ENCODER, Mp4FieldKey.ENCODER);
         tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_ARTISTID, Mp4FieldKey.MUSICBRAINZ_ARTISTID);
         tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASEID, Mp4FieldKey.MUSICBRAINZ_ALBUMID);
         tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASEARTISTID, Mp4FieldKey.MUSICBRAINZ_ALBUMARTISTID);
         tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_TRACK_ID, Mp4FieldKey.MUSICBRAINZ_TRACKID);
         tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_DISC_ID, Mp4FieldKey.MUSICBRAINZ_DISCID);
         tagFieldToMp4Field.put(FieldKey.MUSICIP_ID, Mp4FieldKey.MUSICIP_PUID);
         tagFieldToMp4Field.put(FieldKey.AMAZON_ID, Mp4FieldKey.ASIN);
         tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASE_STATUS, Mp4FieldKey.MUSICBRAINZ_ALBUM_STATUS);
         tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASE_TYPE, Mp4FieldKey.MUSICBRAINZ_ALBUM_TYPE);
         tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASE_COUNTRY, Mp4FieldKey.RELEASECOUNTRY);
         tagFieldToMp4Field.put(FieldKey.LYRICS, Mp4FieldKey.LYRICS);
         tagFieldToMp4Field.put(FieldKey.IS_COMPILATION, Mp4FieldKey.COMPILATION);
         tagFieldToMp4Field.put(FieldKey.ARTIST_SORT, Mp4FieldKey.ARTIST_SORT);
         tagFieldToMp4Field.put(FieldKey.ALBUM_ARTIST_SORT, Mp4FieldKey.ALBUM_ARTIST_SORT);
         tagFieldToMp4Field.put(FieldKey.ALBUM_SORT, Mp4FieldKey.ALBUM_SORT);
         tagFieldToMp4Field.put(FieldKey.TITLE_SORT, Mp4FieldKey.TITLE_SORT);
         tagFieldToMp4Field.put(FieldKey.COMPOSER_SORT, Mp4FieldKey.COMPOSER_SORT);
         tagFieldToMp4Field.put(FieldKey.COVER_ART, Mp4FieldKey.ARTWORK);
         tagFieldToMp4Field.put(FieldKey.ISRC, Mp4FieldKey.ISRC);
         tagFieldToMp4Field.put(FieldKey.CATALOG_NO, Mp4FieldKey.CATALOGNO);
         tagFieldToMp4Field.put(FieldKey.BARCODE, Mp4FieldKey.BARCODE);
         tagFieldToMp4Field.put(FieldKey.RECORD_LABEL, Mp4FieldKey.LABEL);
         tagFieldToMp4Field.put(FieldKey.LYRICIST, Mp4FieldKey.LYRICIST);
         tagFieldToMp4Field.put(FieldKey.CONDUCTOR, Mp4FieldKey.CONDUCTOR);
         tagFieldToMp4Field.put(FieldKey.REMIXER, Mp4FieldKey.REMIXER);
         tagFieldToMp4Field.put(FieldKey.MOOD, Mp4FieldKey.MOOD);
         tagFieldToMp4Field.put(FieldKey.MEDIA, Mp4FieldKey.MEDIA);
         tagFieldToMp4Field.put(FieldKey.URL_OFFICIAL_RELEASE_SITE, Mp4FieldKey.URL_OFFICIAL_RELEASE_SITE);
         tagFieldToMp4Field.put(FieldKey.URL_DISCOGS_RELEASE_SITE, Mp4FieldKey.URL_DISCOGS_RELEASE_SITE);
         tagFieldToMp4Field.put(FieldKey.URL_WIKIPEDIA_RELEASE_SITE, Mp4FieldKey.URL_WIKIPEDIA_RELEASE_SITE);
         tagFieldToMp4Field.put(FieldKey.URL_OFFICIAL_ARTIST_SITE, Mp4FieldKey.URL_OFFICIAL_ARTIST_SITE);
         tagFieldToMp4Field.put(FieldKey.URL_DISCOGS_ARTIST_SITE, Mp4FieldKey.URL_DISCOGS_ARTIST_SITE);
         tagFieldToMp4Field.put(FieldKey.URL_WIKIPEDIA_ARTIST_SITE, Mp4FieldKey.URL_WIKIPEDIA_ARTIST_SITE);
         tagFieldToMp4Field.put(FieldKey.LANGUAGE, Mp4FieldKey.LANGUAGE);
         tagFieldToMp4Field.put(FieldKey.KEY, Mp4FieldKey.KEY);
         tagFieldToMp4Field.put(FieldKey.URL_LYRICS_SITE, Mp4FieldKey.URL_LYRICS_SITE);
         tagFieldToMp4Field.put(FieldKey.TRACK_TOTAL, Mp4FieldKey.TRACK);
         tagFieldToMp4Field.put(FieldKey.DISC_TOTAL, Mp4FieldKey.DISCNUMBER);
     }
 
     /**
      * Create genre field
      * <p/>
      * <p>If the content can be parsed to one of the known values use the genre field otherwise
      * use the custom field.
      *
      * @param content
      * @return
      */
     @SuppressWarnings({"JavaDoc"})
     private TagField createGenreField(String content)
     {
         if (content == null)
         {
             throw new IllegalArgumentException(ErrorMessage.GENERAL_INVALID_NULL_ARGUMENT.getMsg());
         }
         if (Mp4GenreField.isValidGenre(content))
         {
             return new Mp4GenreField(content);
         }
         else
         {
             return new Mp4TagTextField(GENRE_CUSTOM.getFieldName(), content);
         }
     }
 
     protected boolean isAllowedEncoding(String enc)
     {
         return enc.equals(Mp4BoxHeader.CHARSET_UTF_8);
     }
 
     public String toString()
     {
         return "Mpeg4 " + super.toString();
     }
 
 
     /**
      * Maps the generic key to the mp4 key and return the list of values for this field
      *
      * @param genericKey
      */
     @SuppressWarnings({"JavaDoc"})
     @Override
     public List<TagField> getFields(FieldKey genericKey) throws KeyNotFoundException
     {
         if (genericKey == null)
         {
             throw new KeyNotFoundException();
         }
         return super.get(tagFieldToMp4Field.get(genericKey).getFieldName());
     }
 
 
     /**
      * Retrieve the  values that exists for this mp4keyId (this is the internalid actually used)
      * <p/>
      *
      * @param mp4FieldKey
      * @throws org.jaudiotagger.tag.KeyNotFoundException
      * @return
      */
     public List<TagField> get(Mp4FieldKey mp4FieldKey) throws KeyNotFoundException
     {
         if (mp4FieldKey == null)
         {
             throw new KeyNotFoundException();
         }
         return super.get(mp4FieldKey.getFieldName());
     }
 
     /**
      * Retrieve the first value that exists for this generic key
      *
      * @param genericKey
      * @return
      */
     public String getFirst(FieldKey genericKey) throws KeyNotFoundException
     {
         if (genericKey == null)
         {
             throw new KeyNotFoundException();
         }
 
         if(genericKey== FieldKey.GENRE)
         {
             List<TagField> genres = get(GENRE.getFieldName());
             if (genres.size() == 0)
             {
                 genres = get(GENRE_CUSTOM.getFieldName());
             }
             if(genres.size()>0)
             {
                 return ((TagTextField)genres.get(0)).getContent();
             }
             else
             {
                 return "";
             }
 
         }
         else if(genericKey== FieldKey.TRACK)
         {
             List<TagField> list = get(tagFieldToMp4Field.get(genericKey));
             if(list.size()>0)
             {
                 Mp4TrackField trackField = (Mp4TrackField)list.get(0);
                 if(trackField.getTrackNo()>0)
                 {
                     return String.valueOf(trackField.getTrackNo());
                 }
             }
         }
         else if(genericKey== FieldKey.TRACK_TOTAL)
         {
             List<TagField> list = get(tagFieldToMp4Field.get(genericKey));
             if(list.size()>0)
             {
                 Mp4TrackField trackField = (Mp4TrackField)list.get(0);
                 if(trackField.getTrackTotal()>0)
                 {
                     return String.valueOf(trackField.getTrackTotal());
                 }
             }
         }
         else if(genericKey== FieldKey.DISC_NO)
         {
             List<TagField> list = get(tagFieldToMp4Field.get(genericKey));
             if(list.size()>0)
             {
                 Mp4DiscNoField discField = (Mp4DiscNoField)list.get(0);
                 if(discField.getDiscNo()>0)
                 {
                      return String.valueOf(discField.getDiscNo());
                 }
 
             }
         }
         else if(genericKey== FieldKey.DISC_TOTAL)
         {
             List<TagField> list = get(tagFieldToMp4Field.get(genericKey));
             if(list.size()>0)
             {
                 Mp4DiscNoField discField = (Mp4DiscNoField)list.get(0);
                 if(discField.getDiscTotal()>0)
                 {
                      return String.valueOf(discField.getDiscTotal());
                 }
             }
         }
         else
         {
             return super.getFirst(tagFieldToMp4Field.get(genericKey).getFieldName());
         }
         return "";
     }
 
     /**
      * Retrieve the first value that exists for this mp4key
      *
      * @param mp4Key
      * @return
      * @throws org.jaudiotagger.tag.KeyNotFoundException
      */
     public String getFirst(Mp4FieldKey mp4Key) throws KeyNotFoundException
     {
         if (mp4Key == null)
         {
             throw new KeyNotFoundException();
         }
         return super.getFirst(mp4Key.getFieldName());
     }
 
     public Mp4TagField getFirstField(FieldKey genericKey) throws KeyNotFoundException
     {
         if (genericKey == null)
         {
             throw new KeyNotFoundException();
         }
         return (Mp4TagField)super.getFirstField(tagFieldToMp4Field.get(genericKey).getFieldName());
     }
 
     public Mp4TagField getFirstField(Mp4FieldKey mp4Key) throws KeyNotFoundException
     {
         if (mp4Key == null)
         {
             throw new KeyNotFoundException();
         }
         return (Mp4TagField) super.getFirstField(mp4Key.getFieldName());
     }
 
     /**
      * Delete fields with this generic key
      *
      * @param genericKey
      */
     public void deleteField(FieldKey genericKey) throws KeyNotFoundException
     {
         if (genericKey == null)
         {
             throw new KeyNotFoundException();
         }
         super.deleteField(tagFieldToMp4Field.get(genericKey).getFieldName());
     }
 
     /**
      * Delete fields with this mp4key
      *
      * @param mp4Key
      * @throws org.jaudiotagger.tag.KeyNotFoundException
      */
     public void deleteField(Mp4FieldKey mp4Key) throws KeyNotFoundException
     {
         if (mp4Key == null)
         {
             throw new KeyNotFoundException();
         }
         super.deleteField(mp4Key.getFieldName());
     }
 
     /**
      * Create discno field
      *
      * @param content can be any of the following
      *                1
      *                1/10
      * @return
      * @throws org.jaudiotagger.tag.FieldDataInvalidException
      */
     public TagField createDiscNoField(String content) throws FieldDataInvalidException
     {
         return new Mp4DiscNoField(content);
     }
 
     /**
      * Create artwork field
      *
      * @param data raw image data
      * @return
      * @throws org.jaudiotagger.tag.FieldDataInvalidException
      */
     public TagField createArtworkField(byte[] data)
     {
         return new Mp4TagCoverField(data);
     }
 
      /**
      * Create artwork field
      *    
      * @return
      */
     public TagField createField(Artwork artwork) throws FieldDataInvalidException
     {
         return new Mp4TagCoverField(artwork.getBinaryData());
     }
 
     /**
      * Create Tag Field using generic key
      * <p/>
      * This should use the correct subclass for the key
      *
      * @param genericKey
      * @param value
      * @return
      * @throws KeyNotFoundException
      * @throws FieldDataInvalidException
      */
     @Override
     public TagField createField(FieldKey genericKey, String value) throws KeyNotFoundException, FieldDataInvalidException
     {
         if (value == null)
         {
             throw new IllegalArgumentException(ErrorMessage.GENERAL_INVALID_NULL_ARGUMENT.getMsg());
         }
         if (genericKey == null)
         {
             throw new KeyNotFoundException();
         }
 
         if(genericKey== FieldKey.TRACK)
         {
             return new Mp4TrackField(Integer.parseInt(value));
         }
         else if(genericKey== FieldKey.TRACK_TOTAL)
         {
             return new Mp4TrackField(0,Integer.parseInt(value));
         }
         else if(genericKey== FieldKey.DISC_NO)
         {
             return new Mp4DiscNoField(Integer.parseInt(value));
         }
         else if(genericKey== FieldKey.DISC_TOTAL)
         {
             return new Mp4DiscNoField(0,Integer.parseInt(value));
         }
         else
         {
             return createField(tagFieldToMp4Field.get(genericKey), value);
         }
     }
 
     /**
      * Set field, special handling for track and disc because they hold two fields
      * 
      * @param field
      */
     @Override
     public void setField(TagField field)
     {
         if (field == null)
         {
             return;
         }
 
         if(field.getId().equals(TRACK.getFieldName()))
         {
             List<TagField> list = fields.get(field.getId());
             if(list==null||list.size()==0)
             {
                  super.setField(field);
             }
             else
             {
                 Mp4TrackField existingTrackField = (Mp4TrackField)list.get(0);
                 Mp4TrackField newTrackField      = (Mp4TrackField)field;
                 Short trackNo    = existingTrackField.getTrackNo();
                 Short trackTotal = existingTrackField.getTrackTotal();
                 if(newTrackField.getTrackNo()>0 )
                 {
                     trackNo = newTrackField.getTrackNo();
                 }
                 if(newTrackField.getTrackTotal()>0 )
                 {
                     trackTotal = newTrackField.getTrackTotal();
                 }
 
                 Mp4TrackField mergedTrackField = new Mp4TrackField(trackNo,trackTotal);
                 super.setField(mergedTrackField);
             }
         }
         else if(field.getId().equals(DISCNUMBER.getFieldName()))
         {
             List<TagField> list = fields.get(field.getId());
             if(list==null||list.size()==0)
             {
                  super.setField(field);
             }
             else
             {
                 Mp4DiscNoField existingDiscNoField = (Mp4DiscNoField)list.get(0);
                 Mp4DiscNoField newDiscNoField      = (Mp4DiscNoField)field;
                 Short discNo    = existingDiscNoField.getDiscNo();
                 Short discTotal = existingDiscNoField.getDiscTotal();
                 if(newDiscNoField.getDiscNo()>0 )
                 {
                     discNo = newDiscNoField.getDiscNo();
                 }
                 if(newDiscNoField.getDiscTotal()>0 )
                 {
                     discTotal = newDiscNoField.getDiscTotal();
                 }
 
                 Mp4DiscNoField mergedDiscNoField = new Mp4DiscNoField(discNo,discTotal);
                 super.setField(mergedDiscNoField);
             }
         }
         else
         {
             super.setField(field);
         }
     }
 
     /**
      * Create Tag Field using mp4 key
      * <p/>
      * Uses the correct subclass for the key
      *
      * @param mp4FieldKey
      * @param value
      * @return
      * @throws KeyNotFoundException
      * @throws FieldDataInvalidException
      */
     public TagField createField(Mp4FieldKey mp4FieldKey, String value) throws KeyNotFoundException, FieldDataInvalidException
     {
         if (value == null)
         {
             throw new IllegalArgumentException(ErrorMessage.GENERAL_INVALID_NULL_ARGUMENT.getMsg());
         }
         if (mp4FieldKey == null)
         {
             throw new KeyNotFoundException();
         }
         switch (mp4FieldKey)
         {
             //This is boolean stored as 1, but calling program might setField as 'true' so we handle this
             //case internally
             case COMPILATION:
                 if(value.equals("true"))
                 {
                     value= Mp4TagByteField.TRUE_VALUE;
                 }
                 return new Mp4TagByteField(mp4FieldKey, value, mp4FieldKey.getFieldLength());
 
             case RATING:
             case BPM:
             case CONTENT_TYPE:
             case TV_SEASON:
             case TV_EPISODE:
             case TOOL:
                 return new Mp4TagByteField(mp4FieldKey, value, mp4FieldKey.getFieldLength());
 
             case GENRE:
                 return createGenreField(value);
 
             case PODCAST_URL:
             case EPISODE_GLOBAL_ID:
                 return new Mp4TagTextNumberField(mp4FieldKey.getFieldName(), value);
 
             case DISCNUMBER:
                 return new Mp4DiscNoField(value);
 
             case TRACK:
                 return new Mp4TrackField(value);
 
             case MUSICBRAINZ_TRACKID:
             case MUSICBRAINZ_ARTISTID:
             case MUSICBRAINZ_ALBUMID:
             case MUSICBRAINZ_ALBUMARTISTID:
             case MUSICBRAINZ_DISCID:
             case MUSICIP_PUID:
             case ASIN:
             case MUSICBRAINZ_ALBUM_STATUS:
             case MUSICBRAINZ_ALBUM_TYPE:
             case RELEASECOUNTRY:
             case PART_OF_GAPLESS_ALBUM:
             case ITUNES_SMPB:
             case ITUNES_NORM:
             case CDDB_1:
             case CDDB_TRACKNUMBER:
             case CDDB_IDS:
             case LYRICIST:
             case CONDUCTOR:
             case REMIXER:
             case ENGINEER:
             case PRODUCER:
             case DJMIXER:
             case MIXER:
             case MOOD:
             case ISRC:
             case MEDIA:
             case LABEL:
             case CATALOGNO:
             case BARCODE:
             case URL_OFFICIAL_RELEASE_SITE:
             case URL_DISCOGS_RELEASE_SITE:
             case URL_WIKIPEDIA_RELEASE_SITE:
             case URL_OFFICIAL_ARTIST_SITE:
             case URL_DISCOGS_ARTIST_SITE:
             case URL_WIKIPEDIA_ARTIST_SITE:
             case LANGUAGE:
             case KEY: 
             case URL_LYRICS_SITE:
                 return new Mp4TagReverseDnsField(mp4FieldKey, value);
 
             case ARTWORK:
                 throw new UnsupportedOperationException(ErrorMessage.ARTWORK_CANNOT_BE_CREATED_WITH_THIS_METHOD.getMsg());
                  
             default:
                 return new Mp4TagTextField(mp4FieldKey.getFieldName(), value);
         }
     }
 
     public List<Artwork> getArtworkList()
     {
         List<TagField> coverartList = get(Mp4FieldKey.ARTWORK);
         List<Artwork> artworkList = new ArrayList<Artwork>(coverartList.size());
 
         for(TagField next:coverartList)
         {
             Mp4TagCoverField mp4CoverArt = (Mp4TagCoverField)next;
             Artwork artwork = new Artwork();
             artwork.setBinaryData(mp4CoverArt.getData());
             artwork.setMimeType(Mp4TagCoverField.getMimeTypeForImageType(mp4CoverArt.getFieldType()));
             artworkList.add(artwork);
         }
         return artworkList;
     }
 
 }

1		/*
2		* Entagged Audio Tag library
3		* Copyright (c) 2003-2005 Raphael Slinckx <raphael@slinckx.net>
4		*
5		* This library is free software; you can redistribute it and/or
6		* modify it under the terms of the GNU Lesser General Public
7		* License as published by the Free Software Foundation; either
8		* version 2.1 of the License, or (at your option) any later version.
9		*
10		* This library is distributed in the hope that it will be useful,
11		* but WITHOUT ANY WARRANTY; without even the implied warranty of
12		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13		* Lesser General Public License for more details.
14		*
15		* You should have received a copy of the GNU Lesser General Public
16		* License along with this library; if not, write to the Free Software
17		* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18		*/
19		package org.jaudiotagger.tag.mp4;
20
21		import org.jaudiotagger.audio.generic.AbstractTag;
22		import org.jaudiotagger.audio.mp4.atom.Mp4BoxHeader;
23		import org.jaudiotagger.logging.ErrorMessage;
24		import org.jaudiotagger.tag.*;
25		import org.jaudiotagger.tag.datatype.Artwork;
26		import static org.jaudiotagger.tag.mp4.Mp4FieldKey.*;
27		import org.jaudiotagger.tag.mp4.field.*;
28
29		import java.util.ArrayList;
30		import java.util.EnumMap;
31		import java.util.List;
32
33		/**
34		* A Logical representation of Mp4Tag, i.e the meta information stored in an Mp4 file underneath the
35		* moov.udt.meta.ilst atom.
36		*/
37	413	public class Mp4Tag extends AbstractTag
38		{
39
40	4	private static final EnumMap<FieldKey, Mp4FieldKey> tagFieldToMp4Field = new EnumMap<FieldKey, Mp4FieldKey>(FieldKey.class);
41
42		//Mapping from generic key to mp4 key
43		static
44		{
45	4	tagFieldToMp4Field.put(FieldKey.ARTIST, Mp4FieldKey.ARTIST);
46	4	tagFieldToMp4Field.put(FieldKey.ALBUM, Mp4FieldKey.ALBUM);
47	4	tagFieldToMp4Field.put(FieldKey.TITLE, Mp4FieldKey.TITLE);
48	4	tagFieldToMp4Field.put(FieldKey.TRACK, Mp4FieldKey.TRACK);
49	4	tagFieldToMp4Field.put(FieldKey.YEAR, Mp4FieldKey.DAY);
50	4	tagFieldToMp4Field.put(FieldKey.GENRE, Mp4FieldKey.GENRE);
51	4	tagFieldToMp4Field.put(FieldKey.COMMENT, Mp4FieldKey.COMMENT);
52	4	tagFieldToMp4Field.put(FieldKey.ALBUM_ARTIST, Mp4FieldKey.ALBUM_ARTIST);
53	4	tagFieldToMp4Field.put(FieldKey.COMPOSER, Mp4FieldKey.COMPOSER);
54	4	tagFieldToMp4Field.put(FieldKey.GROUPING, Mp4FieldKey.GROUPING);
55	4	tagFieldToMp4Field.put(FieldKey.DISC_NO, Mp4FieldKey.DISCNUMBER);
56	4	tagFieldToMp4Field.put(FieldKey.BPM, Mp4FieldKey.BPM);
57	4	tagFieldToMp4Field.put(FieldKey.ENCODER, Mp4FieldKey.ENCODER);
58	4	tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_ARTISTID, Mp4FieldKey.MUSICBRAINZ_ARTISTID);
59	4	tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASEID, Mp4FieldKey.MUSICBRAINZ_ALBUMID);
60	4	tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASEARTISTID, Mp4FieldKey.MUSICBRAINZ_ALBUMARTISTID);
61	4	tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_TRACK_ID, Mp4FieldKey.MUSICBRAINZ_TRACKID);
62	4	tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_DISC_ID, Mp4FieldKey.MUSICBRAINZ_DISCID);
63	4	tagFieldToMp4Field.put(FieldKey.MUSICIP_ID, Mp4FieldKey.MUSICIP_PUID);
64	4	tagFieldToMp4Field.put(FieldKey.AMAZON_ID, Mp4FieldKey.ASIN);
65	4	tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASE_STATUS, Mp4FieldKey.MUSICBRAINZ_ALBUM_STATUS);
66	4	tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASE_TYPE, Mp4FieldKey.MUSICBRAINZ_ALBUM_TYPE);
67	4	tagFieldToMp4Field.put(FieldKey.MUSICBRAINZ_RELEASE_COUNTRY, Mp4FieldKey.RELEASECOUNTRY);
68	4	tagFieldToMp4Field.put(FieldKey.LYRICS, Mp4FieldKey.LYRICS);
69	4	tagFieldToMp4Field.put(FieldKey.IS_COMPILATION, Mp4FieldKey.COMPILATION);
70	4	tagFieldToMp4Field.put(FieldKey.ARTIST_SORT, Mp4FieldKey.ARTIST_SORT);
71	4	tagFieldToMp4Field.put(FieldKey.ALBUM_ARTIST_SORT, Mp4FieldKey.ALBUM_ARTIST_SORT);
72	4	tagFieldToMp4Field.put(FieldKey.ALBUM_SORT, Mp4FieldKey.ALBUM_SORT);
73	4	tagFieldToMp4Field.put(FieldKey.TITLE_SORT, Mp4FieldKey.TITLE_SORT);
74	4	tagFieldToMp4Field.put(FieldKey.COMPOSER_SORT, Mp4FieldKey.COMPOSER_SORT);
75	4	tagFieldToMp4Field.put(FieldKey.COVER_ART, Mp4FieldKey.ARTWORK);
76	4	tagFieldToMp4Field.put(FieldKey.ISRC, Mp4FieldKey.ISRC);
77	4	tagFieldToMp4Field.put(FieldKey.CATALOG_NO, Mp4FieldKey.CATALOGNO);
78	4	tagFieldToMp4Field.put(FieldKey.BARCODE, Mp4FieldKey.BARCODE);
79	4	tagFieldToMp4Field.put(FieldKey.RECORD_LABEL, Mp4FieldKey.LABEL);
80	4	tagFieldToMp4Field.put(FieldKey.LYRICIST, Mp4FieldKey.LYRICIST);
81	4	tagFieldToMp4Field.put(FieldKey.CONDUCTOR, Mp4FieldKey.CONDUCTOR);
82	4	tagFieldToMp4Field.put(FieldKey.REMIXER, Mp4FieldKey.REMIXER);
83	4	tagFieldToMp4Field.put(FieldKey.MOOD, Mp4FieldKey.MOOD);
84	4	tagFieldToMp4Field.put(FieldKey.MEDIA, Mp4FieldKey.MEDIA);
85	4	tagFieldToMp4Field.put(FieldKey.URL_OFFICIAL_RELEASE_SITE, Mp4FieldKey.URL_OFFICIAL_RELEASE_SITE);
86	4	tagFieldToMp4Field.put(FieldKey.URL_DISCOGS_RELEASE_SITE, Mp4FieldKey.URL_DISCOGS_RELEASE_SITE);
87	4	tagFieldToMp4Field.put(FieldKey.URL_WIKIPEDIA_RELEASE_SITE, Mp4FieldKey.URL_WIKIPEDIA_RELEASE_SITE);
88	4	tagFieldToMp4Field.put(FieldKey.URL_OFFICIAL_ARTIST_SITE, Mp4FieldKey.URL_OFFICIAL_ARTIST_SITE);
89	4	tagFieldToMp4Field.put(FieldKey.URL_DISCOGS_ARTIST_SITE, Mp4FieldKey.URL_DISCOGS_ARTIST_SITE);
90	4	tagFieldToMp4Field.put(FieldKey.URL_WIKIPEDIA_ARTIST_SITE, Mp4FieldKey.URL_WIKIPEDIA_ARTIST_SITE);
91	4	tagFieldToMp4Field.put(FieldKey.LANGUAGE, Mp4FieldKey.LANGUAGE);
92	4	tagFieldToMp4Field.put(FieldKey.KEY, Mp4FieldKey.KEY);
93	4	tagFieldToMp4Field.put(FieldKey.URL_LYRICS_SITE, Mp4FieldKey.URL_LYRICS_SITE);
94	4	tagFieldToMp4Field.put(FieldKey.TRACK_TOTAL, Mp4FieldKey.TRACK);
95	4	tagFieldToMp4Field.put(FieldKey.DISC_TOTAL, Mp4FieldKey.DISCNUMBER);
96	4	}
97
98		/**
99		* Create genre field
100		* <p/>
101		* <p>If the content can be parsed to one of the known values use the genre field otherwise
102		* use the custom field.
103		*
104		* @param content
105		* @return
106		*/
107		@SuppressWarnings({"JavaDoc"})
108		private TagField createGenreField(String content)
109		{
110	58	if (content == null)
111		{
112	0	throw new IllegalArgumentException(ErrorMessage.GENERAL_INVALID_NULL_ARGUMENT.getMsg());
113		}
114	58	if (Mp4GenreField.isValidGenre(content))
115		{
116	36	return new Mp4GenreField(content);
117		}
118		else
119		{
120	22	return new Mp4TagTextField(GENRE_CUSTOM.getFieldName(), content);
121		}
122		}
123
124		protected boolean isAllowedEncoding(String enc)
125		{
126	0	return enc.equals(Mp4BoxHeader.CHARSET_UTF_8);
127		}
128
129		public String toString()
130		{
131	136	return "Mpeg4 " + super.toString();
132		}
133
134
135		/**
136		* Maps the generic key to the mp4 key and return the list of values for this field
137		*
138		* @param genericKey
139		*/
140		@SuppressWarnings({"JavaDoc"})
141		@Override
142		public List<TagField> getFields(FieldKey genericKey) throws KeyNotFoundException
143		{
144	111	if (genericKey == null)
145		{
146	0	throw new KeyNotFoundException();
147		}
148	111	return super.get(tagFieldToMp4Field.get(genericKey).getFieldName());
149		}
150
151
152		/**
153		* Retrieve the values that exists for this mp4keyId (this is the internalid actually used)
154		* <p/>
155		*
156		* @param mp4FieldKey
157		* @throws org.jaudiotagger.tag.KeyNotFoundException
158		* @return
159		*/
160		public List<TagField> get(Mp4FieldKey mp4FieldKey) throws KeyNotFoundException
161		{
162	958	if (mp4FieldKey == null)
163		{
164	0	throw new KeyNotFoundException();
165		}
166	958	return super.get(mp4FieldKey.getFieldName());
167		}
168
169		/**
170		* Retrieve the first value that exists for this generic key
171		*
172		* @param genericKey
173		* @return
174		*/
175		public String getFirst(FieldKey genericKey) throws KeyNotFoundException
176		{
177	2515	if (genericKey == null)
178		{
179	0	throw new KeyNotFoundException();
180		}
181
182	2515	if(genericKey== FieldKey.GENRE)
183		{
184	74	List<TagField> genres = get(GENRE.getFieldName());
185	74	if (genres.size() == 0)
186		{
187	30	genres = get(GENRE_CUSTOM.getFieldName());
188		}
189	74	if(genres.size()>0)
190		{
191	74	return ((TagTextField)genres.get(0)).getContent();
192		}
193		else
194		{
195	0	return "";
196		}
197
198		}
199	2441	else if(genericKey== FieldKey.TRACK)
200		{
201	103	List<TagField> list = get(tagFieldToMp4Field.get(genericKey));
202	103	if(list.size()>0)
203		{
204	103	Mp4TrackField trackField = (Mp4TrackField)list.get(0);
205	103	if(trackField.getTrackNo()>0)
206		{
207	103	return String.valueOf(trackField.getTrackNo());
208		}
209		}
210	0	}
211	2338	else if(genericKey== FieldKey.TRACK_TOTAL)
212		{
213	58	List<TagField> list = get(tagFieldToMp4Field.get(genericKey));
214	58	if(list.size()>0)
215		{
216	58	Mp4TrackField trackField = (Mp4TrackField)list.get(0);
217	58	if(trackField.getTrackTotal()>0)
218		{
219	54	return String.valueOf(trackField.getTrackTotal());
220		}
221		}
222	4	}
223	2280	else if(genericKey== FieldKey.DISC_NO)
224		{
225	96	List<TagField> list = get(tagFieldToMp4Field.get(genericKey));
226	96	if(list.size()>0)
227		{
228	96	Mp4DiscNoField discField = (Mp4DiscNoField)list.get(0);
229	96	if(discField.getDiscNo()>0)
230		{
231	96	return String.valueOf(discField.getDiscNo());
232		}
233
234		}
235	0	}
236	2184	else if(genericKey== FieldKey.DISC_TOTAL)
237		{
238	48	List<TagField> list = get(tagFieldToMp4Field.get(genericKey));
239	48	if(list.size()>0)
240		{
241	48	Mp4DiscNoField discField = (Mp4DiscNoField)list.get(0);
242	48	if(discField.getDiscTotal()>0)
243		{
244	48	return String.valueOf(discField.getDiscTotal());
245		}
246		}
247	0	}
248		else
249		{
250	2136	return super.getFirst(tagFieldToMp4Field.get(genericKey).getFieldName());
251		}
252	4	return "";
253		}
254
255		/**
256		* Retrieve the first value that exists for this mp4key
257		*
258		* @param mp4Key
259		* @return
260		* @throws org.jaudiotagger.tag.KeyNotFoundException
261		*/
262		public String getFirst(Mp4FieldKey mp4Key) throws KeyNotFoundException
263		{
264	2215	if (mp4Key == null)
265		{
266	0	throw new KeyNotFoundException();
267		}
268	2215	return super.getFirst(mp4Key.getFieldName());
269		}
270
271		public Mp4TagField getFirstField(FieldKey genericKey) throws KeyNotFoundException
272		{
273	0	if (genericKey == null)
274		{
275	0	throw new KeyNotFoundException();
276		}
277	0	return (Mp4TagField)super.getFirstField(tagFieldToMp4Field.get(genericKey).getFieldName());
278		}
279
280		public Mp4TagField getFirstField(Mp4FieldKey mp4Key) throws KeyNotFoundException
281		{
282	144	if (mp4Key == null)
283		{
284	0	throw new KeyNotFoundException();
285		}
286	144	return (Mp4TagField) super.getFirstField(mp4Key.getFieldName());
287		}
288
289		/**
290		* Delete fields with this generic key
291		*
292		* @param genericKey
293		*/
294		public void deleteField(FieldKey genericKey) throws KeyNotFoundException
295		{
296	4	if (genericKey == null)
297		{
298	0	throw new KeyNotFoundException();
299		}
300	4	super.deleteField(tagFieldToMp4Field.get(genericKey).getFieldName());
301	4	}
302
303		/**
304		* Delete fields with this mp4key
305		*
306		* @param mp4Key
307		* @throws org.jaudiotagger.tag.KeyNotFoundException
308		*/
309		public void deleteField(Mp4FieldKey mp4Key) throws KeyNotFoundException
310		{
311	16	if (mp4Key == null)
312		{
313	0	throw new KeyNotFoundException();
314		}
315	16	super.deleteField(mp4Key.getFieldName());
316	16	}
317
318		/**
319		* Create discno field
320		*
321		* @param content can be any of the following
322		* 1
323		* 1/10
324		* @return
325		* @throws org.jaudiotagger.tag.FieldDataInvalidException
326		*/
327		public TagField createDiscNoField(String content) throws FieldDataInvalidException
328		{
329	0	return new Mp4DiscNoField(content);
330		}
331
332		/**
333		* Create artwork field
334		*
335		* @param data raw image data
336		* @return
337		* @throws org.jaudiotagger.tag.FieldDataInvalidException
338		*/
339		public TagField createArtworkField(byte[] data)
340		{
341	28	return new Mp4TagCoverField(data);
342		}
343
344		/**
345		* Create artwork field
346		*
347		* @return
348		*/
349		public TagField createField(Artwork artwork) throws FieldDataInvalidException
350		{
351	4	return new Mp4TagCoverField(artwork.getBinaryData());
352		}
353
354		/**
355		* Create Tag Field using generic key
356		* <p/>
357		* This should use the correct subclass for the key
358		*
359		* @param genericKey
360		* @param value
361		* @return
362		* @throws KeyNotFoundException
363		* @throws FieldDataInvalidException
364		*/
365		@Override
366		public TagField createField(FieldKey genericKey, String value) throws KeyNotFoundException, FieldDataInvalidException
367		{
368	877	if (value == null)
369		{
370	4	throw new IllegalArgumentException(ErrorMessage.GENERAL_INVALID_NULL_ARGUMENT.getMsg());
371		}
372	873	if (genericKey == null)
373		{
374	0	throw new KeyNotFoundException();
375		}
376
377	873	if(genericKey== FieldKey.TRACK)
378		{
379	8	return new Mp4TrackField(Integer.parseInt(value));
380		}
381	865	else if(genericKey== FieldKey.TRACK_TOTAL)
382		{
383	8	return new Mp4TrackField(0,Integer.parseInt(value));
384		}
385	857	else if(genericKey== FieldKey.DISC_NO)
386		{
387	24	return new Mp4DiscNoField(Integer.parseInt(value));
388		}
389	833	else if(genericKey== FieldKey.DISC_TOTAL)
390		{
391	4	return new Mp4DiscNoField(0,Integer.parseInt(value));
392		}
393		else
394		{
395	829	return createField(tagFieldToMp4Field.get(genericKey), value);
396		}
397		}
398
399		/**
400		* Set field, special handling for track and disc because they hold two fields
401		*
402		* @param field
403		*/
404		@Override
405		public void setField(TagField field)
406		{
407	891	if (field == null)
408		{
409	0	return;
410		}
411
412	891	if(field.getId().equals(TRACK.getFieldName()))
413		{
414	20	List<TagField> list = fields.get(field.getId());
415	20	if(list==null\|\|list.size()==0)
416		{
417	4	super.setField(field);
418		}
419		else
420		{
421	16	Mp4TrackField existingTrackField = (Mp4TrackField)list.get(0);
422	16	Mp4TrackField newTrackField = (Mp4TrackField)field;
423	16	Short trackNo = existingTrackField.getTrackNo();
424	16	Short trackTotal = existingTrackField.getTrackTotal();
425	16	if(newTrackField.getTrackNo()>0 )
426		{
427	8	trackNo = newTrackField.getTrackNo();
428		}
429	16	if(newTrackField.getTrackTotal()>0 )
430		{
431	12	trackTotal = newTrackField.getTrackTotal();
432		}
433
434	16	Mp4TrackField mergedTrackField = new Mp4TrackField(trackNo,trackTotal);
435	16	super.setField(mergedTrackField);
436		}
437	20	}
438	871	else if(field.getId().equals(DISCNUMBER.getFieldName()))
439		{
440	36	List<TagField> list = fields.get(field.getId());
441	36	if(list==null\|\|list.size()==0)
442		{
443	24	super.setField(field);
444		}
445		else
446		{
447	12	Mp4DiscNoField existingDiscNoField = (Mp4DiscNoField)list.get(0);
448	12	Mp4DiscNoField newDiscNoField = (Mp4DiscNoField)field;
449	12	Short discNo = existingDiscNoField.getDiscNo();
450	12	Short discTotal = existingDiscNoField.getDiscTotal();
451	12	if(newDiscNoField.getDiscNo()>0 )
452		{
453	8	discNo = newDiscNoField.getDiscNo();
454		}
455	12	if(newDiscNoField.getDiscTotal()>0 )
456		{
457	12	discTotal = newDiscNoField.getDiscTotal();
458		}
459
460	12	Mp4DiscNoField mergedDiscNoField = new Mp4DiscNoField(discNo,discTotal);
461	12	super.setField(mergedDiscNoField);
462		}
463	36	}
464		else
465		{
466	835	super.setField(field);
467		}
468	891	}
469
470		/**
471		* Create Tag Field using mp4 key
472		* <p/>
473		* Uses the correct subclass for the key
474		*
475		* @param mp4FieldKey
476		* @param value
477		* @return
478		* @throws KeyNotFoundException
479		* @throws FieldDataInvalidException
480		*/
481		public TagField createField(Mp4FieldKey mp4FieldKey, String value) throws KeyNotFoundException, FieldDataInvalidException
482		{
483	836	if (value == null)
484		{
485	0	throw new IllegalArgumentException(ErrorMessage.GENERAL_INVALID_NULL_ARGUMENT.getMsg());
486		}
487	836	if (mp4FieldKey == null)
488		{
489	0	throw new KeyNotFoundException();
490		}
491	836	switch (mp4FieldKey)
492		{
493		//This is boolean stored as 1, but calling program might setField as 'true' so we handle this
494		//case internally
495		case COMPILATION:
496	2	if(value.equals("true"))
497		{
498	1	value= Mp4TagByteField.TRUE_VALUE;
499		}
500	2	return new Mp4TagByteField(mp4FieldKey, value, mp4FieldKey.getFieldLength());
501
502		case RATING:
503		case BPM:
504		case CONTENT_TYPE:
505		case TV_SEASON:
506		case TV_EPISODE:
507		case TOOL:
508	38	return new Mp4TagByteField(mp4FieldKey, value, mp4FieldKey.getFieldLength());
509
510		case GENRE:
511	58	return createGenreField(value);
512
513		case PODCAST_URL:
514		case EPISODE_GLOBAL_ID:
515	0	return new Mp4TagTextNumberField(mp4FieldKey.getFieldName(), value);
516
517		case DISCNUMBER:
518	0	return new Mp4DiscNoField(value);
519
520		case TRACK:
521	0	return new Mp4TrackField(value);
522
523		case MUSICBRAINZ_TRACKID:
524		case MUSICBRAINZ_ARTISTID:
525		case MUSICBRAINZ_ALBUMID:
526		case MUSICBRAINZ_ALBUMARTISTID:
527		case MUSICBRAINZ_DISCID:
528		case MUSICIP_PUID:
529		case ASIN:
530		case MUSICBRAINZ_ALBUM_STATUS:
531		case MUSICBRAINZ_ALBUM_TYPE:
532		case RELEASECOUNTRY:
533		case PART_OF_GAPLESS_ALBUM:
534		case ITUNES_SMPB:
535		case ITUNES_NORM:
536		case CDDB_1:
537		case CDDB_TRACKNUMBER:
538		case CDDB_IDS:
539		case LYRICIST:
540		case CONDUCTOR:
541		case REMIXER:
542		case ENGINEER:
543		case PRODUCER:
544		case DJMIXER:
545		case MIXER:
546		case MOOD:
547		case ISRC:
548		case MEDIA:
549		case LABEL:
550		case CATALOGNO:
551		case BARCODE:
552		case URL_OFFICIAL_RELEASE_SITE:
553		case URL_DISCOGS_RELEASE_SITE:
554		case URL_WIKIPEDIA_RELEASE_SITE:
555		case URL_OFFICIAL_ARTIST_SITE:
556		case URL_DISCOGS_ARTIST_SITE:
557		case URL_WIKIPEDIA_ARTIST_SITE:
558		case LANGUAGE:
559		case KEY:
560		case URL_LYRICS_SITE:
561	294	return new Mp4TagReverseDnsField(mp4FieldKey, value);
562
563		case ARTWORK:
564	4	throw new UnsupportedOperationException(ErrorMessage.ARTWORK_CANNOT_BE_CREATED_WITH_THIS_METHOD.getMsg());
565
566		default:
567	853	return new Mp4TagTextField(mp4FieldKey.getFieldName(), value);
568		}
569		}
570
571		public List<Artwork> getArtworkList()
572		{
573	32	List<TagField> coverartList = get(Mp4FieldKey.ARTWORK);
574	32	List<Artwork> artworkList = new ArrayList<Artwork>(coverartList.size());
575
576	32	for(TagField next:coverartList)
577		{
578	24	Mp4TagCoverField mp4CoverArt = (Mp4TagCoverField)next;
579	24	Artwork artwork = new Artwork();
580	24	artwork.setBinaryData(mp4CoverArt.getData());
581	24	artwork.setMimeType(Mp4TagCoverField.getMimeTypeForImageType(mp4CoverArt.getFieldType()));
582	24	artworkList.add(artwork);
583	24	}
584	32	return artworkList;
585		}
586
587		}