diff options
Diffstat (limited to 'isoparser/src/main/java/com/coremedia/iso/boxes/ItemLocationBox.java')
| -rw-r--r-- | isoparser/src/main/java/com/coremedia/iso/boxes/ItemLocationBox.java | 360 |
1 files changed, 360 insertions, 0 deletions
diff --git a/isoparser/src/main/java/com/coremedia/iso/boxes/ItemLocationBox.java b/isoparser/src/main/java/com/coremedia/iso/boxes/ItemLocationBox.java new file mode 100644 index 0000000..6dcee6f --- /dev/null +++ b/isoparser/src/main/java/com/coremedia/iso/boxes/ItemLocationBox.java @@ -0,0 +1,360 @@ +/* + * Copyright 2008 CoreMedia AG, Hamburg + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.coremedia.iso.boxes; + + +import com.coremedia.iso.IsoTypeReader; +import com.coremedia.iso.IsoTypeReaderVariable; +import com.coremedia.iso.IsoTypeWriter; +import com.coremedia.iso.IsoTypeWriterVariable; +import com.googlecode.mp4parser.AbstractFullBox; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.LinkedList; +import java.util.List; + +/** + * aligned(8) class ItemLocationBox extends FullBox(‘iloc’, version, 0) { + * unsigned int(4) offset_size; + * unsigned int(4) length_size; + * unsigned int(4) base_offset_size; + * if (version == 1) + * unsigned int(4) index_size; + * else + * unsigned int(4) reserved; + * unsigned int(16) item_count; + * for (i=0; i<item_count; i++) { + * unsigned int(16) item_ID; + * if (version == 1) { + * unsigned int(12) reserved = 0; + * unsigned int(4) construction_method; + * } + * unsigned int(16) data_reference_index; + * unsigned int(base_offset_size*8) base_offset; + * unsigned int(16) extent_count; + * for (j=0; j<extent_count; j++) { + * if ((version == 1) && (index_size > 0)) { + * unsigned int(index_size*8) extent_index; + * } + * unsigned int(offset_size*8) extent_offset; + * unsigned int(length_size*8) extent_length; + * } + * } + * } + */ +public class ItemLocationBox extends AbstractFullBox { + public int offsetSize = 8; + public int lengthSize = 8; + public int baseOffsetSize = 8; + public int indexSize = 0; + public List<Item> items = new LinkedList<Item>(); + + public static final String TYPE = "iloc"; + + public ItemLocationBox() { + super(TYPE); + } + + @Override + protected long getContentSize() { + long size = 8; + for (Item item : items) { + size += item.getSize(); + } + return size; + } + + + @Override + protected void getContent(ByteBuffer byteBuffer) { + writeVersionAndFlags(byteBuffer); + IsoTypeWriter.writeUInt8(byteBuffer, ((offsetSize << 4) | lengthSize)); + if (getVersion() == 1) { + IsoTypeWriter.writeUInt8(byteBuffer, (baseOffsetSize << 4 | indexSize)); + } else { + IsoTypeWriter.writeUInt8(byteBuffer, (baseOffsetSize << 4)); + } + IsoTypeWriter.writeUInt16(byteBuffer, items.size()); + for (Item item : items) { + item.getContent(byteBuffer); + } + } + + @Override + public void _parseDetails(ByteBuffer content) { + parseVersionAndFlags(content); + int tmp = IsoTypeReader.readUInt8(content); + offsetSize = tmp >>> 4; + lengthSize = tmp & 0xf; + tmp = IsoTypeReader.readUInt8(content); + baseOffsetSize = tmp >>> 4; + + if (getVersion() == 1) { + indexSize = tmp & 0xf; + } + int itemCount = IsoTypeReader.readUInt16(content); + for (int i = 0; i < itemCount; i++) { + items.add(new Item(content)); + } + } + + + public int getOffsetSize() { + return offsetSize; + } + + public void setOffsetSize(int offsetSize) { + this.offsetSize = offsetSize; + } + + public int getLengthSize() { + return lengthSize; + } + + public void setLengthSize(int lengthSize) { + this.lengthSize = lengthSize; + } + + public int getBaseOffsetSize() { + return baseOffsetSize; + } + + public void setBaseOffsetSize(int baseOffsetSize) { + this.baseOffsetSize = baseOffsetSize; + } + + public int getIndexSize() { + return indexSize; + } + + public void setIndexSize(int indexSize) { + this.indexSize = indexSize; + } + + public List<Item> getItems() { + return items; + } + + public void setItems(List<Item> items) { + this.items = items; + } + + + public Item createItem(int itemId, int constructionMethod, int dataReferenceIndex, long baseOffset, List<Extent> extents) { + return new Item(itemId, constructionMethod, dataReferenceIndex, baseOffset, extents); + } + + Item createItem(ByteBuffer bb) { + return new Item(bb); + } + + public class Item { + public int itemId; + public int constructionMethod; + public int dataReferenceIndex; + public long baseOffset; + public List<Extent> extents = new LinkedList<Extent>(); + + public Item(ByteBuffer in) { + itemId = IsoTypeReader.readUInt16(in); + + if (getVersion() == 1) { + int tmp = IsoTypeReader.readUInt16(in); + constructionMethod = tmp & 0xf; + } + + dataReferenceIndex = IsoTypeReader.readUInt16(in); + if (baseOffsetSize > 0) { + baseOffset = IsoTypeReaderVariable.read(in, baseOffsetSize); + } else { + baseOffset = 0; + } + int extentCount = IsoTypeReader.readUInt16(in); + + + for (int i = 0; i < extentCount; i++) { + extents.add(new Extent(in)); + } + } + + public Item(int itemId, int constructionMethod, int dataReferenceIndex, long baseOffset, List<Extent> extents) { + this.itemId = itemId; + this.constructionMethod = constructionMethod; + this.dataReferenceIndex = dataReferenceIndex; + this.baseOffset = baseOffset; + this.extents = extents; + } + + public int getSize() { + int size = 2; + + if (getVersion() == 1) { + size += 2; + } + + size += 2; + size += baseOffsetSize; + size += 2; + + + for (Extent extent : extents) { + size += extent.getSize(); + } + return size; + } + + public void setBaseOffset(long baseOffset) { + this.baseOffset = baseOffset; + } + + public void getContent(ByteBuffer bb) { + IsoTypeWriter.writeUInt16(bb, itemId); + + if (getVersion() == 1) { + IsoTypeWriter.writeUInt16(bb, constructionMethod); + } + + + IsoTypeWriter.writeUInt16(bb, dataReferenceIndex); + if (baseOffsetSize > 0) { + IsoTypeWriterVariable.write(baseOffset, bb, baseOffsetSize); + } + IsoTypeWriter.writeUInt16(bb, extents.size()); + + for (Extent extent : extents) { + extent.getContent(bb); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Item item = (Item) o; + + if (baseOffset != item.baseOffset) return false; + if (constructionMethod != item.constructionMethod) return false; + if (dataReferenceIndex != item.dataReferenceIndex) return false; + if (itemId != item.itemId) return false; + if (extents != null ? !extents.equals(item.extents) : item.extents != null) return false; + + return true; + } + + @Override + public int hashCode() { + int result = itemId; + result = 31 * result + constructionMethod; + result = 31 * result + dataReferenceIndex; + result = 31 * result + (int) (baseOffset ^ (baseOffset >>> 32)); + result = 31 * result + (extents != null ? extents.hashCode() : 0); + return result; + } + + @Override + public String toString() { + return "Item{" + + "baseOffset=" + baseOffset + + ", itemId=" + itemId + + ", constructionMethod=" + constructionMethod + + ", dataReferenceIndex=" + dataReferenceIndex + + ", extents=" + extents + + '}'; + } + } + + + public Extent createExtent(long extentOffset, long extentLength, long extentIndex) { + return new Extent(extentOffset, extentLength, extentIndex); + } + + Extent createExtent(ByteBuffer bb) { + return new Extent(bb); + } + + + public class Extent { + public long extentOffset; + public long extentLength; + public long extentIndex; + + public Extent(long extentOffset, long extentLength, long extentIndex) { + this.extentOffset = extentOffset; + this.extentLength = extentLength; + this.extentIndex = extentIndex; + } + + + public Extent(ByteBuffer in) { + if ((getVersion() == 1) && indexSize > 0) { + extentIndex = IsoTypeReaderVariable.read(in, indexSize); + } + extentOffset = IsoTypeReaderVariable.read(in, offsetSize); + extentLength = IsoTypeReaderVariable.read(in, lengthSize); + } + + public void getContent(ByteBuffer os) { + if ((getVersion() == 1) && indexSize > 0) { + IsoTypeWriterVariable.write(extentIndex, os, indexSize); + } + IsoTypeWriterVariable.write(extentOffset, os, offsetSize); + IsoTypeWriterVariable.write(extentLength, os, lengthSize); + } + + public int getSize() { + return (indexSize > 0 ? indexSize : 0) + offsetSize + lengthSize; + } + + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + Extent extent = (Extent) o; + + if (extentIndex != extent.extentIndex) return false; + if (extentLength != extent.extentLength) return false; + if (extentOffset != extent.extentOffset) return false; + + return true; + } + + @Override + public int hashCode() { + int result = (int) (extentOffset ^ (extentOffset >>> 32)); + result = 31 * result + (int) (extentLength ^ (extentLength >>> 32)); + result = 31 * result + (int) (extentIndex ^ (extentIndex >>> 32)); + return result; + } + + @Override + public String toString() { + final StringBuilder sb = new StringBuilder(); + sb.append("Extent"); + sb.append("{extentOffset=").append(extentOffset); + sb.append(", extentLength=").append(extentLength); + sb.append(", extentIndex=").append(extentIndex); + sb.append('}'); + return sb.toString(); + } + } + + +} |