true if the content description should be placed into the header object. if false
* it will be placed in the header extension object.
* @param hecd true if the extended content description should be placed into the header object. if false
* it will be placed in the header extension object.
* @throws Exception on I/O Errors.
*/
private void applyTag(File testFile, boolean hcd, boolean hecd) throws Exception
{
// getFields an audio file instance
AudioFile read = AudioFileIO.read(testFile);
// deleteField all managed data
AudioFileIO.delete(read);
// Create chunks
MetadataContainer[] distributeMetadata = TagConverter.distributeMetadata(this.testTag);
// createField creator for the content description object (chunk)
WriteableChunkModifer cdCreator = new WriteableChunkModifer(distributeMetadata[0]);
MetadataContainer ecd = distributeMetadata[2];
// createField creator for the extended content description object (chunk)
WriteableChunkModifer ecdCreator = new WriteableChunkModifer(ecd);
// createField the modifier lists
Listtrue if a content description is expected in the ASF header.
* @param hecd true if an extended content description is expected in the ASF header.
* @param ehcd true if a content description is expected in the ASF header extension.
* @param ehecd true if an extended content description is expected in the ASF header extension.
* @throws Exception on I/O Errors
*/
private void checkExcpectations(File testFile, boolean hcd, boolean hecd, boolean ehcd, boolean ehecd) throws Exception
{
AudioFile read = AudioFileIO.read(testFile);
assertTrue(read.getAudioHeader().isVariableBitRate());
assertEquals("TheArtist", read.getTag().getFirst(FieldKey.ARTIST));
AsfHeader readHeader = AsfHeaderReader.readHeader(testFile);
assertNotNull(readHeader.findContentDescription());
assertNotNull(readHeader.findExtendedContentDescription());
assertEquals(hcd, readHeader.getContentDescription() != null);
assertEquals(hecd, readHeader.getExtendedContentDescription() != null);
assertEquals(ehcd, readHeader.getExtendedHeader() != null && readHeader.getExtendedHeader()
.getContentDescription() != null);
assertEquals(ehecd, readHeader.getExtendedHeader() != null && readHeader.getExtendedHeader()
.getExtendedContentDescription() != null);
}
/**
* Tests the locations of the metadata descriptor object and the extended metadata descriptor object, upon
* some deep ASF manipulations.
*
* @throws Exception On I/O Errors
*/
public void testChunkLocations() throws Exception
{
File testFile = prepareTestFile(null);
AudioFile read = AudioFileIO.read(testFile);
AudioFileIO.delete(read);
read.setTag(testTag);
read.commit();
checkExcpectations(testFile, true, true, false, false);
applyTag(testFile, false, false);
applyTag(testFile, false, true);
applyTag(testFile, true, false);
applyTag(testFile, true, true);
}
}
libjaudiotagger-java-2.0.3/srctest/org/jaudiotagger/tag/wma/WmaTestCase.java 0000644 0001750 0001750 00000006074 11276777123 027014 0 ustar drazzib drazzib package org.jaudiotagger.tag.wma;
import junit.framework.TestCase;
import org.jaudiotagger.AbstractTestCase;
import org.jaudiotagger.audio.AudioFile;
import org.jaudiotagger.audio.AudioFileIO;
import org.jaudiotagger.audio.asf.util.Utils;
import org.jaudiotagger.tag.Tag;
import java.io.File;
/**
* Base class for WMA test cases.sourceFile.
* @param sourceFile The filename of the file to perform tests on. ({@linkplain AbstractTestCase#copyAudioToTmp(String) copy} will be created)
*/
public WmaTestCase(final String sourceFile)
{
this.sourceTestFile = sourceFile;
}
/**
* Creates an instance, that would perform tests on the given sourceFile.
* @param sourceFile The filename of the file to perform tests on. ({@linkplain AbstractTestCase#copyAudioToTmp(String) copy} will be created)
* @param name name of the test.
*/
public WmaTestCase(final String sourceFile, final String name)
{
super(name);
this.sourceTestFile = sourceFile;
}
/**
* Returns the audio file to perform the tests on.true if and only if the renaming succeeded;
* false otherwise
*/
public static boolean copy(File fromFile, File toFile) {
try {
FileInputStream in = new FileInputStream(fromFile);
FileOutputStream out = new FileOutputStream(toFile);
byte[] buf = new byte[8192];
int len;
while ((len = in.read(buf)) > -1) {
out.write(buf, 0, len);
}
in.close();
out.close();
// cleanupif files are not the same length
if (fromFile.length() != toFile.length()) {
toFile.delete();
return false;
}
return true;
} catch (IOException e) {
e.printStackTrace();
return false;
}
}
/**
* Copy audiofile to processing dir ready for use in test
*
* @param fileName
* @return
*/
public static File copyAudioToTmp(String fileName) {
File inputFile = new File("testdata", fileName);
File outputFile = new File("testdatatmp", fileName);
if (!outputFile.getParentFile().exists()) {
outputFile.getParentFile().mkdirs();
}
boolean result = copy(inputFile, outputFile);
assertTrue(result);
return outputFile;
}
/**
* Copy audiofile to processing dir ready for use in test, use this if using
* same file in multiple tests because with junit multithreading can have
* problemsa otherwise
*
* @param fileName
* @return
*/
public static File copyAudioToTmp(String fileName, File newFileName) {
File inputFile = new File("testdata", fileName);
File outputFile = new File("testdatatmp", newFileName.getName());
if (!outputFile.getParentFile().exists()) {
outputFile.getParentFile().mkdirs();
}
boolean result = copy(inputFile, outputFile);
assertTrue(result);
return outputFile;
}
/**
* Prepends file with tag file in order to create an mp3 with a valid id3
*
* @param tagfile
* @param fileName
* @return
*/
public static File copyAudioToTmp(String tagfile, String fileName) {
File inputTagFile = new File("testtagdata", tagfile);
File inputFile = new File("testdata", fileName);
File outputFile = new File("testdatatmp", fileName);
if (!outputFile.getParentFile().exists()) {
outputFile.getParentFile().mkdirs();
}
boolean result = append(inputTagFile, inputFile, outputFile);
assertTrue(result);
return outputFile;
}
/**
* This method asserts that the given actual message is
* constructed with the expected message string.null.
*
* @author Christian Laireiter
*/
public class AsfCodeCheckTest extends TestCase
{
/**
* Tests the correct implementation of {@link AsfTag}.true if data is equal.
*/
public static boolean equals(final MetadataContainer c1,
MetadataContainer c2) {
if (c1 == c2) {
throw new IllegalArgumentException("Made a mistake?");
}
boolean result = c1.getGuid().equals(c2.getGuid());
result &= c1.getContainerType() == c2.getContainerType();
result &= c1.getDescriptorCount() == c2.getDescriptorCount();
result &= equals(c1.getDescriptors(), c2.getDescriptors());
return result;
}
}
libjaudiotagger-java-2.0.3/srctest/org/jaudiotagger/audio/asf/data/MetadataDescriptorTest.java 0000644 0001750 0001750 00000053245 11222471043 032460 0 ustar drazzib drazzib package org.jaudiotagger.audio.asf.data;
import junit.framework.TestCase;
import org.jaudiotagger.tag.TagOptionSingleton;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Random;
/**
* Tests the most important data structure for the basic ASF implementations
* metadata.
*
* @author Christian Laireiter
*/
public class MetadataDescriptorTest extends TestCase {
/**
* A test descriptor instance.
*/
private final MetadataDescriptor descriptor1 = new MetadataDescriptor(
"testDescriptor");
/**
* Helper method for creating string with charAmount of 'a's.charAmount of 'a's.charAmount of 'a's.true if they represent the same.
* @throws IllegalArgumentException
* if they are the same object (m1 == m2).
*/
public static boolean equals(final MetadataDescriptor m1,
final MetadataDescriptor m2) {
if (m1 == m2) {
throw new IllegalArgumentException("Made a mistake ?");
}
boolean result = m1.getType() == m2.getType();
result &= m1.getContainerType() == m2.getContainerType();
result &= Arrays.equals(m1.getRawData(), m2.getRawData());
return result;
}
}
libjaudiotagger-java-2.0.3/srctest/org/jaudiotagger/audio/asf/data/AbstractMetadataContainer.java 0000644 0001750 0001750 00000010272 11222471043 033101 0 ustar drazzib drazzib package org.jaudiotagger.audio.asf.data;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* This class tests the correct implementation of {@link MetadataContainer}
* implementations.Shoudl not happen with well written code, hence RuntimeException. */ public class KeyNotFoundException extends RuntimeException { /** * Creates a new KeyNotFoundException datatype. */ public KeyNotFoundException() { } /** * Creates a new KeyNotFoundException datatype. * * @param ex the cause. */ public KeyNotFoundException(Throwable ex) { super(ex); } /** * Creates a new KeyNotFoundException datatype. * * @param msg the detail message. */ public KeyNotFoundException(String msg) { super(msg); } /** * Creates a new KeyNotFoundException datatype. * * @param msg the detail message. * @param ex the cause. */ public KeyNotFoundException(String msg, Throwable ex) { super(msg, ex); } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/FieldDataInvalidException.java 0000644 0001750 0001750 00000002041 10736454526 030140 0 ustar drazzib drazzib package org.jaudiotagger.tag; /** * Thrown if the try and create a field with invalid data *
*For example if try and create an Mp4Field with type Byte using data that cannot be parsed as a number * then this exception will be thrown */ public class FieldDataInvalidException extends TagException { /** * Creates a new KeyNotFoundException datatype. */ public FieldDataInvalidException() { } /** * Creates a new KeyNotFoundException datatype. * * @param ex the cause. */ public FieldDataInvalidException(Throwable ex) { super(ex); } /** * Creates a new KeyNotFoundException datatype. * * @param msg the detail message. */ public FieldDataInvalidException(String msg) { super(msg); } /** * Creates a new KeyNotFoundException datatype. * * @param msg the detail message. * @param ex the cause. */ public FieldDataInvalidException(String msg, Throwable ex) { super(msg, ex); } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/datatype/ 0000755 0001750 0001750 00000000000 11556363176 024111 5 ustar drazzib drazzib libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/datatype/BooleanByte.java 0000644 0001750 0001750 00000007023 11470746136 027155 0 ustar drazzib drazzib /** * @author : Paul Taylor * @author : Eric Farng * * Version @version:$Id: BooleanByte.java 929 2010-11-17 12:36:46Z paultaylor $ * * 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 * * Description: * */ package org.jaudiotagger.tag.datatype; import org.jaudiotagger.tag.InvalidDataTypeException; import org.jaudiotagger.tag.id3.AbstractTagFrameBody; /** * Represents a bit flag within a byte */ public class BooleanByte extends AbstractDataType { /** * */ int bitPosition = -1; /** * Creates a new ObjectBooleanByte datatype. * * @param identifier * @param frameBody * @param bitPosition * @throws IndexOutOfBoundsException */ public BooleanByte(String identifier, AbstractTagFrameBody frameBody, int bitPosition) { super(identifier, frameBody); if ((bitPosition < 0) || (bitPosition > 7)) { throw new IndexOutOfBoundsException("Bit position needs to be from 0 - 7 : " + bitPosition); } this.bitPosition = bitPosition; } public BooleanByte(BooleanByte copy) { super(copy); this.bitPosition = copy.bitPosition; } /** * @return */ public int getBitPosition() { return bitPosition; } /** * @return */ public int getSize() { return 1; } /** * @param obj * @return */ public boolean equals(Object obj) { if (!(obj instanceof BooleanByte)) { return false; } BooleanByte object = (BooleanByte) obj; return this.bitPosition == object.bitPosition && super.equals(obj); } /** * @param arr * @param offset * @throws NullPointerException * @throws IndexOutOfBoundsException */ public void readByteArray(byte[] arr, int offset) throws InvalidDataTypeException { if (arr == null) { throw new NullPointerException("Byte array is null"); } if ((offset < 0) || (offset >= arr.length)) { throw new IndexOutOfBoundsException("Offset to byte array is out of bounds: offset = " + offset + ", array.length = " + arr.length); } byte newValue = arr[offset]; newValue >>= bitPosition; newValue &= 0x1; this.value = newValue == 1; } /** * @return */ public String toString() { return "" + value; } /** * @return */ public byte[] writeByteArray() { byte[] retValue; retValue = new byte[1]; if (value != null) { retValue[0] = (byte) ((Boolean) value ? 1 : 0); retValue[0] <<= bitPosition; } return retValue; } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/datatype/TextEncodedStringSizeTerminated.java 0000644 0001750 0001750 00000030424 11470746136 033220 0 ustar drazzib drazzib package org.jaudiotagger.tag.datatype; import org.jaudiotagger.logging.Hex; import org.jaudiotagger.tag.InvalidDataTypeException; import org.jaudiotagger.tag.TagOptionSingleton; import org.jaudiotagger.tag.id3.AbstractTagFrameBody; import org.jaudiotagger.tag.id3.valuepair.TextEncoding; import java.nio.Buffer; import java.nio.ByteBuffer; import java.nio.CharBuffer; import java.nio.charset.*; import java.util.ArrayList; import java.util.Arrays; import java.util.List; /** * Represents a String which is not delimited by null character. *
* This type of String will usually only be used when it is the last field within a frame, when reading the remainder of * the byte array will be read, when writing the frame will be accommodate the required size for the String. The String * will be encoded based upon the text encoding of the frame that it belongs to. * * All TextInformation frames support multiple strings, stored as a null separated list, where null is represented by * the termination code for the character encoding. This functionality is only officially support in ID3v24. * * Most applications will ignore any but the first value, but some such as Foobar 2000 will decode them properly * * iTunes write null terminators characters after the String even though it only writes a single value. * * */ public class TextEncodedStringSizeTerminated extends AbstractString { /** * Creates a new empty TextEncodedStringSizeTerminated datatype. * * @param identifier identifies the frame type * @param frameBody */ public TextEncodedStringSizeTerminated(String identifier, AbstractTagFrameBody frameBody) { super(identifier, frameBody); } /** * Copy constructor * * @param object */ public TextEncodedStringSizeTerminated(TextEncodedStringSizeTerminated object) { super(object); } public boolean equals(Object obj) { if(this==obj) { return true; } return obj instanceof TextEncodedStringSizeTerminated && super.equals(obj); } /** * Read a 'n' bytes from buffer into a String where n is the framesize - offset * so thefore cannot use this if there are other objects after it because it has no * delimiter. * * Must take into account the text encoding defined in the Encoding Object * ID3 Text Frames often allow multiple strings seperated by the null char * appropriate for the encoding. * * @param arr this is the buffer for the frame * @param offset this is where to start reading in the buffer for this field * @throws NullPointerException * @throws IndexOutOfBoundsException */ public void readByteArray(byte[] arr, int offset) throws InvalidDataTypeException { logger.finest("Reading from array from offset:" + offset); //Get the Specified Decoder String charSetName = getTextEncodingCharSet(); CharsetDecoder decoder = Charset.forName(charSetName).newDecoder(); decoder.reset(); //Decode sliced inBuffer ByteBuffer inBuffer; if(TagOptionSingleton.getInstance().isAndroid()) { //#302 [dallen] truncating array manually since the decoder.decode() does not honor the offset in the in buffer byte[] truncArr = new byte[arr.length - offset]; System.arraycopy(arr, offset, truncArr, 0, truncArr.length); inBuffer = ByteBuffer.wrap(truncArr); } else { inBuffer = ByteBuffer.wrap(arr, offset, arr.length - offset).slice(); } CharBuffer outBuffer = CharBuffer.allocate(arr.length - offset); CoderResult coderResult = decoder.decode(inBuffer, outBuffer, true); if (coderResult.isError()) { logger.warning("Decoding error:" + coderResult.toString()); } decoder.flush(outBuffer); outBuffer.flip(); //If using UTF16 with BOM we then search through the text removing any BOMs that could exist //for multiple values, BOM could be Big Endian or Little Endian if (charSetName.equals(TextEncoding.CHARSET_UTF_16)) { value = outBuffer.toString().replace("\ufeff","").replace("\ufffe",""); } else { value = outBuffer.toString(); } //SetSize, important this is correct for finding the next datatype setSize(arr.length - offset); logger.info("Read SizeTerminatedString:" + value + " size:" + size); } /** * Write String using specified encoding * * When this is called multiple times, all but the last value has a trailing null * * @param encoder * @param next * @param i * @param noOfValues * @return * @throws CharacterCodingException */ private ByteBuffer writeString( CharsetEncoder encoder, String next, int i, int noOfValues) throws CharacterCodingException { ByteBuffer bb; if(( i + 1) == noOfValues ) { bb = encoder.encode(CharBuffer.wrap(next)); } else { bb = encoder.encode(CharBuffer.wrap(next + '\0')); } bb.rewind(); return bb; } /** * Write String in UTF-LEBOM format * * When this is called multiple times, all but the last value has a trailing null * * Remember we are using this charset because the charset that writes BOM does it the wrong way for us * so we use this none and then manually add the BOM ourselves. * * @param next * @param i * @param noOfValues * @return * @throws CharacterCodingException */ private ByteBuffer writeStringUTF16LEBOM( String next, int i, int noOfValues) throws CharacterCodingException { CharsetEncoder encoder = Charset.forName(TextEncoding.CHARSET_UTF_16_ENCODING_FORMAT).newEncoder(); ByteBuffer bb = null; //Note remember LE BOM is ff fe but this is handled by encoder Unicode char is fe ff if(( i + 1)==noOfValues) { bb = encoder.encode(CharBuffer.wrap('\ufeff' + next )); } else { bb = encoder.encode(CharBuffer.wrap('\ufeff' + next + '\0')); } bb.rewind(); return bb; } /** * Removing trailing null from end of String, this should be there but some applications continue to write * this unnecessary null char. */ private void stripTrailingNull() { if (TagOptionSingleton.getInstance().isRemoveTrailingTerminatorOnWrite()) { String stringValue = (String) value; if (stringValue.length() > 0) { if (stringValue.charAt(stringValue.length() - 1) == '\0') { stringValue = (stringValue).substring(0, stringValue.length() - 1); value = stringValue; } } } } /** * Because nulls are stripped we need to check if not removing trailing nulls whether the original * value ended with a null and if so add it back in. * @param values * @param stringValue */ private void checkTrailingNull( ListAbstractAsfTagImageField is an abstract class for representing tag
* fields containing image data.true, Creates a copy of
* source, if its not empty-null if the field is empty (empty byte[] or blank
* string}.
*/
private TagField copyFrom(final TagField source)
{
TagField result;
if (isCopyingFields())
{
if (source instanceof AsfTagField)
{
try
{
result = (TagField) ((AsfTagField) source).clone();
}
catch (CloneNotSupportedException e)
{
result = new AsfTagField(((AsfTagField) source).getDescriptor());
}
}
else if (source instanceof TagTextField)
{
final String content = ((TagTextField) source).getContent();
result = new AsfTagTextField(source.getId(), content);
}
else
{
throw new RuntimeException("Unknown Asf Tag Field class:" // NOPMD
// by
// Christian
// Laireiter
// on
// 5/9/09
// 5:44
// PM
+ source.getClass());
}
}
else
{
result = source;
}
return result;
}
/**
* Creates an {@link AsfTagCoverField} from given artwork
*
* @param artwork artwork to create a ASF field from.
* @return ASF field capable of storing artwork.
*/
public AsfTagCoverField createField(final Artwork artwork)
{
return new AsfTagCoverField(artwork.getBinaryData(), artwork.getPictureType(), artwork.getDescription(), artwork.getMimeType());
}
/**
* Create artwork field
*
* @param data raw image data
* @return creates a default ASF picture field with default
* {@linkplain PictureTypes#DEFAULT_ID picture type}.
*/
public AsfTagCoverField createArtworkField(final byte[] data)
{
return new AsfTagCoverField(data, PictureTypes.DEFAULT_ID, null, null);
}
/**
* Creates a field for storing the copyright.true, the {@link #copyFrom(TagField)} method creates a
* new {@link AsfTagField} instance and copies the content from the source.true it is ensured that the {@link AsfTag} instance
* has its own copies of fields, which cannot be modified after assignment
* (which could pass some checks), and it just stores {@link AsfTagField}
* objects.true if field may be added.
*/
// TODO introduce this concept to all formats
private boolean isValidField(final TagField field)
{
if (field == null)
{
return false;
}
if (!(field instanceof AsfTagField))
{
return false;
}
return !field.isEmpty();
}
/**
* {@inheritDoc}
*/
@Override
// TODO introduce copy idea to all formats
public void setField(final TagField field)
{
if (isValidField(field))
{
// Copy only occurs if flag setField
super.setField(copyFrom(field));
}
}
/**
* Sets the copyright.true if ASF implementation supports multiple values for the field.
*/
public static boolean isMultiValued(final String fieldName)
{
final AsfFieldKey fieldKey = getAsfFieldKey(fieldName);
return fieldKey != null && fieldKey.isMultiValued();
}
/**
* If set, the field has a standard id assigned.
*/
private final String fieldName;
/**
* If true, the field will be stored repeatedly if occurs so in tags.
*/
private final boolean multiValued;
/**
* The lowest possible container type, such a field can be stored into.true if the this ASF field can have multiple
* values.
*/
private AsfFieldKey(final String asfFieldName, final boolean multiValue) {
this(asfFieldName, multiValue, ContainerType.EXTENDED_CONTENT,
ContainerType.METADATA_LIBRARY_OBJECT);
}
/**
* Creates an instance.true if the this ASF field can have multiple
* values.
* @param restrictedTo
* fields must be stored in this container.
*/
private AsfFieldKey(final String asfFieldName, final boolean multiValue,
final ContainerType restrictedTo) {
this(asfFieldName, multiValue, restrictedTo, restrictedTo);
}
/**
* Creates an instance.true if the this ASF field can have multiple
* values.
* @param lowest
* fields must be stored at least in this container.
* @param highest
* fields aren't allowed to be stored in better containers than
* this.
*/
private AsfFieldKey(final String asfFieldName, final boolean multiValue,
final ContainerType lowest, final ContainerType highest) {
this.fieldName = asfFieldName;
assert !multiValue || highest.isMultiValued() : "Definition error";
this.multiValued = multiValue && highest.isMultiValued();
this.lowestContainer = lowest;
this.highestContainer = highest;
assert ContainerType.areInCorrectOrder(lowest, highest);
}
/**
* Returns the standard field id.
*
* @return the standard field id. (may be null)
*/
public String getFieldName()
{
return this.fieldName;
}
/**
* @return the highestContainer
*/
public ContainerType getHighestContainer() {
return this.highestContainer;
}
/**
* @return the lowestContainer
*/
public ContainerType getLowestContainer() {
return this.lowestContainer;
}
/**
* Returns true if this field can store multiple values.
*
* @return true if multiple values are supported for this field.
*/
public boolean isMultiValued()
{
return this.multiValued;
}
/**
* {@inheritDoc}
*/
@Override
public String toString()
{
return getFieldName();
}
}
libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/asf/AsfTagBannerField.java 0000644 0001750 0001750 00000003367 11277264361 027156 0 ustar drazzib drazzib package org.jaudiotagger.tag.asf;
import org.jaudiotagger.audio.asf.data.ContentBranding;
import org.jaudiotagger.audio.asf.data.ContainerType;
import org.jaudiotagger.audio.asf.data.MetadataDescriptor;
import org.jaudiotagger.tag.asf.AbstractAsfTagImageField;
import org.jaudiotagger.tag.asf.AsfFieldKey;
/**
* This field represents the image content of the banner image which is stored
* in the {@linkplain ContentBranding content branding} chunk of ASF files.Syncsafe integers are used for the size in the tag header of v23 and v24 tags, and in the frame size in * the frame header of v24 frames. *
*In some parts of the tag it is inconvenient to use the * unsychronisation scheme because the size of unsynchronised data is * not known in advance, which is particularly problematic with size * descriptors. The solution in ID3v2 is to use synchsafe integers, in * which there can never be any false synchs. Synchsafe integers are * integers that keep its highest bit (bit 7) zeroed, making seven bits * out of eight available. Thus a 32 bit synchsafe integer can store 28 * bits of information. *
* Example: * * 255 (%11111111) encoded as a 16 bit synchsafe integer is 383 * (%00000001 01111111). */ public class ID3SyncSafeInteger { public static final int INTEGRAL_SIZE = 4; /** * Sizes equal or smaller than this are the same whether held as sync safe integer or normal integer so * it doesnt matter. */ public static final int MAX_SAFE_SIZE = 127; /** * Read syncsafe value from byteArray in format specified in spec and convert to int. * * @param buffer syncsafe integer * @return decoded int */ private static int bufferToValue(byte[] buffer) { //Note Need to && with 0xff otherwise if value is greater than 128 we get a negative number //when cast byte to int return ((buffer[0] & 0xff) << 21) + ((buffer[1] & 0xff) << 14) + ((buffer[2] & 0xff) << 7) + ((buffer[3]) & 0xff); } /** * Read syncsafe value from buffer in format specified in spec and convert to int. * * The buffers position is moved to just after the location of the syncsafe integer * * @param buffer syncsafe integer * @return decoded int */ protected static int bufferToValue(ByteBuffer buffer) { byte byteBuffer[] = new byte[INTEGRAL_SIZE]; buffer.get(byteBuffer, 0, INTEGRAL_SIZE); return bufferToValue(byteBuffer); } /** * Is buffer holding a value that is definently not syncsafe * * We cannot guarantee a buffer is holding a syncsafe integer but there are some checks * we can do to show that it definently is not. * * The buffer is NOT moved after reading. * * This function is useful for reading ID3v24 frames created in iTunes because iTunes does not use syncsafe * integers in its frames. * * @param buffer * @return true if this buffer is definently not holding a syncsafe integer */ protected static boolean isBufferNotSyncSafe(ByteBuffer buffer) { int position = buffer.position(); //Check Bit7 not set for (int i = 0; i < INTEGRAL_SIZE; i++) { byte nextByte = buffer.get(position + i); if ((nextByte & 0x80) > 0) { return true; } } return false; } /** * Checks if the buffer just contains zeros * * This can be used to identify when accessing padding of a tag * * @param buffer * @return true if buffer only contains zeros */ protected static boolean isBufferEmpty(byte[] buffer) { for (byte aBuffer : buffer) { if (aBuffer != 0) { return false; } } return true; } /** * Convert int value to syncsafe value held in bytearray * * @param size * @return buffer syncsafe integer */ protected static byte[] valueToBuffer(int size) { byte[] buffer = new byte[4]; buffer[0] = (byte) ((size & 0x0FE00000) >> 21); buffer[1] = (byte) ((size & 0x001FC000) >> 14); buffer[2] = (byte) ((size & 0x00003F80) >> 7); buffer[3] = (byte) (size & 0x0000007F); return buffer; } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/framebody/ 0000755 0001750 0001750 00000000000 11556363174 024723 5 ustar drazzib drazzib libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/framebody/FrameBodyTOPE.java 0000644 0001750 0001750 00000005136 11470746136 030131 0 ustar drazzib drazzib /* * 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.framebody; import org.jaudiotagger.tag.InvalidTagException; import org.jaudiotagger.tag.id3.ID3v24Frames; import java.nio.ByteBuffer; /** * Original artist(s)/performer(s) Text information frame. *The 'Original artist(s)/performer(s)' frame is intended for the performer(s) of the original recording, if for * example the music in the file should be a cover of a previously released song. The performers are separated with * the "/" character. *
*For more details, please refer to the ID3 specifications: *
The 'Internet radio station owner' frame contains the name of the owner of the internet radio station from which the audio is streamed. *
*For more details, please refer to the ID3 specifications: *
The 'Track number/Position in set' frame is a numeric string containing the order number of the audio-file on its original recording. * * This may be extended with a "/" character and a numeric string containing the total number of tracks/elements on the original recording. * e.g. "4/9". * * Some applications like to prepend the track number with a zero to aid sorting, (i.e 02 comes before 10) * *
*For more details, please refer to the ID3 specifications: *
* The tempo descriptor is followed by a time stamp. Every time the * tempo in the music changes, a tempo descriptor may indicate this for * the player. All tempo descriptors should be sorted in chronological * order. The first beat-stroke in a time-period is at the same time as * the beat description occurs. There may only be one "SYTC" frame in * each tag. *
| <Header for 'Synchronised tempo codes', ID: "SYTC"> | |
| Time stamp format | $xx |
| Tempo data | <binary data> |
* Where time stamp format is: *
* $01 Absolute time, 32 bit sized, using MPEG frames as unit
* $02 Absolute time, 32 bit sized, using milliseconds as unit
*
* Abolute time means that every stamp contains the time from the * beginning of the file. *
* *For more details, please refer to the ID3 specifications: *
The 'Media type' frame describes from which media the sound * originated. This may be a text string or a reference to the * predefined media types found in the list below. References are made * within "(" and ")" and are optionally followed by a text refinement, * e.g. "(MC) with four channels". If a text refinement should begin * with a "(" character it should be replaced with "((" in the same way * as in the "TCO" frame. Predefined refinements is appended after the * media type, e.g. "(CD/A)" or "(VID/PAL/VHS)". *
| DIG | Other digital media | |
| /A | Analog transfer from media | |
| ANA | Other analog media | |
| /WAC | Wax cylinder | |
| /8CA | 8-track tape cassette | |
| CD | CD | |
| /A | Analog transfer from media | |
| /DD | DDD | |
| /AD | ADD | |
| /AA | AAD | |
| LD | Laserdisc | |
| /A | Analog transfer from media | |
| TT | Turntable records | |
| /33 | 33.33 rpm | |
| /45 | 45 rpm | |
| /71 | 71.29 rpm | |
| /76 | 76.59 rpm | |
| /78 | 78.26 rpm | |
| /80 | 80 rpm | |
| MD | MiniDisc | |
| /A | Analog transfer from media | |
| DAT | DAT | |
| /A | Analog transfer from media | |
| /1 | standard, 48 kHz/16 bits, linear | |
| /2 | mode 2, 32 kHz/16 bits, linear | |
| /3 | mode 3, 32 kHz/12 bits, nonlinear, low speed | |
| /4 | mode 4, 32 kHz/12 bits, 4 channels | |
| /5 | mode 5, 44.1 kHz/16 bits, linear | |
| /6 | mode 6, 44.1 kHz/16 bits, 'wide track' play | |
| DCC | DCC | |
| /A | Analog transfer from media | |
| DVD | DVD | |
| /A | Analog transfer from media | |
| TV | Television | |
| /PAL | PAL | |
| /NTSC | NTSC | |
| /SECAM | SECAM | |
| VID | Video | |
| /PAL | PAL | |
| /NTSC | NTSC | |
| /SECAM | SECAM | |
| /VHS | VHS | |
| /SVHS | S-VHS | |
| /BETA | BETAMAX | |
| RAD | Radio | |
| /FM | FM | |
| /AM | AM | |
| /LW | LW | |
| /MW | MW | |
| TEL | Telephone | |
| /I | ISDN | |
| MC | MC (normal cassette) | |
| /4 | 4.75 cm/s (normal speed for a two sided cassette) | |
| /9 | 9.5 cm/s | |
| /I | Type I cassette (ferric/normal) | |
| /II | Type II cassette (chrome) | |
| /III | Type III cassette (ferric chrome) | |
| /IV | Type IV cassette (metal) | |
| REE | Reel | |
| /9 | 9.5 cm/s | |
| /19 | 19 cm/s | |
| /38 | 38 cm/s | |
| /76 | 76 cm/s | |
| /I | Type I cassette (ferric/normal) | |
| /II | Type II cassette (chrome) | |
| /III | Type III cassette (ferric chrome) | |
| /IV | Type IV cassette (metal) |
For more details, please refer to the ID3 specifications: *
The 'Conductor' frame is used for the name of the conductor. *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Synchronised lyrics/text', ID: "SYLT"> | |
| Text encoding | $xx |
| Language | $xx xx xx |
| Time stamp format | $xx |
| Content type | $xx |
| Content descriptor | <text string according to encoding> $00 (00) |
| Encoding: | $00 | ISO-8859-1 character set is used => $00 is sync identifier. |
| $01 | Unicode character set is used => $00 00 is sync identifier. |
| Content type: | $00 | is other |
| $01 | is lyrics | |
| $02 | is text transcription | |
| $03 | is movement/part name (e.g. "Adagio") | |
| $04 | is events (e.g. "Don Quijote enters the stage") | |
| $05 | is chord (e.g. "Bb F Fsus") | |
| $06 | is trivia/'pop up' information |
* $01 Absolute time, 32 bit sized, using MPEG frames as unit
* $02 Absolute time, 32 bit sized, using milliseconds as unit
*
* Abolute time means that every stamp contains the time from the * beginning of the file. *
* The text that follows the frame header differs from that of the * unsynchronised lyrics/text transcription in one major way. Each * syllable (or whatever size of text is considered to be convenient by * the encoder) is a null terminated string followed by a time stamp * denoting where in the sound file it belongs. Each sync thus has the * following structure: *
| Terminated text to be synced (typically a syllable) | |
| Sync identifier (terminator to above string) | $00 (00) |
| Time stamp | $xx (xx ...) |
* Newline ($0A) characters are allowed in all "SYLT" frames and should * be used after every entry (name, event etc.) in a frame with the * content type $03 - $04. *
* A few considerations regarding whitespace characters: Whitespace * separating words should mark the beginning of a new word, thus * occurring in front of the first syllable of a new word. This is also * valid for new line characters. A syllable followed by a comma should * not be broken apart with a sync (both the syllable and the comma * should be before the sync). *
* An example: The "USLT" passage *
* "Strangers in the night" $0A "Exchanging glances" *
would be "SYLT" encoded as: *
* "Strang" $00 xx xx "ers" $00 xx xx " in" $00 xx xx " the" $00 xx xx * " night" $00 xx xx 0A "Ex" $00 xx xx "chang" $00 xx xx "ing" $00 xx * xx "glan" $00 xx xx "ces" $00 xx xx *
There may be more than one "SYLT" frame in each tag, but only one * with the same language and content descriptor.
* *For more details, please refer to the ID3 specifications: *
| <Header for 'Play counter', ID: "PCNT"> | |
| Counter | $xx xx xx xx (xx ...) |
For more details, please refer to the ID3 specifications: *
The 'Copyright/Legal information' frame is a URL pointing at a webpage where the terms of use and ownership of the file is described. *
*For more details, please refer to the ID3 specifications: *
For more details, please refer to the ID3 specifications: *
The 'Official audio source webpage' frame is a URL pointing at the official webpage for the source of the audio * file, e.g. a movie. *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Linked information', ID: "LINK"> | |
| Frame identifier | $xx xx xx |
| URL | <text string> $00 |
| ID and additional data | <text string(s)> |
* The "TXXX", "APIC", "GEOB" and "AENC" frames may be linked with * the content descriptor as additional ID data. *
* The "COMM", "SYLT" and "USLT" frames may be linked with three bytes * of language descriptor directly followed by a content descriptor as * additional ID data. *
* *For more details, please refer to the ID3 specifications: *
The super.super Constructor sets up the Object list for the frame. * * @param byteBuffer * @param frameSize * @throws InvalidTagException if unable to create framebody from buffer */ protected AbstractFrameBodyTextInfo(ByteBuffer byteBuffer, int frameSize) throws InvalidTagException { super(byteBuffer, frameSize); } /** * Set the Full Text String. *
*If this String contains null terminator characters these are parsed as value * separators, allowing you to hold multiple strings within one text frame. This functionality is only * officially support in ID3v24. * * @param text to set */ public void setText(String text) { if (text == null) { throw new IllegalArgumentException(ErrorMessage.GENERAL_INVALID_NULL_ARGUMENT.getMsg()); } setObjectValue(DataTypes.OBJ_TEXT, text); } public String getUserFriendlyValue() { return getTextWithoutTrailingNulls(); } /** * Retrieve the complete text String as it is held internally. * * If multiple values are held these wil be returned, needless trailing nulls will also be returned * * @return the text string */ public String getText() { return (String) getObjectValue(DataTypes.OBJ_TEXT); } /** * Retrieve the complete text String but without any trailing nulls * * If multiple values are held these will be returned, needless trailing nulls will not be returned * * @return the text string */ public String getTextWithoutTrailingNulls() { TextEncodedStringSizeTerminated text = (TextEncodedStringSizeTerminated) getObject(DataTypes.OBJ_TEXT); return text.getValueWithoutTrailingNull(); } /** * Get first value * * @return value at index 0 */ public String getFirstTextValue() { TextEncodedStringSizeTerminated text = (TextEncodedStringSizeTerminated) getObject(DataTypes.OBJ_TEXT); return text.getValueAtIndex(0); } /** * Get text value at index * * When a multiple values are stored within a single text frame this method allows access to any of the * individual values. * * @param index * @return value at index */ public String getValueAtIndex(int index) { TextEncodedStringSizeTerminated text = (TextEncodedStringSizeTerminated) getObject(DataTypes.OBJ_TEXT); return text.getValueAtIndex(index); } /** * Add additional value to value * * @param value at index */ public void addTextValue(String value) { TextEncodedStringSizeTerminated text = (TextEncodedStringSizeTerminated) getObject(DataTypes.OBJ_TEXT); text.addValue(value); } /** * @return number of text values, usually one */ public int getNumberOfValues() { TextEncodedStringSizeTerminated text = (TextEncodedStringSizeTerminated) getObject(DataTypes.OBJ_TEXT); return text.getNumberOfValues(); } /** * Because Text frames have a text encoding we need to check the text * String does not contain characters that cannot be encoded in * current encoding before we write data. If there are change the text * encoding. */ public void write(ByteArrayOutputStream tagBuffer) { //Ensure valid for type setTextEncoding(ID3TextEncodingConversion.getTextEncoding(getHeader(), getTextEncoding())); //Ensure valid for data if (!((TextEncodedStringSizeTerminated) getObject(DataTypes.OBJ_TEXT)).canBeEncoded()) { this.setTextEncoding(ID3TextEncodingConversion.getUnicodeTextEncoding(getHeader())); } super.write(tagBuffer); } /** * Setup the Object List. All text frames contain a text encoding * and then a text string. *
* TODO:would like to make final but cannot because overridden by FrameBodyTXXX */ protected void setupObjectList() { objectList.add(new NumberHashMap(DataTypes.OBJ_TEXT_ENCODING, this, TextEncoding.TEXT_ENCODING_FIELD_SIZE)); objectList.add(new TextEncodedStringSizeTerminated(DataTypes.OBJ_TEXT, this)); } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/framebody/FrameBodyRBUF.java 0000644 0001750 0001750 00000006607 11277006322 030113 0 ustar drazzib drazzib /** * @author : Paul Taylor * @author : Eric Farng * * Version @version:$Id: FrameBodyRBUF.java 832 2009-11-12 13:25:38Z paultaylor $ * * 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 * * Description: * */ package org.jaudiotagger.tag.id3.framebody; import org.jaudiotagger.tag.InvalidTagException; import org.jaudiotagger.tag.datatype.BooleanByte; import org.jaudiotagger.tag.datatype.DataTypes; import org.jaudiotagger.tag.datatype.NumberFixedLength; import org.jaudiotagger.tag.id3.ID3v24Frames; import java.nio.ByteBuffer; /** * Body of Recommended buffer size frame, generally used for streaming audio */ public class FrameBodyRBUF extends AbstractID3v2FrameBody implements ID3v24FrameBody, ID3v23FrameBody { private static int BUFFER_FIELD_SIZE = 3; private static int EMBED_FLAG_BIT_POSITION = 1; private static int OFFSET_FIELD_SIZE = 4; /** * Creates a new FrameBodyRBUF datatype. */ public FrameBodyRBUF() { this.setObjectValue(DataTypes.OBJ_BUFFER_SIZE, (byte) 0); this.setObjectValue(DataTypes.OBJ_EMBED_FLAG, Boolean.FALSE); this.setObjectValue(DataTypes.OBJ_OFFSET, (byte) 0); } public FrameBodyRBUF(FrameBodyRBUF body) { super(body); } /** * Creates a new FrameBodyRBUF datatype. * * @param bufferSize * @param embeddedInfoFlag * @param offsetToNextTag */ public FrameBodyRBUF(byte bufferSize, boolean embeddedInfoFlag, byte offsetToNextTag) { this.setObjectValue(DataTypes.OBJ_BUFFER_SIZE, bufferSize); this.setObjectValue(DataTypes.OBJ_EMBED_FLAG, embeddedInfoFlag); this.setObjectValue(DataTypes.OBJ_OFFSET, offsetToNextTag); } /** * Creates a new FrameBodyRBUF datatype. * * @param byteBuffer * @param frameSize * @throws InvalidTagException if unable to create framebody from buffer */ public FrameBodyRBUF(ByteBuffer byteBuffer, int frameSize) throws InvalidTagException { super(byteBuffer, frameSize); } /** * The ID3v2 frame identifier * * @return the ID3v2 frame identifier for this frame type */ public String getIdentifier() { return ID3v24Frames.FRAME_ID_RECOMMENDED_BUFFER_SIZE; } /** * */ protected void setupObjectList() { objectList.add(new NumberFixedLength(DataTypes.OBJ_BUFFER_SIZE, this, BUFFER_FIELD_SIZE)); objectList.add(new BooleanByte(DataTypes.OBJ_EMBED_FLAG, this, (byte) EMBED_FLAG_BIT_POSITION)); objectList.add(new NumberFixedLength(DataTypes.OBJ_OFFSET, this, OFFSET_FIELD_SIZE)); } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/framebody/FrameBodyTDLY.java 0000644 0001750 0001750 00000005176 11277006322 030131 0 ustar drazzib drazzib /* * 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.framebody; import org.jaudiotagger.tag.InvalidTagException; import org.jaudiotagger.tag.id3.ID3v24Frames; import java.nio.ByteBuffer; /** * Playlist delay Text information frame. *The 'Playlist delay' defines the numbers of milliseconds of silence between every song in a playlist. The player should use the "ETC" frame, if present, to skip initial silence and silence at the end of the audio to match the 'Playlist delay' time. The time is represented as a numeric string. *
*For more details, please refer to the ID3 specifications: *
The 'Encoded by' frame contains the name of the person or organisation that encoded the audio file. * This field may contain a copyright message, if the audio file also is copyrighted by the encoder. *
*For more details, please refer to the ID3 specifications: *
The 'Original filename' frame contains the preferred filename for the file, since some media doesn't allow the desired length of the filename. The filename is case sensitive and includes its suffix. *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Encryption method registration', ID: "ENCR"> | |
| Owner identifier | <text string> $00 |
| Method symbol | $xx |
| Encryption data | <binary data> |
For more details, please refer to the ID3 specifications: *
The 'Content type', which previously was * stored as a one byte numeric value only, is now a numeric string. You * may use one or several of the types as ID3v1.1 did or, since the * category list would be impossible to maintain with accurate and up to * date categories, define your own. *
* ID3V23:References to the ID3v1 genres can be made by, as first byte, enter * "(" followed by a number from the genres list (appendix A) and * ended with a ")" character. This is optionally followed by a * refinement, e.g. "(21)" or "(4)Eurodisco". Several references can be * made in the same frame, e.g. "(51)(39)". If the refinement should * begin with a "(" character it should be replaced with "((", e.g. "((I * can figure out any genre)" or "(55)((I think...)". The following new * content types is defined in ID3v2 and is implemented in the same way * as the numeric content types, e.g. "(RX)". *
| RX | Remix |
| CR | Cover |
For more details, please refer to the ID3 specifications: *
| RX | Remix |
| CR | Cover |
| <Head for 'Position synchronisation', ID: "POSS"> | |
| Time stamp format | $xx |
| Position | $xx (xx ...) |
* $01 Absolute time, 32 bit sized, using MPEG frames as unit
* $02 Absolute time, 32 bit sized, using milliseconds as unit
*
* and position is where in the audio the listener starts to receive, * i.e. the beginning of the next frame. If this frame is used in the * beginning of a file the value is always 0. There may only be one * "POSS" frame in each tag. *
* *For more details, please refer to the ID3 specifications: *
The 'Original release year' frame is intended for the year when the original recording, if for example the music * in the file should be a cover of a previously released song, was released. The field is formatted as in the "TYER" * frame. *
*For more details, please refer to the ID3 specifications: *
This frame contains a picture directly related to the audio file. * Image format is preferably "PNG" [PNG] or "JPG" [JFIF]. Description * is a short description of the picture, represented as a terminated * textstring. The description has a maximum length of 64 characters, * but may be empty. There may be several pictures attached to one file, * each in their individual "PIC" frame, but only one with the same * ontent descriptor. There may only be one picture with the picture * type declared as picture type $01 and $02 respectively. There is a * possibility to put only a link to the image file by using the 'image * format' "-->" and having a complete URL [URL] instead of picture data. * The use of linked files should however be used restrictively since * there is the risk of separation of files. *
* Attached picture "PIC" * Frame size $xx xx xx * Text encoding $xx * Image format $xx xx xx * Picture type $xx * DescriptionThe 'Part of a set' frame is a numeric string that describes which part of a set the audio came from. * This frame is used if the source described in the "TALB" frame is divided into several mediums, e.g. a double CD. * The value may be extended with a "/" character and a numeric string containing the total number of parts in the set. * e.g. "1/2". *
*For more details, please refer to the ID3 specifications: *
* After the 'Owner identifier', a pointer to an unencrypted part of the * audio can be specified. The 'Preview start' and 'Preview length' is * described in frames. If no part is unencrypted, these fields should * be left zeroed. After the 'preview length' field follows optionally a * datablock required for decryption of the audio. There may be more * than one "AENC" frames in a tag, but only one with the same 'Owner * identifier'. *
| <Header for 'Audio encryption', ID: "AENC"> | |
| Owner identifier | <text string> $00 |
| Preview start | $xx xx |
| Preview length | $xx xx |
| Encryption info | <binary data> |
For more details, please refer to the ID3 specifications: *
The 'Copyright message' frame, which must begin with a year and a space character (making five characters), is intended for the copyright holder of the original sound, not the audio file itself. The absence of this frame means only that the copyright information is unavailable or has been removed, and must not be interpreted to mean that the sound is public domain. Every time this field is displayed the field must be preceded with "Copyright ©". *
*For more details, please refer to the ID3 specifications: *
The 'Year' frame is a numeric string with a year of the recording. This frames is always four characters long (until the year 10000). *
Deprecated in v2.4.0 *
*For more details, please refer to the ID3 specifications: *
The 'Size' frame contains the size of the audiofile in bytes, excluding the ID3v2 tag, represented as a numeric string. *
*For more details, please refer to the ID3 specifications: *
The 'Software/Hardware and settings used for encoding' frame includes the used audio encoder and its settings when the file was encoded. Hardware refers to hardware encoders, not the computer on which a program was run. *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Private frame', ID: "PRIV"> | |
| Owner identifier | <text string> $00 |
| The private data | <binary data> |
For more details, please refer to the ID3 specifications: *
The 'Official internet radio station homepage' contains a URL pointing at the homepage of the internet radio station. *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Ownership frame', ID: "OWNE"> | |
| Text encoding | $xx |
| Price payed | <text string> $00 |
| Date of purch. | <text string> |
| Seller | <text string according to encoding> |
For more details, please refer to the ID3 specifications: *
| <Header for 'Group ID registration', ID: "GRID"> | |
| Owner identifier | <text string> $00 |
| Group symbol | $xx |
| Group dependent data | <binary data> |
For more details, please refer to the ID3 specifications: *
The 'Subtitle/Description refinement' frame is used for information directly related to the contents title (e.g. "Op. 16" or "Performed live at Wembley"). *
*For more details, please refer to the ID3 specifications: *
| <Header of 'Equalisation', ID: "EQUA"> | |
| Adjustment bits | $xx |
* The 'adjustment bits' field defines the number of bits used for * representation of the adjustment. This is normally $10 (16 bits) for * MPEG 2 layer I, II and III and MPEG 2.5. This value may not be * $00. *
* This is followed by 2 bytes + ('adjustment bits' rounded up to the * nearest byte) for every equalisation band in the following format, * giving a frequency range of 0 - 32767Hz: *
| Increment/decrement | %x (MSB of the Frequency) |
| Frequency | (lower 15 bits) |
| Adjustment | $xx (xx ...) |
* The increment/decrement bit is 1 for increment and 0 for decrement. * The equalisation bands should be ordered increasingly with reference * to frequency. All frequencies don't have to be declared. The * equalisation curve in the reading software should be interpolated * between the values in this frame. Three equal adjustments for three * subsequent frequencies. A frequency should only be described once in * the frame. *
* *For more details, please refer to the ID3 specifications: *
* Each reference consists of two parts; a certain number of bits, as * defined in 'bits for bytes deviation', that describes the difference * between what is said in 'bytes between reference' and the reality and * a certain number of bits, as defined in 'bits for milliseconds * deviation', that describes the difference between what is said in * 'milliseconds between reference' and the reality. The number of bits * in every reference, i.e. 'bits for bytes deviation'+'bits for * milliseconds deviation', must be a multiple of four. There may only * be one "MLLT" frame in each tag. *
| <Header for 'Location lookup table', ID: "MLLT"> | |
| MPEG frames between reference | $xx xx |
| Bytes between reference | $xx xx xx |
| Milliseconds between reference | $xx xx xx |
| Bits for bytes deviation | $xx |
| Bits for milliseconds dev. | $xx |
* Then for every reference the following data is included; *
| Deviation in bytes | %xxx.... |
| Deviation in milliseconds | %xxx.... |
For more details, please refer to the ID3 specifications: *
The 'Title/Songname/Content description' frame is the actual name of the piece (e.g. "Adagio", "Hurricane Donna"). *
*For more details, please refer to the ID3 specifications: *
The 'Commercial information' frame is a URL pointing at a webpage with information such as where the album can be * bought. There may be more than one "WCOM" frame in a tag, but not with the same content. *
*For more details, please refer to the ID3 specifications: *
determines whether or not track is part of compilation * * @author : Paul Taylor */ public class FrameBodyTCMP extends AbstractFrameBodyTextInfo implements ID3v24FrameBody, ID3v23FrameBody { //TODO does iTunes have to have null terminator? static String IS_COMPILATION = "1\u0000"; /** * Creates a new FrameBodyTCMP datatype, with compilation enabled *
* This is the preferred constructor to use because TCMP frames should not exist * unless they are set to true */ public FrameBodyTCMP() { setObjectValue(DataTypes.OBJ_TEXT_ENCODING, TextEncoding.ISO_8859_1); setObjectValue(DataTypes.OBJ_TEXT, IS_COMPILATION); } public FrameBodyTCMP(FrameBodyTCMP body) { super(body); } /** * Creates a new FrameBodyTCMP datatype. * * @param textEncoding * @param text */ public FrameBodyTCMP(byte textEncoding, String text) { super(textEncoding, text); } public boolean isCompilation() { return this.getText().equals(IS_COMPILATION); } /** * Creates a new FrameBodyTIT1 datatype. * * @param byteBuffer * @param frameSize * @throws InvalidTagException */ public FrameBodyTCMP(ByteBuffer byteBuffer, int frameSize) throws InvalidTagException { super(byteBuffer, frameSize); } /** * The ID3v2 frame identifier * * @return the ID3v2 frame identifier for this frame type */ public String getIdentifier() { return ID3v24Frames.FRAME_ID_IS_COMPILATION; } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/framebody/FrameBodyTEXT.java 0000644 0001750 0001750 00000005024 11277006322 030131 0 ustar drazzib drazzib /* * 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.framebody; import org.jaudiotagger.tag.InvalidTagException; import org.jaudiotagger.tag.id3.ID3v24Frames; import java.nio.ByteBuffer; /** * Lyricist/Text writer Text information frame. *The 'Lyricist(s)/Text writer(s)' frame is intended for the writer(s) of the text or lyrics in the recording. They are seperated with the "/" character. *
*For more details, please refer to the ID3 specifications: *
The 'Time' frame is a numeric string in the HHMM format containing the time for the recording. This field is always four characters long. *
Deprecated in v2.4.0 *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Terms of use frame', ID: "USER"> | |
| Text encoding | $xx |
| Language | $xx xx xx |
| The actual text | <text string according to encoding> |
For more details, please refer to the ID3 specifications: *
The 'Band/Orchestra/Accompaniment' frame is used for additional information about the performers in the recording. *
*For more details, please refer to the ID3 specifications: *
The 'Length' frame contains the length of the audiofile in milliseconds, represented as a numeric string. *
*For more details, please refer to the ID3 specifications: *
The 'Composer(s)' frame is intended for the name of the composer(s). They are seperated with the "/" character. *
*For more details, please refer to the ID3 specifications: *
The 'Date' frame is a numeric string in the DDMM format containing the date for the recording. This field is always four characters long. *
Deprecated in v2.4.0 *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Event timing codes', ID: "ETCO"> | |
| Time stamp format | $xx |
* Where time stamp format is: *
* $01 Absolute time, 32 bit sized, using MPEG frames as unit
* $02 Absolute time, 32 bit sized, using milliseconds as unit
*
* Abolute time means that every stamp contains the time from the * beginning of the file. *
* Followed by a list of key events in the following format: *
| Type of event | $xx |
| Time stamp | $xx (xx ...) |
* The 'Time stamp' is set to zero if directly at the beginning of the * sound or after the previous event. All events should be sorted in * chronological order. The type of event is as follows: *
| $00 | padding (has no meaning) |
| $01 | end of initial silence |
| $02 | intro start |
| $03 | mainpart start |
| $04 | outro start |
| $05 | outro end |
| $06 | verse start |
| $07 | refrain start |
| $08 | interlude start |
| $09 | theme start |
| $0A | variation start |
| $0B | key change |
| $0C | time change |
| $0D | momentary unwanted noise (Snap, Crackle & Pop) |
| $0E | sustained noise |
| $0F | sustained noise end |
| $10 | intro end |
| $11 | mainpart end |
| $12 | verse end |
| $13 | refrain end |
| $14 | theme end |
| $15-$DF | reserved for future use |
| $E0-$EF | not predefined sync 0-F |
| $F0-$FC | reserved for future use |
| $FD | audio end (start of silence) |
| $FE | audio file ends |
| $FF | one more byte of events follows (all the following bytes with the value $FF have the same function) |
* Terminating the start events such as "intro start" is not required. * The 'Not predefined sync's ($E0-EF) are for user events. You might * want to synchronise your music to something, like setting of an * explosion on-stage, turning on your screensaver etc. *
* There may only be one "ETCO" frame in each tag.
* *For more details, please refer to the ID3 specifications: *
* There may be more than one frame of this type in a tag but each must * have an Element ID that is unique with respect to any other "CTOC" or * "CHAP" frame in the tag. *
* Each "CTOC" frame represents one level or element of a table of contents * by providing a list of Child Element IDs. These match the Element IDs of * other "CHAP" and "CTOC" frames in the tag. *
*| <ID3v2.3 or ID3v2.4 frame header, ID: "CTOC"> | (10 bytes) | |
| Element ID | <text string> $00 | |
| Flags | %000000ab | |
| Entry count | $xx (8-bit unsigned int) | |
| <Child Element ID list> | ||
| <Optional embedded sub-frames> |
* Flag a - Top-level bit
* This is set to 1 to identify the top-level "CTOC" frame. This frame
* is the root of the Table of Contents tree and is not a child of any
* other "CTOC" frame. Only one "CTOC" frame in an ID3v2 tag can have
* this bit set to 1. In all other "CTOC" frames this bit shall be set
* to 0.
*
* Flag b - Ordered bit
* This should be set to 1 if the entries in the Child Element ID list
* are ordered or set to 0 if they not are ordered. This provides a hint
* as to whether the elements should be played as a continuous ordered
* sequence or played individually.
*
* The Entry count is the number of entries in the Child Element ID list * that follows and must be greater than zero. Each entry in the list * consists of: *
*| Child Element ID | <text string> $00 |
* If a parser does not recognise "CTOC" frames it can skip them using * the size field in the frame header. When it does this it will skip * any embedded sub-frames carried within the frame. *
* *For more details, please refer to the ID3 Chapter Frame specifications: *
* * @author Marc Gimpel, Horizon Wimba S.A. * @version $Id: FrameBodyCTOC.java 832 2009-11-12 13:25:38Z paultaylor $ */ public class FrameBodyCTOC extends AbstractID3v2FrameBody implements ID3v2ChapterFrameBody { /** * Creates a new FrameBodyCTOC datatype. */ public FrameBodyCTOC() { } /** * Creates a new FrameBodyCTOC datatype. * * @param body */ public FrameBodyCTOC(FrameBodyCTOC body) { super(body); } /** * Creates a new FrameBodyCTOC datatype. * * @param byteBuffer * @param frameSize * @throws InvalidTagException if unable to create framebody from buffer */ public FrameBodyCTOC(ByteBuffer byteBuffer, int frameSize) throws InvalidTagException { super(byteBuffer, frameSize); } /** * The ID3v2 frame identifier * * @return the ID3v2 frame identifier for this frame type */ public String getIdentifier() { return ID3v2ChapterFrames.FRAME_ID_TABLE_OF_CONTENT; } /** * TODO:proper mapping */ protected void setupObjectList() { objectList.add(new ByteArraySizeTerminated(DataTypes.OBJ_DATA, this)); } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/framebody/FrameBodySEEK.java 0000644 0001750 0001750 00000005044 11277006322 030076 0 ustar drazzib drazzib /** * @author : Paul Taylor * @author : Eric Farng * * Version @version:$Id: FrameBodySEEK.java 832 2009-11-12 13:25:38Z paultaylor $ * * 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 * * Description: * */ package org.jaudiotagger.tag.id3.framebody; import org.jaudiotagger.tag.InvalidTagException; import org.jaudiotagger.tag.datatype.DataTypes; import org.jaudiotagger.tag.datatype.NumberFixedLength; import org.jaudiotagger.tag.id3.ID3v24Frames; import java.nio.ByteBuffer; public class FrameBodySEEK extends AbstractID3v2FrameBody implements ID3v24FrameBody { /** * Creates a new FrameBodySEEK datatype. */ public FrameBodySEEK() { // this.setObject("Minimum Offset to Next Tag", new Integer(0)); } /** * Creates a new FrameBodySEEK datatype. * * @param minOffsetToNextTag */ public FrameBodySEEK(int minOffsetToNextTag) { this.setObjectValue(DataTypes.OBJ_OFFSET, minOffsetToNextTag); } public FrameBodySEEK(FrameBodySEEK body) { super(body); } /** * Creates a new FrameBodySEEK datatype. * * @param byteBuffer * @param frameSize * @throws InvalidTagException if unable to create framebody from buffer */ public FrameBodySEEK(ByteBuffer byteBuffer, int frameSize) throws InvalidTagException { super(byteBuffer, frameSize); } /** * The ID3v2 frame identifier * * @return the ID3v2 frame identifier for this frame type */ public String getIdentifier() { return ID3v24Frames.FRAME_ID_AUDIO_SEEK_POINT_INDEX; } /** * */ protected void setupObjectList() { objectList.add(new NumberFixedLength(DataTypes.OBJ_OFFSET, this, 4)); } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/framebody/FrameBodyWOAR.java 0000644 0001750 0001750 00000005021 11277006322 030112 0 ustar drazzib drazzib /* * 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.framebody; import org.jaudiotagger.tag.InvalidTagException; import org.jaudiotagger.tag.id3.ID3v24Frames; import java.nio.ByteBuffer; /** * Official artist/performer webpage URL link frames. *The 'Official artist/performer webpage' frame is a URL pointing at the artists official webpage. There may be more than one "WOAR" frame in a tag if the audio contains more than one performer, but not with the same content. *
*For more details, please refer to the ID3 specifications: *
The 'Recording dates' frame is a intended to be used as complement to the "TYER", "TDAT" and "TIME" frames. E.g. "4th-7th June, 12th June" in combination with the "TYER" frame. *
*For more details, please refer to the ID3 specifications: *
The 'Lead artist(s)/Lead performer(s)/Soloist(s)/Performing group' is used for the main artist(s). They are seperated with the "/" character. *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Comment', ID: "COMM"> | |
| Text encoding | $xx |
| Language | $xx xx xx |
| Short content descrip. | <text string according to encoding> $00 (00) |
| The actual text | <full text string according to encoding> |
For more details, please refer to the ID3 specifications: *
The 'BPM' frame contains the number of beats per minute in the mainpart of the audio. The BPM is an integer and represented as a numerical string. *
*For more details, please refer to the ID3 specifications: *
The 'Content group description' frame is used if the sound belongs to a larger category of sounds/music. * For example, classical music is often sorted in different musical sections (e.g. "Piano Concerto", "Weather - Hurricane"). *
*For more details, please refer to the ID3 specifications: *
The 'Album/Movie/Show title' frame is intended for the title of the recording(/source of sound) which the audio in the file is taken from. *
*For more details, please refer to the ID3 specifications: *
For more details, please refer to the ID3 specifications: *
The 'Original lyricist(s)/text writer(s)' frame is intended for the text writer(s) of the original recording, if for example the music in the file should be a cover of a previously released song. The text writers are seperated with the "/" character. *
*For more details, please refer to the ID3 specifications: *
The 'Official audio file webpage' frame is a URL pointing at a file specific webpage. *
*For more details, please refer to the ID3 specifications: *
* 'Premix left to right' is the amount of left sound to be mixed in the * right before any reverb is applied, where $00 id 0% and $FF is 100%. * 'Premix right to left' does the same thing, but right to left. * Setting both premix to $FF would result in a mono output (if the * reverb is applied symmetric). There may only be one "RVRB" frame in * each tag. *
| <Header for 'Reverb', ID: "RVRB"> | |
| Reverb left (ms) | $xx xx |
| Reverb right (ms) | $xx xx |
| Reverb bounces, left | $xx |
| Reverb bounces, right | $xx |
| Reverb feedback, left to left | $xx |
| Reverb feedback, left to right | $xx |
| Reverb feedback, right to right | $xx |
| Reverb feedback, right to left | $xx |
| Premix left to right | $xx |
| Premix right to left | $xx |
For more details, please refer to the ID3 specifications: *
| <Header for 'Popularimeter', ID: "POPM"> | |
| Email to user | <text string> $00 |
| Rating | $xx |
| Counter | $xx xx xx xx (xx ...) |
For more details, please refer to the ID3 specifications: *
The 'Interpreted, remixed, or otherwise modified by' frame contains more information about the people behind a remix and similar interpretations of another existing piece. *
*For more details, please refer to the ID3 specifications: *
The 'Publishers official webpage' frame is a URL pointing at the official wepage for the publisher. *
*For more details, please refer to the ID3 specifications: *
| <Header for 'General encapsulated object', ID: "GEOB"> | |
| Text encoding | $xx |
| MIME type | <text string> $00 |
| Filename | <text string according to encoding> $00 (00) |
| Content description | |
| Encapsulated object | <binary data> |
For more details, please refer to the ID3 specifications: *
* The price string is followed by an 8 character date string in the * format YYYYMMDD, describing for how long the price is valid. After * that is a contact URL, with which the user can contact the seller, * followed by a one byte 'received as' field. It describes how the * audio is delivered when bought according to the following list: *
| $00 | Other |
| $01 | Standard CD album with other songs |
| $02 | Compressed audio on CD |
| $03 | File over the Internet |
| $04 | Stream over the Internet |
| $05 | As note sheets |
| $06 | As note sheets in a book with other sheets |
| $07 | Music on other media |
| $08 | Non-musical merchandise |
* Next follows a terminated string with the name of the seller followed * by a terminated string with a short description of the product. The * last thing is the ability to include a company logotype. The first of * them is the 'Picture MIME type' field containing information about * which picture format is used. In the event that the MIME media type * name is omitted, "image/" will be implied. Currently only "image/png" * and "image/jpeg" are allowed. This format string is followed by the * binary picture data. This two last fields may be omitted if no * picture is to attach. *
| <Header for 'Commercial frame', ID: "COMR"> | |
| Text encoding | $xx |
| Price string | <text string> $00 |
| Valid until | <text string> |
| Contact URL | <text string> $00 |
| Received as | $xx |
| Name of seller | <text string according to encoding> $00 (00) |
| Description | <text string according to encoding> $00 (00) |
| Picture MIME type | <string> $00 |
| Seller logo | <binary data> |
For more details, please refer to the ID3 specifications: *
| <Header for 'Attached picture', ID: "APIC"> | |
| Text encoding | $xx |
| MIME type | <text string> $00 |
| Picture type | $xx |
| Description | <text string according to encoding> $00 (00) |
| Picture data | <binary data> |
| Picture type: | *$00 | Other |
| $01 | 32x32 pixels 'file icon' (PNG only) | |
| $02 | Other file icon | |
| $03 | Cover (front) | |
| $04 | Cover (back) | |
| $05 | Leaflet page | |
| $06 | Media (e.g. lable side of CD) | |
| $07 | Lead artist/lead performer/soloist | |
| $08 | Artist/performer | |
| $09 | Conductor | |
| $0A | Band/Orchestra | |
| $0B | Composer | |
| $0C | Lyricist/text writer | |
| $0D | Recording Location | |
| $0E | During recording | |
| $0F | During performance | |
| $10 | Movie/video screen capture | |
| $11 | A bright coloured fish | |
| $12 | Illustration | |
| $13 | Band/artist logotype | |
| $14 | Publisher/Studio logotype |
For more details, please refer to the ID3 specifications: *
The 'Payment' frame is a URL pointing at a webpage that will handle the process of paying for this file. *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Music CD identifier', ID: "MCDI"> | |
| CD TOC | <binary data> |
For more details, please refer to the ID3 specifications: *
The 'Initial key' frame contains the musical key in which the sound starts. It is represented as a string with * a maximum length of three characters. The ground keys are represented with "A","B","C","D","E", "F" and "G" and halfkeys represented * with "b" and "#". Minor is represented as "m". Example "Cbm". Off key is represented with an "o" only. *
*For more details, please refer to the ID3 specifications: *
The 'Tagging time' frame contains a timestamp describing then the * audio was tagged. Timestamp format is described in the ID3v2 * structure document
*/ public class FrameBodyTDTG extends AbstractFrameBodyTextInfo implements ID3v24FrameBody { /** * Creates a new FrameBodyTDTG datatype. */ public FrameBodyTDTG() { } public FrameBodyTDTG(FrameBodyTDTG body) { super(body); } /** * Creates a new FrameBodyTDTG datatype. * * @param textEncoding * @param text */ public FrameBodyTDTG(byte textEncoding, String text) { super(textEncoding, text); } /** * Creates a new FrameBodyTDTG datatype. * * @param byteBuffer * @param frameSize * @throws java.io.IOException * @throws InvalidTagException */ public FrameBodyTDTG(ByteBuffer byteBuffer, int frameSize) throws InvalidTagException { super(byteBuffer, frameSize); } /** * @return the frame identifier */ public String getIdentifier() { return ID3v24Frames.FRAME_ID_TAGGING_TIME; } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/framebody/FrameBodyTLAN.java 0000644 0001750 0001750 00000006112 11277006322 030102 0 ustar drazzib drazzib /* * 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.framebody; import org.jaudiotagger.tag.InvalidTagException; import org.jaudiotagger.tag.id3.ID3v24Frames; import org.jaudiotagger.tag.reference.Languages; import java.nio.ByteBuffer; /** * Language(s) Text information frame. *The 'Language(s)' frame should contain the languages of the text or lyrics spoken or sung in the audio. The language is represented with three characters according to ISO-639-2. If more than one language is used in the text their language codes should follow according to their usage. *
*For more details, please refer to the ID3 specifications: *
The 'File type' frame indicates which type of audio this tag defines. * The following type and refinements are defined: *
| MPG | MPEG Audio | |
| /1 | MPEG 1/2 layer I | |
| /2 | MPEG 1/2 layer II | |
| /3 | MPEG 1/2 layer III | |
| /2.5 | MPEG 2.5 | |
| /AAC | Advanced audio compression | |
| VQF | Transform-domain Weighted Interleave Vector Quantization | |
| PCM | Pulse Code Modulated audio |
* but other types may be used, not for these types though. This is used * in a similar way to the predefined types in the "TMED" frame, but * without parentheses. If this frame is not present audio type is * assumed to be "MPG". *
* *For more details, please refer to the ID3 specifications: *
The 'Original album/movie/show title' frame is intended for the title of the original recording (or source of sound), if for example the music * in the file should be a cover of a previously released song. *
*For more details, please refer to the ID3 specifications: *
The 'File owner/licensee' frame contains the name of the owner or licensee of the file and it's contents. *
*For more details, please refer to the ID3 specifications: *
| <ID3v2.3 or ID3v2.4 frame header, ID: "CHAP"> | (10 bytes) | |
| Element ID | <text string> $00 | |
| Start time | $xx xx xx xx | |
| End time | $xx xx xx xx | |
| Start offset | $xx xx xx xx | |
| End offset | $xx xx xx xx | |
| <Optional embedded sub-frames> |
* The Element ID uniquely identifies the frame. It is not intended to * be human readable and should not be presented to the end user. *
* The Start and End times are a count in milliseconds from the * beginning of the file to the start and end of the chapter * respectively. *
* The Start offset is a zero-based count of bytes from the beginning * of the file to the first byte of the first audio frame in the * chapter. If these bytes are all set to 0xFF then the value should be * ignored and the start time value should be utilized. *
* The End offset is a zero-based count of bytes from the beginning of * the file to the first byte of the audio frame following the end of * the chapter. If these bytes are all set to 0xFF then the value should * be ignored and the end time value should be utilized. *
* There then follows a sequence of optional frames that are embedded * within the "CHAP" frame and which describe the content of the chapter * (e.g. a "TIT2" frame representing the chapter name) or provide * related material such as URLs and images. These sub-frames are * contained within the bounds of the "CHAP" frame as signalled by the * size field in the "CHAP" frame header. If a parser does not recognise * "CHAP" frames it can skip them using the size field in the frame * header. When it does this it will skip any embedded sub-frames * carried within the frame. *
* *For more details, please refer to the ID3 Chapter Frame specifications: *
* * @author Marc Gimpel, Horizon Wimba S.A. * @version $Id: FrameBodyCHAP.java 832 2009-11-12 13:25:38Z paultaylor $ */ public class FrameBodyCHAP extends AbstractID3v2FrameBody implements ID3v2ChapterFrameBody { /** * Creates a new FrameBodyCHAP datatype. */ public FrameBodyCHAP() { } /** * Creates a new FrameBodyCHAP datatype. * * @param body */ public FrameBodyCHAP(FrameBodyCHAP body) { super(body); } /** * Creates a new FrameBodyCHAP datatype. * * @param elementId * @param startTime * @param endTime * @param startOffset * @param endOffset */ public FrameBodyCHAP(String elementId, int startTime, int endTime, int startOffset, int endOffset) { this.setObjectValue(DataTypes.OBJ_ELEMENT_ID, elementId); this.setObjectValue(DataTypes.OBJ_START_TIME, startTime); this.setObjectValue(DataTypes.OBJ_END_TIME, endTime); this.setObjectValue(DataTypes.OBJ_START_OFFSET, startOffset); this.setObjectValue(DataTypes.OBJ_END_OFFSET, endOffset); } /** * Creates a new FrameBodyAENC datatype. * * @param byteBuffer * @param frameSize * @throws InvalidTagException if unable to create framebody from buffer */ public FrameBodyCHAP(ByteBuffer byteBuffer, int frameSize) throws InvalidTagException { super(byteBuffer, frameSize); } /** * The ID3v2 frame identifier * * @return the ID3v2 frame identifier for this frame type */ public String getIdentifier() { return ID3v2ChapterFrames.FRAME_ID_CHAPTER; } /** * */ protected void setupObjectList() { objectList.add(new StringNullTerminated(DataTypes.OBJ_ELEMENT_ID, this)); objectList.add(new NumberFixedLength(DataTypes.OBJ_START_TIME, this, 4)); objectList.add(new NumberFixedLength(DataTypes.OBJ_END_TIME, this, 4)); objectList.add(new NumberFixedLength(DataTypes.OBJ_START_OFFSET, this, 4)); objectList.add(new NumberFixedLength(DataTypes.OBJ_END_OFFSET, this, 4)); } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/framebody/FrameBodyTRSN.java 0000644 0001750 0001750 00000004776 11277006322 030150 0 ustar drazzib drazzib /* * 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.framebody; import org.jaudiotagger.tag.InvalidTagException; import org.jaudiotagger.tag.id3.ID3v24Frames; import java.nio.ByteBuffer; /** * Internet radio station name Text information frame. *The 'Internet radio station name' frame contains the name of the internet radio station from which the audio is streamed. *
*For more details, please refer to the ID3 specifications: *
| <Header for 'Unsynchronised lyrics/text transcription', ID: "USLT"> | |
| Text encoding | $xx |
| Language | $xx xx xx |
| Content descriptor | <text string according to encoding> $00 (00) |
| Lyrics/text | <full text string according to encoding> |
For more details, please refer to the ID3 specifications: *
The 'Original release time' frame contains a timestamp describing * when the original recording of the audio was released. Timestamp * format is described in the ID3v2 structure document.
*/ public class FrameBodyTDOR extends AbstractFrameBodyTextInfo implements ID3v24FrameBody { /** * Creates a new FrameBodyTDOR datatype. */ public FrameBodyTDOR() { } public FrameBodyTDOR(FrameBodyTDOR body) { super(body); } /** * When converting v3 TDAT to v4 TDRC frame * @param body */ public FrameBodyTDOR(FrameBodyTORY body) { setObjectValue(DataTypes.OBJ_TEXT_ENCODING, TextEncoding.ISO_8859_1); setObjectValue(DataTypes.OBJ_TEXT, body.getText()); } /** * Creates a new FrameBodyTDOR datatype. * * @param textEncoding * @param text */ public FrameBodyTDOR(byte textEncoding, String text) { super(textEncoding, text); } /** * Creates a new FrameBodyTDOR datatype. * * @param byteBuffer * @param frameSize * @throws InvalidTagException */ public FrameBodyTDOR(ByteBuffer byteBuffer, int frameSize) throws InvalidTagException { super(byteBuffer, frameSize); } /** * The ID3v2 frame identifier * * @return the ID3v2 frame identifier for this frame type */ public String getIdentifier() { return ID3v24Frames.FRAME_ID_ORIGINAL_RELEASE_TIME; } } libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/AbstractID3v2Frame.java 0000644 0001750 0001750 00000051161 11470746136 027106 0 ustar drazzib drazzib /* * 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.audio.mp3.MP3File; import org.jaudiotagger.tag.*; import org.jaudiotagger.tag.id3.framebody.AbstractID3v2FrameBody; import org.jaudiotagger.tag.id3.framebody.FrameBodyEncrypted; import org.jaudiotagger.tag.id3.framebody.FrameBodyUnsupported; import org.jaudiotagger.tag.id3.valuepair.TextEncoding; import org.jaudiotagger.utils.EqualsUtil; import java.io.ByteArrayOutputStream; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.nio.ByteBuffer; import java.util.logging.Level; /** * This abstract class is each frame header inside a ID3v2 tag. * * @author : Paul Taylor * @author : Eric Farng * @version $Id: AbstractID3v2Frame.java 929 2010-11-17 12:36:46Z paultaylor $ */ public abstract class AbstractID3v2Frame extends AbstractTagFrame implements TagTextField { protected static final String TYPE_FRAME = "frame"; protected static final String TYPE_FRAME_SIZE = "frameSize"; protected static final String UNSUPPORTED_ID = "Unsupported"; //Frame identifier protected String identifier = ""; //Frame Size protected int frameSize; //The purpose of this is to provide the filename that should be used when writing debug messages //when problems occur reading or writing to file, otherwise it is difficult to track down the error //when processing many files private String loggingFilename = ""; /** * * @return size in bytes of the frameid field */ protected abstract int getFrameIdSize(); /** * * @return the size in bytes of the frame size field */ protected abstract int getFrameSizeSize(); /** * * @return the size in bytes of the frame header */ protected abstract int getFrameHeaderSize(); /** * Create an empty frame */ protected AbstractID3v2Frame() { } /** * This holds the Status flags (not supported in v2.20 */ StatusFlags statusFlags = null; /** * This holds the Encoding flags (not supported in v2.20) */ EncodingFlags encodingFlags = null; /** * Create a frame based on another frame * @param frame */ public AbstractID3v2Frame(AbstractID3v2Frame frame) { super(frame); } /** * Create a frame based on a body * @param body */ public AbstractID3v2Frame(AbstractID3v2FrameBody body) { this.frameBody = body; this.frameBody.setHeader(this); } /** * Create a new frame with empty body based on identifier * @param identifier */ //TODO the identifier checks should be done in the relevent subclasses public AbstractID3v2Frame(String identifier) { logger.info("Creating empty frame of type" + identifier); this.identifier = identifier; // Use reflection to map id to frame body, which makes things much easier // to keep things up to date. try { ClassLog info messages for falgs that have been set and log warnings when bits have been set for unknown flags
* * @param byteBuffer * @throws TagException */ private void readHeaderFlags(ByteBuffer byteBuffer) throws TagException { //Flags byte flags = byteBuffer.get(); unsynchronization = (flags & MASK_V24_UNSYNCHRONIZATION) != 0; extended = (flags & MASK_V24_EXTENDED_HEADER) != 0; experimental = (flags & MASK_V24_EXPERIMENTAL) != 0; footer = (flags & MASK_V24_FOOTER_PRESENT) != 0; //Not allowable/Unknown Flags if ((flags & FileConstants.BIT3) != 0) { logger.warning(ErrorMessage.ID3_INVALID_OR_UNKNOWN_FLAG_SET.getMsg(getLoggingFilename(), FileConstants.BIT3)); } if ((flags & FileConstants.BIT2) != 0) { logger.warning(ErrorMessage.ID3_INVALID_OR_UNKNOWN_FLAG_SET.getMsg(getLoggingFilename(), FileConstants.BIT2)); } if ((flags & FileConstants.BIT1) != 0) { logger.warning(ErrorMessage.ID3_INVALID_OR_UNKNOWN_FLAG_SET.getMsg(getLoggingFilename(), FileConstants.BIT1)); } if ((flags & FileConstants.BIT0) != 0) { logger.warning(ErrorMessage.ID3_INVALID_OR_UNKNOWN_FLAG_SET.getMsg(getLoggingFilename(), FileConstants.BIT0)); } if (isUnsynchronization()) { logger.info(ErrorMessage.ID3_TAG_UNSYNCHRONIZED.getMsg(getLoggingFilename())); } if (extended) { logger.info(ErrorMessage.ID3_TAG_EXTENDED.getMsg(getLoggingFilename())); } if (experimental) { logger.info(ErrorMessage.ID3_TAG_EXPERIMENTAL.getMsg(getLoggingFilename())); } if (footer) { logger.warning(ErrorMessage.ID3_TAG_FOOTER.getMsg(getLoggingFilename())); } } /** * Read the optional extended header * * @param byteBuffer * @param size * @throws org.jaudiotagger.tag.InvalidTagException */ private void readExtendedHeader(ByteBuffer byteBuffer, int size) throws InvalidTagException { byte[] buffer; // int is 4 bytes. int extendedHeaderSize = byteBuffer.getInt(); // the extended header must be at least 6 bytes if (extendedHeaderSize <= TAG_EXT_HEADER_LENGTH) { throw new InvalidTagException(ErrorMessage.ID3_EXTENDED_HEADER_SIZE_TOO_SMALL.getMsg(getLoggingFilename(), extendedHeaderSize)); } //Number of bytes byteBuffer.get(); // Read the extended flag bytes byte extFlag = byteBuffer.get(); updateTag = (extFlag & MASK_V24_TAG_UPDATE) != 0; crcDataFlag = (extFlag & MASK_V24_CRC_DATA_PRESENT) != 0; tagRestriction = (extFlag & MASK_V24_TAG_RESTRICTIONS) != 0; // read the length byte if the flag is set // this tag should always be zero but just in case // read this information. if (updateTag) { byteBuffer.get(); } //CRC-32 if (crcDataFlag) { // the CRC has a variable length byteBuffer.get(); buffer = new byte[TAG_EXT_HEADER_CRC_DATA_LENGTH]; byteBuffer.get(buffer, 0, TAG_EXT_HEADER_CRC_DATA_LENGTH); crcData = 0; for (int i = 0; i < TAG_EXT_HEADER_CRC_DATA_LENGTH; i++) { crcData <<= 8; crcData += buffer[i]; } } //Tag Restriction if (tagRestriction) { byteBuffer.get(); buffer = new byte[1]; byteBuffer.get(buffer, 0, 1); tagSizeRestriction = (byte) ((buffer[0] & MASK_V24_TAG_SIZE_RESTRICTIONS) >> 6); textEncodingRestriction = (byte) ((buffer[0] & MASK_V24_TEXT_ENCODING_RESTRICTIONS) >> 5); textFieldSizeRestriction = (byte) ((buffer[0] & MASK_V24_TEXT_FIELD_SIZE_RESTRICTIONS) >> 3); imageEncodingRestriction = (byte) ((buffer[0] & MASK_V24_IMAGE_ENCODING) >> 2); imageSizeRestriction = (byte) (buffer[0] & MASK_V24_IMAGE_SIZE_RESTRICTIONS); } } /** * {@inheritDoc} */ @Override public void read(ByteBuffer byteBuffer) throws TagException { int size; byte[] buffer; if (!seek(byteBuffer)) { throw new TagNotFoundException(getLoggingFilename() + ":" + getIdentifier() + " tag not found"); } logger.info(getLoggingFilename() + ":" + "Reading ID3v24 tag"); readHeaderFlags(byteBuffer); // Read the size, this is size of tag apart from tag header size = ID3SyncSafeInteger.bufferToValue(byteBuffer); logger.info(getLoggingFilename() + ":" + "Reading tag from file size set in header is" + size); if (extended) { readExtendedHeader(byteBuffer, size); } //Note if there was an extended header the size value has padding taken //off so we dont search it. readFrames(byteBuffer, size); } /** * Read frames from tag * @param byteBuffer * @param size */ protected void readFrames(ByteBuffer byteBuffer, int size) { logger.finest(getLoggingFilename() + ":" + "Start of frame body at" + byteBuffer.position()); //Now start looking for frames ID3v24Frame next; frameMap = new LinkedHashMap(); encryptedFrameMap = new LinkedHashMap(); //Read the size from the Tag Header this.fileReadSize = size; // Read the frames until got to upto the size as specified in header logger.finest(getLoggingFilename() + ":" + "Start of frame body at:" + byteBuffer.position() + ",frames data size is:" + size); while (byteBuffer.position() <= size) { String id; try { //Read Frame logger.finest(getLoggingFilename() + ":" + "looking for next frame at:" + byteBuffer.position()); next = new ID3v24Frame(byteBuffer, getLoggingFilename()); id = next.getIdentifier(); loadFrameIntoMap(id, next); } //Found Padding, no more frames catch (PaddingException ex) { logger.config(getLoggingFilename() + ":Found padding starting at:" + byteBuffer.position()); break; } //Found Empty Frame catch (EmptyFrameException ex) { logger.warning(getLoggingFilename() + ":" + "Empty Frame:" + ex.getMessage()); this.emptyFrameBytes += TAG_HEADER_LENGTH; } catch (InvalidFrameIdentifierException ifie) { logger.info(getLoggingFilename() + ":" + "Invalid Frame Identifier:" + ifie.getMessage()); this.invalidFrames++; //Don't try and find any more frames break; } //Problem trying to find frame catch (InvalidFrameException ife) { logger.warning(getLoggingFilename() + ":" + "Invalid Frame:" + ife.getMessage()); this.invalidFrames++; //Don't try and find any more frames break; } //Failed reading frame but may just have invalid data but correct length so lets carry on //in case we can read the next frame catch(InvalidDataTypeException idete) { logger.warning(getLoggingFilename() + ":Corrupt Frame:" + idete.getMessage()); this.invalidFrames++; continue; } } } /** * Write the ID3 header to the ByteBuffer. * * TODO Calculate the CYC Data Check * TODO Reintroduce Extended Header * * @param padding is the size of the padding * @param size is the size of the body data * @return ByteBuffer * @throws IOException */ private ByteBuffer writeHeaderToBuffer(int padding, int size) throws IOException { //This would only be set if every frame in tag has been unsynchronized, I only unsychronize frames //that need it, in any case I have been advised not to set it even then. unsynchronization = false; // Flags,currently we never calculate the CRC // and if we dont calculate them cant keep orig values. Tags are not // experimental and we never create extended header to keep things simple. extended = false; experimental = false; footer = false; // Create Header Buffer,allocate maximum possible size for the header ByteBuffer headerBuffer = ByteBuffer.allocate(TAG_HEADER_LENGTH); //TAGID headerBuffer.put(TAG_ID); //Major Version headerBuffer.put(getMajorVersion()); //Minor Version headerBuffer.put(getRevision()); //Flags byte flagsByte = 0; if (isUnsynchronization()) { flagsByte |= MASK_V24_UNSYNCHRONIZATION; } if (extended) { flagsByte |= MASK_V24_EXTENDED_HEADER; } if (experimental) { flagsByte |= MASK_V24_EXPERIMENTAL; } if (footer) { flagsByte |= MASK_V24_FOOTER_PRESENT; } headerBuffer.put(flagsByte); //Size As Recorded in Header, don't include the main header length //Additional Header Size,(for completeness we never actually write the extended header, or footer) int additionalHeaderSize = 0; if (extended) { additionalHeaderSize += TAG_EXT_HEADER_LENGTH; if (updateTag) { additionalHeaderSize += TAG_EXT_HEADER_UPDATE_LENGTH; } if (crcDataFlag) { additionalHeaderSize += TAG_EXT_HEADER_CRC_LENGTH; } if (tagRestriction) { additionalHeaderSize += TAG_EXT_HEADER_RESTRICTION_LENGTH; } } //Size As Recorded in Header, don't include the main header length headerBuffer.put(ID3SyncSafeInteger.valueToBuffer(padding + size + additionalHeaderSize)); //Write Extended Header ByteBuffer extHeaderBuffer = null; if (extended) { //Write Extended Header Size int extendedSize = TAG_EXT_HEADER_LENGTH; if (updateTag) { extendedSize += TAG_EXT_HEADER_UPDATE_LENGTH; } if (crcDataFlag) { extendedSize += TAG_EXT_HEADER_CRC_LENGTH; } if (tagRestriction) { extendedSize += TAG_EXT_HEADER_RESTRICTION_LENGTH; } extHeaderBuffer = ByteBuffer.allocate(extendedSize); extHeaderBuffer.putInt(extendedSize); //Write Number of flags Byte extHeaderBuffer.put((byte) TAG_EXT_NUMBER_BYTES_DATA_LENGTH); //Write Extended Flags byte extFlag = 0; if (updateTag) { extFlag |= MASK_V24_TAG_UPDATE; } if (crcDataFlag) { extFlag |= MASK_V24_CRC_DATA_PRESENT; } if (tagRestriction) { extFlag |= MASK_V24_TAG_RESTRICTIONS; } extHeaderBuffer.put(extFlag); //Write Update Data if (updateTag) { extHeaderBuffer.put((byte) 0); } //Write CRC Data if (crcDataFlag) { extHeaderBuffer.put((byte) TAG_EXT_HEADER_CRC_DATA_LENGTH); extHeaderBuffer.put((byte) 0); extHeaderBuffer.putInt(crcData); } //Write Tag Restriction if (tagRestriction) { extHeaderBuffer.put((byte) TAG_EXT_HEADER_RESTRICTION_DATA_LENGTH); //todo not currently setting restrictions extHeaderBuffer.put((byte) 0); } } if (extHeaderBuffer != null) { extHeaderBuffer.flip(); headerBuffer.put(extHeaderBuffer); } headerBuffer.flip(); return headerBuffer; } /** * {@inheritDoc} */ @Override public void write(File file, long audioStartLocation) throws IOException { setLoggingFilename(file.getName()); logger.info("Writing tag to file:"+getLoggingFilename()); //Write Body Buffer byte[] bodyByteBuffer = writeFramesToBuffer().toByteArray(); //Calculate Tag Size including Padding int sizeIncPadding = calculateTagSize(bodyByteBuffer.length + TAG_HEADER_LENGTH, (int) audioStartLocation); //Calculate padding bytes required int padding = sizeIncPadding - (bodyByteBuffer.length + TAG_HEADER_LENGTH); ByteBuffer headerBuffer = writeHeaderToBuffer(padding, bodyByteBuffer.length); writeBufferToFile(file, headerBuffer, bodyByteBuffer, padding, sizeIncPadding, audioStartLocation); } /** * {@inheritDoc} */ @Override public void write(WritableByteChannel channel) throws IOException { logger.info("Writing tag to channel"); byte[] bodyByteBuffer = writeFramesToBuffer().toByteArray(); ByteBuffer headerBuffer = writeHeaderToBuffer(0, bodyByteBuffer.length); channel.write(headerBuffer); channel.write(ByteBuffer.wrap(bodyByteBuffer)); } /** * Display the tag in an XMLFormat */ public void createStructure() { MP3File.getStructureFormatter().openHeadingElement(TYPE_TAG, getIdentifier()); super.createStructureHeader(); //Header MP3File.getStructureFormatter().openHeadingElement(TYPE_HEADER, ""); MP3File.getStructureFormatter().addElement(TYPE_UNSYNCHRONISATION, this.isUnsynchronization()); MP3File.getStructureFormatter().addElement(TYPE_CRCDATA, this.crcData); MP3File.getStructureFormatter().addElement(TYPE_EXPERIMENTAL, this.experimental); MP3File.getStructureFormatter().addElement(TYPE_EXTENDED, this.extended); MP3File.getStructureFormatter().addElement(TYPE_PADDINGSIZE, this.paddingSize); MP3File.getStructureFormatter().addElement(TYPE_FOOTER, this.footer); MP3File.getStructureFormatter().addElement(TYPE_IMAGEENCODINGRESTRICTION, this.paddingSize); MP3File.getStructureFormatter().addElement(TYPE_IMAGESIZERESTRICTION, this.imageSizeRestriction); MP3File.getStructureFormatter().addElement(TYPE_TAGRESTRICTION, this.tagRestriction); MP3File.getStructureFormatter().addElement(TYPE_TAGSIZERESTRICTION, this.tagSizeRestriction); MP3File.getStructureFormatter().addElement(TYPE_TEXTFIELDSIZERESTRICTION, this.textFieldSizeRestriction); MP3File.getStructureFormatter().addElement(TYPE_TEXTENCODINGRESTRICTION, this.textEncodingRestriction); MP3File.getStructureFormatter().addElement(TYPE_UPDATETAG, this.updateTag); MP3File.getStructureFormatter().closeHeadingElement(TYPE_HEADER); //Body super.createStructureBody(); MP3File.getStructureFormatter().closeHeadingElement(TYPE_TAG); } /** * Are all frame swithin this tag unsynchronized * *Because synchronization occurs at the frame level it is not normally desirable to unsynchronize all frames * and hence this flag is not normally set. * * @return are all frames within the tag unsynchronized */ public boolean isUnsynchronization() { return unsynchronization; } /** * Create a new frame with the specified frameid * * @param id * @return */ public ID3v24Frame createFrame(String id) { return new ID3v24Frame(id); } /** * Create Frame for Id3 Key *
* Only textual data supported at the moment, should only be used with frames that * support a simple string argument. * * @param id3Key * @param value * @return * @throws KeyNotFoundException * @throws FieldDataInvalidException */ public TagField createField(ID3v24FieldKey id3Key, String value) throws KeyNotFoundException, FieldDataInvalidException { if (id3Key == null) { throw new KeyNotFoundException(); } return super.doCreateTagField(new FrameAndSubId(id3Key.getFrameId(), id3Key.getSubId()), value); } /** * Retrieve the first value that exists for this id3v24key * * @param id3v24FieldKey * @return * @throws org.jaudiotagger.tag.KeyNotFoundException */ public String getFirst(ID3v24FieldKey id3v24FieldKey) throws KeyNotFoundException { if (id3v24FieldKey == null) { throw new KeyNotFoundException(); } FrameAndSubId frameAndSubId = new FrameAndSubId(id3v24FieldKey.getFrameId(), id3v24FieldKey.getSubId()); if (id3v24FieldKey == ID3v24FieldKey.TRACK) { AbstractID3v2Frame frame = getFirstField(frameAndSubId.getFrameId()); return String.valueOf(((FrameBodyTRCK)frame.getBody()).getTrackNo()); } else if (id3v24FieldKey == ID3v24FieldKey.TRACK_TOTAL) { AbstractID3v2Frame frame = getFirstField(frameAndSubId.getFrameId()); return String.valueOf(((FrameBodyTRCK)frame.getBody()).getTrackTotal()); } else if (id3v24FieldKey == ID3v24FieldKey.DISC_NO) { AbstractID3v2Frame frame = getFirstField(frameAndSubId.getFrameId()); return String.valueOf(((FrameBodyTPOS)frame.getBody()).getDiscNo()); } else if (id3v24FieldKey == ID3v24FieldKey.DISC_TOTAL) { AbstractID3v2Frame frame = getFirstField(frameAndSubId.getFrameId()); return String.valueOf(((FrameBodyTPOS)frame.getBody()).getDiscTotal()); } else { return super.doGetValueAtIndex(frameAndSubId, 0); } } /** * Delete fields with this id3v24FieldKey * * @param id3v24FieldKey * @throws org.jaudiotagger.tag.KeyNotFoundException */ public void deleteField(ID3v24FieldKey id3v24FieldKey) throws KeyNotFoundException { if (id3v24FieldKey == null) { throw new KeyNotFoundException(); } super.doDeleteTagField(new FrameAndSubId(id3v24FieldKey.getFrameId(), id3v24FieldKey.getSubId())); } /** * Delete fields with this (frame) id * @param id */ public void deleteField(String id) { super.doDeleteTagField(new FrameAndSubId(id,null)); } protected FrameAndSubId getFrameAndSubIdFromGenericKey(FieldKey genericKey) { ID3v24FieldKey id3v24FieldKey = ID3v24Frames.getInstanceOf().getId3KeyFromGenericKey(genericKey); if (id3v24FieldKey == null) { throw new KeyNotFoundException("Unable to find key for "+genericKey.name()); } return new FrameAndSubId(id3v24FieldKey.getFrameId(), id3v24FieldKey.getSubId()); } protected ID3Frames getID3Frames() { return ID3v24Frames.getInstanceOf(); } /** * @return comparator used to order frames in preferred order for writing to file * so that most important frames are written first. */ public Comparator getPreferredFrameOrderComparator() { return ID3v24PreferredFrameOrderComparator.getInstanceof(); } public ListYou can include frames here that are not officially supported as long as they can be used within an
* ID3v24Tag
*
* @author Paul Taylor
* @version $Id: ID3v24Frames.java 929 2010-11-17 12:36:46Z paultaylor $
*/
public class ID3v24Frames extends ID3Frames
{
/**
* Frame IDs beginning with T are text frames, & with W are url frames
*/
public static final String FRAME_ID_ACCOMPANIMENT = "TPE2";
public static final String FRAME_ID_ALBUM = "TALB";
public static final String FRAME_ID_ALBUM_SORT_ORDER = "TSOA";
public static final String FRAME_ID_ARTIST = "TPE1";
public static final String FRAME_ID_ATTACHED_PICTURE = "APIC";
public static final String FRAME_ID_AUDIO_ENCRYPTION = "AENC";
public static final String FRAME_ID_AUDIO_SEEK_POINT_INDEX = "ASPI";
public static final String FRAME_ID_BPM = "TBPM";
public static final String FRAME_ID_COMMENT = "COMM";
public static final String FRAME_ID_COMMERCIAL_FRAME = "COMR";
public static final String FRAME_ID_COMPOSER = "TCOM";
public static final String FRAME_ID_CONDUCTOR = "TPE3";
public static final String FRAME_ID_CONTENT_GROUP_DESC = "TIT1";
public static final String FRAME_ID_COPYRIGHTINFO = "TCOP";
public static final String FRAME_ID_ENCODEDBY = "TENC";
public static final String FRAME_ID_ENCODING_TIME = "TDEN";
public static final String FRAME_ID_ENCRYPTION = "ENCR";
public static final String FRAME_ID_EQUALISATION2 = "EQU2";
public static final String FRAME_ID_EVENT_TIMING_CODES = "ETCO";
public static final String FRAME_ID_FILE_OWNER = "TOWN";
public static final String FRAME_ID_FILE_TYPE = "TFLT";
public static final String FRAME_ID_GENERAL_ENCAPS_OBJECT = "GEOB";
public static final String FRAME_ID_GENRE = "TCON";
public static final String FRAME_ID_GROUP_ID_REG = "GRID";
public static final String FRAME_ID_HW_SW_SETTINGS = "TSSE";
public static final String FRAME_ID_INITIAL_KEY = "TKEY";
public static final String FRAME_ID_INVOLVED_PEOPLE = "TIPL";
public static final String FRAME_ID_ISRC = "TSRC";
public static final String FRAME_ID_LANGUAGE = "TLAN";
public static final String FRAME_ID_LENGTH = "TLEN";
public static final String FRAME_ID_LINKED_INFO = "LINK";
public static final String FRAME_ID_LYRICIST = "TEXT";
public static final String FRAME_ID_MEDIA_TYPE = "TMED";
public static final String FRAME_ID_MOOD = "TMOO";
public static final String FRAME_ID_MPEG_LOCATION_LOOKUP_TABLE = "MLLT";
public static final String FRAME_ID_MUSICIAN_CREDITS = "TMCL";
public static final String FRAME_ID_MUSIC_CD_ID = "MCDI";
public static final String FRAME_ID_ORIGARTIST = "TOPE";
public static final String FRAME_ID_ORIGINAL_RELEASE_TIME = "TDOR";
public static final String FRAME_ID_ORIG_FILENAME = "TOFN";
public static final String FRAME_ID_ORIG_LYRICIST = "TOLY";
public static final String FRAME_ID_ORIG_TITLE = "TOAL";
public static final String FRAME_ID_OWNERSHIP = "OWNE";
public static final String FRAME_ID_ARTIST_SORT_ORDER = "TSOP";
public static final String FRAME_ID_PLAYLIST_DELAY = "TDLY";
public static final String FRAME_ID_PLAY_COUNTER = "PCNT";
public static final String FRAME_ID_POPULARIMETER = "POPM";
public static final String FRAME_ID_POSITION_SYNC = "POSS";
public static final String FRAME_ID_PRIVATE = "PRIV";
public static final String FRAME_ID_PRODUCED_NOTICE = "TPRO";
public static final String FRAME_ID_PUBLISHER = "TPUB";
public static final String FRAME_ID_RADIO_NAME = "TRSN";
public static final String FRAME_ID_RADIO_OWNER = "TRSO";
public static final String FRAME_ID_RECOMMENDED_BUFFER_SIZE = "RBUF";
public static final String FRAME_ID_RELATIVE_VOLUME_ADJUSTMENT2 = "RVA2";
public static final String FRAME_ID_RELEASE_TIME = "TDRL";
public static final String FRAME_ID_REMIXED = "TPE4";
public static final String FRAME_ID_REVERB = "RVRB";
public static final String FRAME_ID_SEEK = "SEEK";
public static final String FRAME_ID_SET = "TPOS";
public static final String FRAME_ID_SET_SUBTITLE = "TSST";
public static final String FRAME_ID_SIGNATURE = "SIGN";
public static final String FRAME_ID_SYNC_LYRIC = "SYLT";
public static final String FRAME_ID_SYNC_TEMPO = "SYTC";
public static final String FRAME_ID_TAGGING_TIME = "TDTG";
public static final String FRAME_ID_TERMS_OF_USE = "USER";
public static final String FRAME_ID_TITLE = "TIT2";
public static final String FRAME_ID_TITLE_REFINEMENT = "TIT3";
public static final String FRAME_ID_TITLE_SORT_ORDER = "TSOT";
public static final String FRAME_ID_TRACK = "TRCK";
public static final String FRAME_ID_UNIQUE_FILE_ID = "UFID";
public static final String FRAME_ID_UNSYNC_LYRICS = "USLT";
public static final String FRAME_ID_URL_ARTIST_WEB = "WOAR";
public static final String FRAME_ID_URL_COMMERCIAL = "WCOM";
public static final String FRAME_ID_URL_COPYRIGHT = "WCOP";
public static final String FRAME_ID_URL_FILE_WEB = "WOAF";
public static final String FRAME_ID_URL_OFFICIAL_RADIO = "WORS";
public static final String FRAME_ID_URL_PAYMENT = "WPAY";
public static final String FRAME_ID_URL_PUBLISHERS = "WPUB";
public static final String FRAME_ID_URL_SOURCE_WEB = "WOAS";
public static final String FRAME_ID_USER_DEFINED_INFO = "TXXX";
public static final String FRAME_ID_USER_DEFINED_URL = "WXXX";
public static final String FRAME_ID_YEAR = "TDRC";
public static final String FRAME_ID_ALBUM_ARTIST_SORT_ORDER_ITUNES = "TSO2";
public static final String FRAME_ID_COMPOSER_SORT_ORDER_ITUNES = "TSOC";
public static final String FRAME_ID_IS_COMPILATION = "TCMP";
//TODO this is temporary to provide backwards compatability
public static final String FRAME_ID_PERFORMER_SORT_OWNER = FRAME_ID_ARTIST_SORT_ORDER;
public static final String FRAME_ID_TITLE_SORT_OWNER = FRAME_ID_TITLE_SORT_ORDER;
protected EnumMap 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
* For more details, please refer to the ID3 Chapter Frame specifications:
* For single frames return the frame in this tag with given identifier if it exists, if multiple frames
* exist with the same identifier it will return a list containing all the frames with this identifier
*
* @param identifier
* @return
*/
public Object getEncryptedFrame(String identifier)
{
return encryptedFrameMap.get(identifier);
}
/**
* Retrieve the first value that exists for this identifier
* Currently Write all frames, defaults to the order in which they were loaded, newly
* created frames will be at end of tag.
*
* @return ByteBuffer Contains all the frames written within the tag ready for writing to file
* @throws IOException
*/
protected ByteArrayOutputStream writeFramesToBuffer() throws IOException
{
ByteArrayOutputStream bodyBuffer = new ByteArrayOutputStream();
writeFramesToBufferStream(frameMap, bodyBuffer);
writeFramesToBufferStream(encryptedFrameMap, bodyBuffer);
return bodyBuffer;
}
/**
* Write frames in map to bodyBuffer
*
* @param map
* @param bodyBuffer
* @throws IOException
*/
private void writeFramesToBufferStream(Map map, ByteArrayOutputStream bodyBuffer) throws IOException
{
//Sort keys into Preferred Order
TreeSetsuper.equals(obj).
*
* @param obj The object to compare
* @return if they are equal
*/
public boolean equals(Object obj)
{
return (obj instanceof AbstractTag) && super.equals(obj);
}
/**
* @return
*/
abstract public Iterator iterator();
}
libjaudiotagger-java-2.0.3/src/org/jaudiotagger/tag/id3/ID3v2ChapterFrames.java 0000644 0001750 0001750 00000004027 11276777123 027117 0 ustar drazzib drazzib /*
* Horizon Wimba Copyright (C)2006
*
* 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 getFields 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 java.util.TreeSet;
/**
* Defines ID3 Chapter frames and collections that categorise frames.
*
* ID3v2 tag.
* The old file will be deleted, and the new file renamed.
*
* @param paddingSize This is total size required to store tag before audio
* @param audioStart
* @param file The file to adjust the padding length of
* @throws FileNotFoundException if the file exists but is a directory
* rather than a regular file or cannot be opened for any other
* reason
* @throws IOException on any I/O error
*/
public void adjustPadding(File file, int paddingSize, long audioStart) throws FileNotFoundException, IOException
{
logger.finer("Need to move audio file to accomodate tag");
FileChannel fcIn = null;
FileChannel fcOut;
//Create buffer holds the necessary padding
ByteBuffer paddingBuffer = ByteBuffer.wrap(new byte[paddingSize]);
//Create Temporary File and write channel, make sure it is locked
File paddedFile;
try
{
paddedFile = File.createTempFile(Utils.getMinBaseFilenameAllowedForTempFile(file), ".new", file.getParentFile());
logger.finest("Created temp file:" + paddedFile.getName() + " for " + file.getName());
}
//Vista:Can occur if have Write permission on folder this file would be created in Denied
catch (IOException ioe)
{
logger.log(Level.SEVERE, ioe.getMessage(), ioe);
if (ioe.getMessage().equals(FileSystemMessage.ACCESS_IS_DENIED.getMsg()))
{
logger.severe(ErrorMessage.GENERAL_WRITE_FAILED_TO_CREATE_TEMPORARY_FILE_IN_FOLDER.getMsg(file.getName(), file.getParentFile().getPath()));
throw new UnableToCreateFileException(ErrorMessage.GENERAL_WRITE_FAILED_TO_CREATE_TEMPORARY_FILE_IN_FOLDER.getMsg(file.getName(), file.getParentFile().getPath()));
}
else
{
logger.severe(ErrorMessage.GENERAL_WRITE_FAILED_TO_CREATE_TEMPORARY_FILE_IN_FOLDER.getMsg(file.getName(), file.getParentFile().getPath()));
throw new UnableToCreateFileException(ErrorMessage.GENERAL_WRITE_FAILED_TO_CREATE_TEMPORARY_FILE_IN_FOLDER.getMsg(file.getName(), file.getParentFile().getPath()));
}
}
try
{
fcOut = new FileOutputStream(paddedFile).getChannel();
}
//Vista:Can occur if have special permission Create Folder/Append Data denied
catch (FileNotFoundException ioe)
{
logger.log(Level.SEVERE, ioe.getMessage(), ioe);
logger.severe(ErrorMessage.GENERAL_WRITE_FAILED_TO_MODIFY_TEMPORARY_FILE_IN_FOLDER.getMsg(file.getName(), file.getParentFile().getPath()));
throw new UnableToModifyFileException(ErrorMessage.GENERAL_WRITE_FAILED_TO_MODIFY_TEMPORARY_FILE_IN_FOLDER.getMsg(file.getName(), file.getParentFile().getPath()));
}
try
{
//Create read channel from original file
//TODO lock so cant be modified by anything else whilst reading from it ?
fcIn = new FileInputStream(file).getChannel();
//Write padding to new file (this is where the tag will be written to later)
long written = fcOut.write(paddingBuffer);
//Write rest of file starting from audio
logger.finer("Copying:" + (file.length() - audioStart) + "bytes");
//If the amount to be copied is very large we split into 10MB lumps to try and avoid
//out of memory errors
long audiolength = file.length() - audioStart;
if (audiolength <= MAXIMUM_WRITABLE_CHUNK_SIZE)
{
long written2 = fcIn.transferTo(audioStart, audiolength, fcOut);
logger.finer("Written padding:" + written + " Data:" + written2);
if (written2 != audiolength)
{
throw new RuntimeException(ErrorMessage.MP3_UNABLE_TO_ADJUST_PADDING.getMsg(audiolength, written2));
}
}
else
{
long noOfChunks = audiolength / MAXIMUM_WRITABLE_CHUNK_SIZE;
long lastChunkSize = audiolength % MAXIMUM_WRITABLE_CHUNK_SIZE;
long written2 = 0;
for (int i = 0; i < noOfChunks; i++)
{
written2 += fcIn.transferTo(audioStart + (i * MAXIMUM_WRITABLE_CHUNK_SIZE), MAXIMUM_WRITABLE_CHUNK_SIZE, fcOut);
}
written2 += fcIn.transferTo(audioStart + (noOfChunks * MAXIMUM_WRITABLE_CHUNK_SIZE), lastChunkSize, fcOut);
logger.finer("Written padding:" + written + " Data:" + written2);
if (written2 != audiolength)
{
throw new RuntimeException(ErrorMessage.MP3_UNABLE_TO_ADJUST_PADDING.getMsg(audiolength, written2));
}
}
//Store original modification time
long lastModified = file.lastModified();
//Close Channels and locks
if (fcIn != null)
{
if (fcIn.isOpen())
{
fcIn.close();
}
}
if (fcOut != null)
{
if (fcOut.isOpen())
{
fcOut.close();
}
}
//Replace file with paddedFile
replaceFile(file, paddedFile);
//Update modification time
//TODO is this the right file ?
paddedFile.setLastModified(lastModified);
}
finally
{
try
{
//Whatever happens ensure all locks and channels are closed/released
if (fcIn != null)
{
if (fcIn.isOpen())
{
fcIn.close();
}
}
if (fcOut != null)
{
if (fcOut.isOpen())
{
fcOut.close();
}
}
}
catch (Exception e)
{
logger.log(Level.WARNING, "Problem closing channels and locks:" + e.getMessage(), e);
}
}
}
/**
* Write the data from the buffer to the file
*
* @param file
* @param headerBuffer
* @param bodyByteBuffer
* @param padding
* @param sizeIncPadding
* @param audioStartLocation
* @throws IOException
*/
protected void writeBufferToFile(File file, ByteBuffer headerBuffer, byte[] bodyByteBuffer, int padding, int sizeIncPadding, long audioStartLocation) throws IOException
{
FileChannel fc = null;
FileLock fileLock = null;
//We need to adjust location of audio file if true
if (sizeIncPadding > audioStartLocation)
{
logger.finest("Adjusting Padding");
adjustPadding(file, sizeIncPadding, audioStartLocation);
}
try
{
fc = new RandomAccessFile(file, "rws").getChannel();
fileLock = getFileLockForWriting(fc, file.getPath());
fc.write(headerBuffer);
fc.write(ByteBuffer.wrap(bodyByteBuffer));
fc.write(ByteBuffer.wrap(new byte[padding]));
}
catch (FileNotFoundException fe)
{
logger.log(Level.SEVERE, getLoggingFilename() + fe.getMessage(), fe);
if (fe.getMessage().equals(FileSystemMessage.ACCESS_IS_DENIED.getMsg()))
{
logger.severe(ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(file.getPath()));
throw new UnableToModifyFileException(ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(file.getPath()));
}
else
{
logger.severe(ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(file.getPath()));
throw new UnableToCreateFileException(ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(file.getPath()));
}
}
catch (IOException ioe)
{
logger.log(Level.SEVERE, getLoggingFilename() + ioe.getMessage(), ioe);
if (ioe.getMessage().equals(FileSystemMessage.ACCESS_IS_DENIED.getMsg()))
{
logger.severe(ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(file.getParentFile().getPath()));
throw new UnableToModifyFileException(ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(file.getParentFile().getPath()));
}
else
{
logger.severe(ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(file.getParentFile().getPath()));
throw new UnableToCreateFileException(ErrorMessage.GENERAL_WRITE_FAILED_TO_OPEN_FILE_FOR_EDITING.getMsg(file.getParentFile().getPath()));
}
}
finally
{
if (fc != null)
{
if (fileLock != null)
{
fileLock.release();
}
fc.close();
}
}
}
/**
* Replace originalFile with the contents of newFile
*
* Both files must exist in the same folder so that there are no problems with fileystem mount points
*
* @param newFile
* @param originalFile
* @throws IOException
*/
private void replaceFile(File originalFile, File newFile) throws IOException
{
boolean renameOriginalResult;
//Rename Original File to make a backup in case problem with new file
File originalFileBackup = new File(originalFile.getAbsoluteFile().getParentFile().getPath(), AudioFile.getBaseFilename(originalFile) + ".old");
//If already exists modify the suffix
int count = 1;
while (originalFileBackup.exists())
{
originalFileBackup = new File(originalFile.getAbsoluteFile().getParentFile().getPath(), AudioFile.getBaseFilename(originalFile) + ".old" + count);
count++;
}
renameOriginalResult = originalFile.renameTo(originalFileBackup);
if (!renameOriginalResult)
{
logger.warning(ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_ORIGINAL_FILE_TO_BACKUP.getMsg(originalFile.getAbsolutePath(), originalFileBackup.getName()));
throw new UnableToRenameFileException(ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_ORIGINAL_FILE_TO_BACKUP.getMsg(originalFile.getAbsolutePath(), originalFileBackup.getName()));
}
//Rename new Temporary file to the final file
boolean renameResult = newFile.renameTo(originalFile);
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
renameOriginalResult = originalFileBackup.renameTo(originalFile);
if (!renameOriginalResult)
{
//TODO now if this happens we are left with testfile.old instead of testfile.mp3
logger.warning(ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_ORIGINAL_BACKUP_TO_ORIGINAL.getMsg(originalFileBackup.getAbsolutePath(), originalFile.getName()));
}
logger.warning(ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_TO_ORIGINAL_FILE.getMsg(originalFile.getAbsolutePath(), newFile.getName()));
throw new UnableToRenameFileException(ErrorMessage.GENERAL_WRITE_FAILED_TO_RENAME_TO_ORIGINAL_FILE.getMsg(originalFile.getAbsolutePath(), newFile.getName()));
}
else
{
//Rename was okay so we can now deleteField the backup of the original
boolean deleteResult = originalFileBackup.delete();
if (!deleteResult)
{
//Not a disaster but can't deleteField the backup so make a warning
logger.warning(ErrorMessage.GENERAL_WRITE_WARNING_UNABLE_TO_DELETE_BACKUP_FILE.getMsg(originalFileBackup.getAbsolutePath()));
}
}
}
/*
* Copy framne into map, whilst accounting for multiple frame of same type which can occur even if there were
* not frames of the same type in the original tag
*/
protected void copyFrameIntoMap(String id, AbstractID3v2Frame newFrame)
{
if (frameMap.containsKey(newFrame.getIdentifier()))
{
Object o = frameMap.get(newFrame.getIdentifier());
if (o instanceof AbstractID3v2Frame)
{
List