package org.jaudiotagger.tag.mp4.field;
import org.jaudiotagger.audio.generic.Utils;
import org.jaudiotagger.audio.mp4.atom.Mp4BoxHeader;
import org.jaudiotagger.logging.ErrorMessage;
import org.jaudiotagger.tag.TagField;
import org.jaudiotagger.tag.TagTextField;
import org.jaudiotagger.tag.mp4.Mp4FieldKey;
import org.jaudiotagger.tag.mp4.Mp4TagField;
import org.jaudiotagger.tag.mp4.atom.Mp4DataBox;
import org.jaudiotagger.tag.mp4.atom.Mp4MeanBox;
import org.jaudiotagger.tag.mp4.atom.Mp4NameBox;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
/**
* Represents reverse dns field, used for custom information
* <p/>
* <p>Originally only used by Itunes for information that was iTunes specific but now used in a wide range of uses,
* for example Musicbrainz uses it for many of its fields.
* <p/>
* These fields have a more complex setup
* Box ---- shows this is a reverse dns metadata field
* Box mean the issuer in the form of reverse DNS domain (e.g com.apple.iTunes)
* Box name descriptor identifying the type of contents
* Box data contents
* <p/>
* The raw data passed starts from the mean box
*/
public class Mp4TagReverseDnsField extends Mp4TagField implements TagTextField
{
public static final String IDENTIFIER = "----";
protected int dataSize;
//Issuer
private String issuer;
//Descriptor
private String descriptor;
//Data Content,
//TODO assuming always text at the moment
protected String content;
/**
* Construct from existing file data
*
* @param parentHeader
* @param data
* @throws UnsupportedEncodingException
*/
public Mp4TagReverseDnsField(Mp4BoxHeader parentHeader, ByteBuffer data) throws UnsupportedEncodingException
{
super(parentHeader, data);
}
/**
* Newly created Reverse Dns field
*
* @param id
* @param content
*/
public Mp4TagReverseDnsField(Mp4FieldKey id, String content)
{
super(id.getFieldName());
this.issuer = id.getIssuer();
this.descriptor = id.getIdentifier();
this.content = content;
}
/**
* Newly created Reverse Dns field bypassing the Mp4TagField enum for creation of temporary reverse dns fields
* @param fieldName
* @param issuer
* @param identifier
* @param content
*/
public Mp4TagReverseDnsField(final String fieldName, final String issuer, final String identifier, final String content)
{
super(fieldName);
this.issuer = issuer;
this.descriptor = identifier;
this.content = content;
}
public Mp4FieldType getFieldType()
{
//TODO always assuming text at moment but may not always be the case (though dont have any concrete
//examples)
return Mp4FieldType.TEXT;
}
protected void build(ByteBuffer data) throws UnsupportedEncodingException
{
//Read mean box, set the issuer and skip over data
Mp4BoxHeader meanBoxHeader = new Mp4BoxHeader(data);
Mp4MeanBox meanBox = new Mp4MeanBox(meanBoxHeader, data);
setIssuer(meanBox.getIssuer());
data.position(data.position() + meanBoxHeader.getDataLength());
//Read name box, identify what type of field it is
Mp4BoxHeader nameBoxHeader = new Mp4BoxHeader(data);
Mp4NameBox nameBox = new Mp4NameBox(nameBoxHeader, data);
setDescriptor(nameBox.getName());
data.position(data.position() + nameBoxHeader.getDataLength());
//Issue 198:There is not actually a data atom there cannot cant be because no room for one
if (parentHeader.getDataLength() == meanBoxHeader.getLength() + nameBoxHeader.getLength())
{
id = IDENTIFIER + ":" + issuer + ":" + descriptor;
setContent("");
logger.warning(ErrorMessage.MP4_REVERSE_DNS_FIELD_HAS_NO_DATA.getMsg(id));
}
//Usual Case
else
{
//Read data box, identify the data
Mp4BoxHeader dataBoxHeader = new Mp4BoxHeader(data);
Mp4DataBox dataBox = new Mp4DataBox(dataBoxHeader, data);
setContent(dataBox.getContent());
data.position(data.position() + dataBoxHeader.getDataLength());
//Now calculate the id which in order to be unique needs to use all htree values
id = IDENTIFIER + ":" + issuer + ":" + descriptor;
}
}
public void copyContent(TagField field)
{
if (field instanceof Mp4TagReverseDnsField)
{
this.issuer = ((Mp4TagReverseDnsField) field).getIssuer();
this.descriptor = ((Mp4TagReverseDnsField) field).getDescriptor();
this.content = ((Mp4TagReverseDnsField) field).getContent();
}
}
/**
* @return content
*/
public String getContent()
{
return content;
}
protected byte[] getDataBytes() throws UnsupportedEncodingException
{
return content.getBytes(getEncoding());
}
public String getEncoding()
{
return Mp4BoxHeader.CHARSET_UTF_8;
}
/**
* Convert back to raw content, includes ----,mean,name and data atom as views as one thing externally
*
* @return
* @throws UnsupportedEncodingException
*/
public byte[] getRawContent() throws UnsupportedEncodingException
{
try
{
ByteArrayOutputStream baos = new ByteArrayOutputStream();
//Create Meanbox data
byte[] issuerRawData = issuer.getBytes(getEncoding());
baos.write(Utils.getSizeBEInt32(Mp4BoxHeader.HEADER_LENGTH + Mp4MeanBox.PRE_DATA_LENGTH + issuerRawData.length));
baos.write(Utils.getDefaultBytes(Mp4MeanBox.IDENTIFIER, "ISO-8859-1"));
baos.write(new byte[]{0, 0, 0, 0});
baos.write(issuerRawData);
//Create Namebox data
byte[] nameRawData = descriptor.getBytes(getEncoding());
baos.write(Utils.getSizeBEInt32(Mp4BoxHeader.HEADER_LENGTH + Mp4NameBox.PRE_DATA_LENGTH + nameRawData.length));
baos.write(Utils.getDefaultBytes(Mp4NameBox.IDENTIFIER, "ISO-8859-1"));
baos.write(new byte[]{0, 0, 0, 0});
baos.write(nameRawData);
//Create DataBox data if we have data only
if (content.length() > 0)
{
baos.write(getRawContentDataOnly());
}
//Now wrap with reversedns box
ByteArrayOutputStream outerbaos = new ByteArrayOutputStream();
outerbaos.write(Utils.getSizeBEInt32(Mp4BoxHeader.HEADER_LENGTH + baos.size()));
outerbaos.write(Utils.getDefaultBytes(IDENTIFIER, "ISO-8859-1"));
outerbaos.write(baos.toByteArray());
return outerbaos.toByteArray();
}
catch (IOException ioe)
{
//This should never happen as were not actually writing to/from a file
throw new RuntimeException(ioe);
}
}
public byte[] getRawContentDataOnly() throws UnsupportedEncodingException
{
logger.fine("Getting Raw data for:" + getId());
try
{
//Create DataBox data
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] dataRawData = content.getBytes(getEncoding());
baos.write(Utils.getSizeBEInt32(Mp4BoxHeader.HEADER_LENGTH + Mp4DataBox.PRE_DATA_LENGTH + dataRawData.length));
baos.write(Utils.getDefaultBytes(Mp4DataBox.IDENTIFIER, "ISO-8859-1"));
baos.write(new byte[]{0});
baos.write(new byte[]{0, 0, (byte) getFieldType().getFileClassId()});
baos.write(new byte[]{0, 0, 0, 0});
baos.write(dataRawData);
return baos.toByteArray();
}
catch (IOException ioe)
{
//This should never happen as were not actually writing to/from a file
throw new RuntimeException(ioe);
}
}
public boolean isBinary()
{
return false;
}
public boolean isEmpty()
{
return this.content.trim().equals("");
}
public void setContent(String s)
{
this.content = s;
}
public void setEncoding(String s)
{
/* Not allowed */
}
public String toString()
{
return content;
}
/**
* @return the issuer
*/
public String getIssuer()
{
return issuer;
}
/**
* @return the descriptor
*/
public String getDescriptor()
{
return descriptor;
}
/**
* Set the issuer, usually reverse dns of the Companies domain
*
* @param issuer
*/
public void setIssuer(String issuer)
{
this.issuer = issuer;
}
/**
* Set the descriptor for the data (what type of data it is)
*
* @param descriptor
*/
public void setDescriptor(String descriptor)
{
this.descriptor = descriptor;
}
}
|
