/*

  *  MusicTag Copyright (C)2003,2004

  *

  *  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,

  *  you can get a copy from http://www.opensource.org/licenses/lgpl-license.php or write to the Free Software

  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

  */

 package org.jaudiotagger.tag.id3;

 import org.jaudiotagger.FileConstants;

 import org.jaudiotagger.audio.generic.Utils;

 import org.jaudiotagger.audio.mp3.MP3File;

 import org.jaudiotagger.tag.EmptyFrameException;

 import org.jaudiotagger.tag.InvalidFrameException;

 import org.jaudiotagger.tag.InvalidFrameIdentifierException;

 import org.jaudiotagger.tag.id3.framebody.AbstractID3v2FrameBody;

 import org.jaudiotagger.tag.id3.framebody.FrameBodyDeprecated;

 import org.jaudiotagger.tag.id3.framebody.FrameBodyUnsupported;

 import org.jaudiotagger.tag.id3.framebody.ID3v23FrameBody;

 import java.io.ByteArrayOutputStream;

 import java.io.IOException;

 import java.nio.ByteBuffer;

 import java.util.regex.Matcher;

 import java.util.regex.Pattern;

 import java.util.zip.DataFormatException;

 import java.util.zip.Inflater;

 /**

  * Represents an ID3v2.3 frame.

  *

  * @author : Paul Taylor

  * @author : Eric Farng

  * @version $Id: ID3v23Frame.java 836 2009-11-12 15:44:07Z paultaylor $

  */

 public class ID3v23Frame extends AbstractID3v2Frame

 {

     private static Pattern validFrameIdentifier = Pattern.compile("[A-Z][0-9A-Z]{3}");

     protected static final int FRAME_ID_SIZE = 4;

     protected static final int FRAME_FLAGS_SIZE = 2;

     protected static final int FRAME_SIZE_SIZE = 4;

     protected static final int FRAME_COMPRESSION_UNCOMPRESSED_SIZE = 4;

     protected static final int FRAME_ENCRYPTION_INDICATOR_SIZE = 1;

     protected static final int FRAME_GROUPING_INDICATOR_SIZE = 1;

     protected static final int FRAME_HEADER_SIZE = FRAME_ID_SIZE + FRAME_SIZE_SIZE + FRAME_FLAGS_SIZE;

     /**

      * Creates a new ID3v23 Frame

      */

     public ID3v23Frame()

     {

     }

     /**

      * Creates a new ID3v23 Frame of type identifier.

      * <p/>

      * <p>An empty body of the correct type will be automatically created.

      * This constructor should be used when wish to create a new

      * frame from scratch using user data.

      * @param identifier

      */

     public ID3v23Frame(String identifier)

     {

         super(identifier);

         statusFlags = new StatusFlags();

         encodingFlags = new EncodingFlags();

     }

     /**

      * Copy Constructor

      * <p/>

      * Creates a new v23 frame  based on another v23 frame

      * @param frame

      */

     public ID3v23Frame(ID3v23Frame frame)

     {

         super(frame);

         statusFlags = new StatusFlags(frame.getStatusFlags().getOriginalFlags());

         encodingFlags = new EncodingFlags(frame.getEncodingFlags().getFlags());

     }

     /**

      * Creates a new ID3v23Frame  based on another frame.

      *

      * @param frame

      * @throws org.jaudiotagger.tag.InvalidFrameException

      */

     public ID3v23Frame(AbstractID3v2Frame frame) throws InvalidFrameException

     {

         logger.finer("Creating frame from a frame of a different version");

         if (frame instanceof ID3v23Frame)

         {

             throw new UnsupportedOperationException("Copy Constructor not called. Please type cast the argument");

         }

         if (frame instanceof ID3v24Frame)

         {

             statusFlags = new StatusFlags((ID3v24Frame.StatusFlags) frame.getStatusFlags());

             encodingFlags = new EncodingFlags(frame.getEncodingFlags().getFlags());

         }

         if (frame instanceof ID3v24Frame)

         {

             //Unknown Frame e.g NCON,also protects when known id but has unsupported frame body

             if (frame.getBody() instanceof FrameBodyUnsupported)

             {

                 this.frameBody = new FrameBodyUnsupported((FrameBodyUnsupported) frame.getBody());

                 this.frameBody.setHeader(this);

                 identifier = frame.getIdentifier();

                 logger.info("UNKNOWN:Orig id is:" + frame.getIdentifier() + ":New id is:" + identifier);

                 return;

             }

             // Deprecated frame for v24

             else if (frame.getBody() instanceof FrameBodyDeprecated)

             {

                 //Was it valid for this tag version, if so try and reconstruct

                 if (ID3Tags.isID3v23FrameIdentifier(frame.getIdentifier()))

                 {

                     this.frameBody = ((FrameBodyDeprecated) frame.getBody()).getOriginalFrameBody();

                     this.frameBody.setHeader(this);

                     identifier = frame.getIdentifier();

                     logger.info("DEPRECATED:Orig id is:" + frame.getIdentifier() + ":New id is:" + identifier);

                 }

                 //or was it still deprecated, if so leave as is

                 else

                 {

                     this.frameBody = new FrameBodyDeprecated((FrameBodyDeprecated) frame.getBody());

                     this.frameBody.setHeader(this);

                     identifier = frame.getIdentifier();

                     logger.info("DEPRECATED:Orig id is:" + frame.getIdentifier() + ":New id is:" + identifier);

                     return;

                 }

             }

             else if (ID3Tags.isID3v24FrameIdentifier(frame.getIdentifier()))

             {

                 logger.finer("isID3v24FrameIdentifier");

                 //Version between v4 and v3

                 identifier = ID3Tags.convertFrameID24To23(frame.getIdentifier());

                 if (identifier != null)

                 {

                     logger.finer("V4:Orig id is:" + frame.getIdentifier() + ":New id is:" + identifier);

                     this.frameBody = (AbstractTagFrameBody) ID3Tags.copyObject(frame.getBody());

                     this.frameBody.setHeader(this);

                     return;

                 }

                 else

                 {

                     //Is it a known v4 frame which needs forcing to v3 frame e.g. TDRC - TYER,TDAT

                     identifier = ID3Tags.forceFrameID24To23(frame.getIdentifier());

                     if (identifier != null)

                     {

                         logger.finer("V4:Orig id is:" + frame.getIdentifier() + ":New id is:" + identifier);

                         this.frameBody = this.readBody(identifier, (AbstractID3v2FrameBody) frame.getBody());

                         this.frameBody.setHeader(this);

                         return;

                     }

                     //It is a v24 frame that is not known and cannot be forced in v23 e.g TDRL,in which case

                     //we convert to a framebody unsupported by writing contents as a byte array and feeding

                     //it into FrameBodyUnsupported

                     else

                     {

                         ByteArrayOutputStream baos = new ByteArrayOutputStream();

                         ((AbstractID3v2FrameBody) frame.getBody()).write(baos);

                         identifier = frame.getIdentifier();

                         this.frameBody = new FrameBodyUnsupported(identifier, baos.toByteArray());

                         this.frameBody.setHeader(this);

                         logger.finer("V4:Orig id is:" + frame.getIdentifier() + ":New Id Unsupported is:" + identifier);

                         return;

                     }

                 }

             }

             // Unable to find a suitable framebody, this shold not happen

             else

             {

                 logger.severe("Orig id is:" + frame.getIdentifier() + "Unable to create Frame Body");

                 throw new InvalidFrameException("Orig id is:" + frame.getIdentifier() + "Unable to create Frame Body");

             }

         }

         else if (frame instanceof ID3v22Frame)

         {

             if (ID3Tags.isID3v22FrameIdentifier(frame.getIdentifier()))

             {

                 identifier = ID3Tags.convertFrameID22To23(frame.getIdentifier());

                 if (identifier != null)

                 {

                     logger.info("V3:Orig id is:" + frame.getIdentifier() + ":New id is:" + identifier);

                     this.frameBody = (AbstractTagFrameBody) ID3Tags.copyObject(frame.getBody());

                     this.frameBody.setHeader(this);

                     return;

                 }

                 //Is it a known v2 frame which needs forcing to v23 frame e.g PIC - APIC

                 else if (ID3Tags.isID3v22FrameIdentifier(frame.getIdentifier()))

                 {

                     //Force v2 to v3

                     identifier = ID3Tags.forceFrameID22To23(frame.getIdentifier());

                     if (identifier != null)

                     {

                         logger.info("V22Orig id is:" + frame.getIdentifier() + "New id is:" + identifier);

                         this.frameBody = this.readBody(identifier, (AbstractID3v2FrameBody) frame.getBody());

                         this.frameBody.setHeader(this);

                         return;

                     }

                     //No mechanism exists to convert it to a v23 frame

                     else

                     {

                         this.frameBody = new FrameBodyDeprecated((AbstractID3v2FrameBody) frame.getBody());

                         this.frameBody.setHeader(this);

                         identifier = frame.getIdentifier();

                         logger.info("Deprecated:V22:orig id id is:" + frame.getIdentifier() + ":New id is:" + identifier);

                         return;

                     }

                 }

             }

             // Unknown Frame e.g NCON

             else

             {

                 this.frameBody = new FrameBodyUnsupported((FrameBodyUnsupported) frame.getBody());

                 this.frameBody.setHeader(this);

                 identifier = frame.getIdentifier();

                 logger.info("UNKNOWN:Orig id is:" + frame.getIdentifier() + ":New id is:" + identifier);

                 return;

             }

         }

         logger.warning("Frame is unknown version:"+frame.getClass());

     }

     /**

      * Creates a new ID3v23Frame datatype by reading from byteBuffer.

      *

      * @param byteBuffer to read from

      * @param loggingFilename

      * @throws org.jaudiotagger.tag.InvalidFrameException

      */

     public ID3v23Frame(ByteBuffer byteBuffer, String loggingFilename) throws InvalidFrameException

     {

         setLoggingFilename(loggingFilename);

         read(byteBuffer);

     }

     /**

      * Creates a new ID3v23Frame datatype by reading from byteBuffer.

      *

      * @param byteBuffer to read from

      * @deprecated use {@link #ID3v23Frame(ByteBuffer,String)} instead

      * @throws org.jaudiotagger.tag.InvalidFrameException

      */

     public ID3v23Frame(ByteBuffer byteBuffer) throws InvalidFrameException

     {

         this(byteBuffer, "");

     }

     /**

      * Return size of frame

      *

      * @return int frame size

      */

     public int getSize()

     {

         return frameBody.getSize() + ID3v23Frame.FRAME_HEADER_SIZE;

     }

     /**

      * Compare for equality

      * To be deemed equal obj must be a IDv23Frame with the same identifier

      * and the same flags.

      * containing the same body,datatype list ectera.

      * equals() method is made up from all the various components

      *

      * @param obj

      * @return if true if this object is equivalent to obj

      */

     public boolean equals(Object obj)

     {

         if (!(obj instanceof ID3v23Frame))

         {

             return false;

         }

         ID3v23Frame object = (ID3v23Frame) obj;

         if (this.statusFlags.getOriginalFlags() != object.statusFlags.getOriginalFlags())

         {

             return false;

         }

         return this.encodingFlags.getFlags() == object.encodingFlags.getFlags() && super.equals(obj);

     }

     /**

      * Read the frame from a bytebuffer

      *

      * @param byteBuffer buffer to read from

      */

     public void read(ByteBuffer byteBuffer) throws InvalidFrameException

     {

         logger.info(getLoggingFilename() + ":Read Frame from byteBuffer");

         if (byteBuffer.position() + FRAME_HEADER_SIZE >= byteBuffer.limit())

         {

             logger.warning(getLoggingFilename() + ":No space to find another frame:");

             throw new InvalidFrameException(getLoggingFilename() + ":No space to find another frame");

         }

         byte[] buffer = new byte[FRAME_ID_SIZE];

         // Read the Frame Identifier

         byteBuffer.get(buffer, 0, FRAME_ID_SIZE);

         identifier = new String(buffer);

         // Is this a valid identifier?

         if (!isValidID3v2FrameIdentifier(identifier))

         {

             logger.info(getLoggingFilename() + ":Invalid identifier:" + identifier);

             byteBuffer.position(byteBuffer.position() - (FRAME_ID_SIZE - 1));

             throw new InvalidFrameIdentifierException(getLoggingFilename() + ":" + identifier + "is not a valid ID3v2.30 frame");

         }

         //Read the size field (as Big Endian Int - byte buffers always initlised to Big endian order)

         frameSize = byteBuffer.getInt();

         if (frameSize < 0)

         {

             logger.warning(getLoggingFilename() + ":Invalid Frame Size:" + identifier);

             throw new InvalidFrameException(identifier + " is invalid frame");

         }

         else if (frameSize == 0)

         {

             logger.warning(getLoggingFilename() + ":Empty Frame Size:" + identifier);

             //We dont process this frame or add to framemap becuase contains no useful information

             //Skip the two flag bytes so in correct position for subsequent frames

             byteBuffer.get();

             byteBuffer.get();

             throw new EmptyFrameException(identifier + " is empty frame");

         }

         else if (frameSize > byteBuffer.remaining())

         {

             logger.warning(getLoggingFilename() + ":Invalid Frame size of " +frameSize +" larger than size of" + byteBuffer.remaining() + " before mp3 audio:" + identifier);

             throw new InvalidFrameException(identifier + " is invalid frame");

         }

         //Read the flag bytes

         statusFlags = new StatusFlags(byteBuffer.get());

         encodingFlags = new EncodingFlags(byteBuffer.get());

         String id;

         //If this identifier is a valid v24 identifier or easily converted to v24

         id = ID3Tags.convertFrameID23To24(identifier);

         // Cant easily be converted to v23 but is it a valid v24 identifier

         if (id == null)

         {

             // It is a valid v23 identifier so should be able to find a

             //  frame body for it.

             if (ID3Tags.isID3v23FrameIdentifier(identifier))

             {

                 id = identifier;

             }

             // Unknown so will be created as FrameBodyUnsupported

             else

             {

                 id = UNSUPPORTED_ID;

             }

         }

         logger.fine(getLoggingFilename() + ":Identifier was:" + identifier + " reading using:" + id + "with frame size:" + frameSize);

         //Read extra bits appended to frame header for various encodings

         //These are not included in header size but are included in frame size but wont be read when we actually

         //try to read the frame body data

         int extraHeaderBytesCount = 0;

         int decompressedFrameSize = -1;

         if (((EncodingFlags) encodingFlags).isCompression())

         {

             //Read the Decompressed Size

             decompressedFrameSize = byteBuffer.getInt();

             extraHeaderBytesCount = FRAME_COMPRESSION_UNCOMPRESSED_SIZE;

             logger.fine(getLoggingFilename() + ":Decompressed frame size is:" + decompressedFrameSize);

         }

         if (((EncodingFlags) encodingFlags).isEncryption())

         {

             //Read the Encryption byte, but do nothing with it

             extraHeaderBytesCount += FRAME_ENCRYPTION_INDICATOR_SIZE;

             byteBuffer.get();

         }

         if (((EncodingFlags) encodingFlags).isGrouping())

         {

             //Read the Grouping byte, but do nothing with it

             extraHeaderBytesCount += FRAME_GROUPING_INDICATOR_SIZE;

             byteBuffer.get();

         }

         //Work out the real size of the framebody data

         int realFrameSize = frameSize - extraHeaderBytesCount;

         ByteBuffer frameBodyBuffer = null;

         //Uncompress the frame

         if (((EncodingFlags) encodingFlags).isCompression())

         {

             // Decompress the bytes into this buffer, size initialized from header field

             byte[] result = new byte[decompressedFrameSize];

             byte[] input = new byte[realFrameSize];

             //Store position ( just after frame header and any extra bits)

             //Read frame data into array, and then put buffer back to where it was

             int position = byteBuffer.position();

             byteBuffer.get(input, 0, realFrameSize);

             byteBuffer.position(position);

             Inflater decompresser = new Inflater();

             decompresser.setInput(input);

             try

             {

                 decompresser.inflate(result);

             }

             catch (DataFormatException dfe)

             {

                 dfe.printStackTrace();

                 //Update position of main buffer, so no attempt is made to reread these bytes

                 byteBuffer.position(byteBuffer.position() + realFrameSize);

                 throw new InvalidFrameException(getLoggingFilename() + "Unable to decompress this frame:" + identifier + ":" + dfe.getMessage());

             }

             decompresser.end();

             frameBodyBuffer = ByteBuffer.wrap(result);

         }

         //Read the body data

         try

         {

             if (((EncodingFlags) encodingFlags).isCompression())

             {

                 frameBody = readBody(id, frameBodyBuffer, decompressedFrameSize);

             }

             else

             {

                 //Create Buffer that only contains the body of this frame rather than the remainder of tag

                 frameBodyBuffer = byteBuffer.slice();

                 frameBodyBuffer.limit(realFrameSize);

                 frameBody = readBody(id, frameBodyBuffer, realFrameSize);

             }

             //TODO code seems to assume that if the frame created is not a v23FrameBody

             //it should be deprecated, but what about if somehow a V24Frame has been put into a V23 Tag, shouldnt

             //it then be created as FrameBodyUnsupported

             if (!(frameBody instanceof ID3v23FrameBody))

             {

                 logger.info(getLoggingFilename() + ":Converted frame body with:" + identifier + " to deprecated framebody");

                 frameBody = new FrameBodyDeprecated((AbstractID3v2FrameBody) frameBody);

             }

         }

         finally

         {

             //Update position of main buffer, so no attempt is made to reread these bytes

             byteBuffer.position(byteBuffer.position() + realFrameSize);

         }

     }

     /**

      * Write the frame to bufferOutputStream

      *

      * @throws IOException

      */

     public void write(ByteArrayOutputStream tagBuffer)

     {

         logger.info("Writing frame to buffer:" + getIdentifier());

         //This is where we will write header, move position to where we can

         //write body

         ByteBuffer headerBuffer = ByteBuffer.allocate(FRAME_HEADER_SIZE);

         //Write Frame Body Data

         ByteArrayOutputStream bodyOutputStream = new ByteArrayOutputStream();

         ((AbstractID3v2FrameBody) frameBody).write(bodyOutputStream);

         //Write Frame Header write Frame ID

         if (getIdentifier().length() == 3)

         {

             identifier = identifier + ' ';

         }

         headerBuffer.put(Utils.getDefaultBytes(getIdentifier(), "ISO-8859-1"), 0, FRAME_ID_SIZE);

         //Write Frame Size

         int size = frameBody.getSize();

         logger.fine("Frame Size Is:" + size);

         headerBuffer.putInt(frameBody.getSize());

         //Write the Flags

         //Status Flags:leave as they were when we read

         headerBuffer.put(statusFlags.getWriteFlags());

         //Enclosing Flags, first reset

         encodingFlags.resetFlags();

         //Encoding we dont support any of flags so don't set any

         headerBuffer.put(encodingFlags.getFlags());

         try

         {

             //Add header to the Byte Array Output Stream

             tagBuffer.write(headerBuffer.array());

             //Add body to the Byte Array Output Stream

             tagBuffer.write(bodyOutputStream.toByteArray());

         }

         catch (IOException ioe)

         {

             //This could never happen coz not writing to file, so convert to RuntimeException

             throw new RuntimeException(ioe);

         }

     }

     protected AbstractID3v2Frame.StatusFlags getStatusFlags()

     {

         return statusFlags;

     }

     protected AbstractID3v2Frame.EncodingFlags getEncodingFlags()

     {

         return encodingFlags;

     }

     /**

      * This represents a frame headers Status Flags

      * Make adjustments if necessary based on frame type and specification.

      */

     class StatusFlags extends AbstractID3v2Frame.StatusFlags

     {

         public static final String TYPE_TAGALTERPRESERVATION = "typeTagAlterPreservation";

         public static final String TYPE_FILEALTERPRESERVATION = "typeFileAlterPreservation";

         public static final String TYPE_READONLY = "typeReadOnly";

         /**

          * Discard frame if tag altered

          */

         public static final int MASK_TAG_ALTER_PRESERVATION = FileConstants.BIT7;

         /**

          * Discard frame if audio file part  altered

          */

         public static final int MASK_FILE_ALTER_PRESERVATION = FileConstants.BIT6;

         /**

          * Frame tagged as read only

          */

         public static final int MASK_READ_ONLY = FileConstants.BIT5;

         public StatusFlags()

         {

             originalFlags = (byte) 0;

             writeFlags = (byte) 0;

         }

         StatusFlags(byte flags)

         {

             originalFlags = flags;

             writeFlags = flags;

             modifyFlags();

         }

         /**

          * Use this constructor when convert a v24 frame

          * @param statusFlags

          */

         StatusFlags(ID3v24Frame.StatusFlags statusFlags)

         {

             originalFlags = convertV4ToV3Flags(statusFlags.getOriginalFlags());

             writeFlags = originalFlags;

             modifyFlags();

         }

         private byte convertV4ToV3Flags(byte v4Flag)

         {

             byte v3Flag = (byte) 0;

             if ((v4Flag & ID3v24Frame.StatusFlags.MASK_FILE_ALTER_PRESERVATION) != 0)

             {

                 v3Flag |= (byte) MASK_FILE_ALTER_PRESERVATION;

             }

             if ((v4Flag & ID3v24Frame.StatusFlags.MASK_TAG_ALTER_PRESERVATION) != 0)

             {

                 v3Flag |= (byte) MASK_TAG_ALTER_PRESERVATION;

             }

             return v3Flag;

         }

         protected void modifyFlags()

         {

             String str = getIdentifier();

             if (ID3v23Frames.getInstanceOf().isDiscardIfFileAltered(str))

             {

                 writeFlags |= (byte) MASK_FILE_ALTER_PRESERVATION;

                 writeFlags &= (byte) ~MASK_TAG_ALTER_PRESERVATION;

             }

             else

             {

                 writeFlags &= (byte) ~MASK_FILE_ALTER_PRESERVATION;

                 writeFlags &= (byte) ~MASK_TAG_ALTER_PRESERVATION;

             }

         }

         public void createStructure()

         {

             MP3File.getStructureFormatter().openHeadingElement(TYPE_FLAGS, "");

             MP3File.getStructureFormatter().addElement(TYPE_TAGALTERPRESERVATION, originalFlags & MASK_TAG_ALTER_PRESERVATION);

             MP3File.getStructureFormatter().addElement(TYPE_FILEALTERPRESERVATION, originalFlags & MASK_FILE_ALTER_PRESERVATION);

             MP3File.getStructureFormatter().addElement(TYPE_READONLY, originalFlags & MASK_READ_ONLY);

             MP3File.getStructureFormatter().closeHeadingElement(TYPE_FLAGS);

         }

     }

     /**

      * This represents a frame headers Encoding Flags

      */

     class EncodingFlags extends AbstractID3v2Frame.EncodingFlags

     {

         public static final String TYPE_COMPRESSION = "compression";

         public static final String TYPE_ENCRYPTION = "encryption";

         public static final String TYPE_GROUPIDENTITY = "groupidentity";

         /**

          * Frame is compressed

          */

         public static final int MASK_COMPRESSION = FileConstants.BIT7;

         /**

          * Frame is encrypted

          */

         public static final int MASK_ENCRYPTION = FileConstants.BIT6;

         /**

          * Frame is part of a group

          */

         public static final int MASK_GROUPING_IDENTITY = FileConstants.BIT5;

         public EncodingFlags()

         {

             super();

         }

         public EncodingFlags(byte flags)

         {

             super(flags);

             logEnabledFlags();

         }

         public void logEnabledFlags()

         {

             if (isCompression())

             {

                 logger.warning(getLoggingFilename() + ":" + identifier + " is compressed");

             }

             if (isEncryption())

             {

                 logger.warning(getLoggingFilename() + ":" + identifier + " is encrypted");

             }

             if (isGrouping())

             {

                 logger.warning(getLoggingFilename() + ":" + identifier + " is grouped");

             }

         }

         public boolean isCompression()

         {

             return (flags & MASK_COMPRESSION) > 0;

         }

         public boolean isEncryption()

         {

             return (flags & MASK_ENCRYPTION) > 0;

         }

         public boolean isGrouping()

         {

             return (flags & MASK_GROUPING_IDENTITY) > 0;

         }

         public void createStructure()

         {

             MP3File.getStructureFormatter().openHeadingElement(TYPE_FLAGS, "");

             MP3File.getStructureFormatter().addElement(TYPE_COMPRESSION, flags & MASK_COMPRESSION);

             MP3File.getStructureFormatter().addElement(TYPE_ENCRYPTION, flags & MASK_ENCRYPTION);

             MP3File.getStructureFormatter().addElement(TYPE_GROUPIDENTITY, flags & MASK_GROUPING_IDENTITY);

             MP3File.getStructureFormatter().closeHeadingElement(TYPE_FLAGS);

         }

     }

     /**

      * Does the frame identifier meet the syntax for a idv3v2 frame identifier.

      * must start with a capital letter and only contain capital letters and numbers

      *

      * @param identifier to be checked

      * @return whether the identifier is valid

      */

     public boolean isValidID3v2FrameIdentifier(String identifier)

     {

         Matcher m = ID3v23Frame.validFrameIdentifier.matcher(identifier);

         return m.matches();

     }

     /**

      * Return String Representation of body

      */

     public void createStructure()

     {

         MP3File.getStructureFormatter().openHeadingElement(TYPE_FRAME, getIdentifier());

         MP3File.getStructureFormatter().addElement(TYPE_FRAME_SIZE, frameSize);

         statusFlags.createStructure();

         encodingFlags.createStructure();

         frameBody.createStructure();

         MP3File.getStructureFormatter().closeHeadingElement(TYPE_FRAME);

     }

     /**

      * @return true if considered a common frame

      */

     public boolean isCommon()

     {

         return ID3v23Frames.getInstanceOf().isCommon(getId());

     }

     /**

      * @return true if considered a common frame

      */

     public boolean isBinary()

     {

         return ID3v23Frames.getInstanceOf().isBinary(getId());

     }

 }