/*
* Entagged Audio Tag library
* Copyright (c) 2003-2005 Raphaël 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.vorbiscomment;
import org.jaudiotagger.audio.generic.Utils;
import org.jaudiotagger.audio.ogg.util.VorbisHeader;
import org.jaudiotagger.tag.TagField;
import org.jaudiotagger.tag.TagTextField;
import static org.jaudiotagger.tag.vorbiscomment.VorbisCommentFieldKey.*;
import java.io.UnsupportedEncodingException;
/**
* This class represents the name and content of a tag entry in ogg-files.
* <br>
*
* @author @author Raphael Slinckx (KiKiDonK)
* @author Christian Laireiter (liree)
*/
public class VorbisCommentTagField implements TagTextField {
/**
* If <code>true</code>, the id of the current encapsulated tag field is
* specified as a common field. <br>
* Example is "ARTIST" which should be interpreted by any application as the
* artist of the media content. <br>
* Will be set during construction with {@link #checkCommon()}.
*/
private boolean common;
/**
* Stores the content of the tag field. <br>
*/
private String content;
/**
* Stores the id (name) of the tag field. <br>
*/
private String id;
/**
* If id is invalid
*/
private static final String ERRONEOUS_ID = "ERRONEOUS";
/**
* Creates an instance.
*
* @param raw Raw byte data of the tagfield.
* @throws UnsupportedEncodingException If the data doesn't conform "UTF-8" specification.
*/
public VorbisCommentTagField(byte[] raw) throws UnsupportedEncodingException {
String field = new String(raw, "UTF-8");
int i = field.indexOf("=");
if (i == -1) {
//Beware that ogg ID, must be capitalized and contain no space..
this.id = ERRONEOUS_ID;
this.content = field;
} else {
this.id = field.substring(0, i).toUpperCase();
if (field.length() > i) {
this.content = field.substring(i + 1);
} else {
//We have "XXXXXX=" with nothing after the "="
this.content = "";
}
}
checkCommon();
}
/**
* Creates an instance.
*
* @param fieldId ID (name) of the field.
* @param fieldContent Content of the field.
*/
public VorbisCommentTagField(String fieldId, String fieldContent) {
this.id = fieldId.toUpperCase();
this.content = fieldContent;
checkCommon();
}
/**
* This method examines the ID of the current field and modifies
* {@link #common}in order to reflect if the tag id is a commonly used one.
* <br>
*/
private void checkCommon() {
this.common = id.equals(TITLE.getFieldName()) || id.equals(ALBUM.getFieldName()) || id.equals(ARTIST.getFieldName())
|| id.equals(GENRE.getFieldName()) || id.equals(TRACKNUMBER.getFieldName()) || id.equals(DATE.getFieldName())
|| id.equals(DESCRIPTION.getFieldName()) || id.equals(COMMENT.getFieldName());
}
/**
* This method will copy all bytes of <code>src</code> to <code>dst</code>
* at the specified location.
*
* @param src bytes to copy.
* @param dst where to copy to.
* @param dstOffset at which position of <code>dst</code> the data should be
* copied.
*/
protected void copy(byte[] src, byte[] dst, int dstOffset) {
// for (int i = 0; i < src.length; i++)
// dst[i + dstOffset] = src[i];
/*
* Heared that this method is optimized and does its job very near of
* the system.
*/
System.arraycopy(src, 0, dst, dstOffset, src.length);
}
/**
* @see TagField#copyContent(TagField)
*/
public void copyContent(TagField field) {
if (field instanceof TagTextField) {
this.content = ((TagTextField) field).getContent();
}
}
/**
* This method will try to return the byte representation of the given
* string after it has been converted to the given encoding. <br>
*
* @param s The string whose converted bytes should be returned.
* @param encoding The encoding type to which the string should be converted.
* @return If <code>encoding</code> is supported the byte data of the
* given string is returned in that encoding.
* @throws UnsupportedEncodingException If the requested encoding is not available.
*/
protected byte[] getBytes(String s, String encoding) throws UnsupportedEncodingException {
return s.getBytes(encoding);
}
/**
* @see TagTextField#getContent()
*/
public String getContent() {
return content;
}
/**
* @see TagTextField#getEncoding()
*/
public String getEncoding() {
return VorbisHeader.CHARSET_UTF_8;
}
/**
* @see TagField#getId()
*/
public String getId() {
return this.id;
}
/**
* @see TagField#getRawContent()
*/
public byte[] getRawContent() throws UnsupportedEncodingException {
byte[] size = new byte[VorbisCommentReader.FIELD_COMMENT_LENGTH_LENGTH];
byte[] idBytes = Utils.getDefaultBytes(this.id, "ISO-8859-1");
byte[] contentBytes = getBytes(this.content, "UTF-8");
byte[] b = new byte[4 + idBytes.length + 1 + contentBytes.length];
int length = idBytes.length + 1 + contentBytes.length;
size[3] = (byte) ((length & 0xFF000000) >> 24);
size[2] = (byte) ((length & 0x00FF0000) >> 16);
size[1] = (byte) ((length & 0x0000FF00) >> 8);
size[0] = (byte) (length & 0x000000FF);
int offset = 0;
copy(size, b, offset);
offset += 4;
copy(idBytes, b, offset);
offset += idBytes.length;
b[offset] = (byte) 0x3D;
offset++;// "="
copy(contentBytes, b, offset);
return b;
}
/**
* @see TagField#isBinary()
*/
public boolean isBinary() {
return false;
}
/**
* @see TagField#isBinary(boolean)
*/
public void isBinary(boolean b) {
if (b) {
// Only throw if binary = true requested.
throw new UnsupportedOperationException("OggTagFields cannot be changed to binary.\n" + "binary data should be stored elsewhere" + " according to Vorbis_I_spec.");
}
}
/**
* @see TagField#isCommon()
*/
public boolean isCommon() {
return common;
}
/**
* @see TagField#isEmpty()
*/
public boolean isEmpty() {
return this.content.equals("");
}
/**
* @see TagTextField#setContent(String)
*/
public void setContent(String s) {
this.content = s;
}
/**
* @see TagTextField#setEncoding(String)
*/
public void setEncoding(String s) {
if (s == null || !s.equalsIgnoreCase("UTF-8")) {
throw new UnsupportedOperationException("The encoding of OggTagFields cannot be " + "changed.(specified to be UTF-8)");
}
}
public String toString() {
return getContent();
}
}