diff options
Diffstat (limited to 'isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn')
10 files changed, 1340 insertions, 0 deletions
diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/all-wcprops b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/all-wcprops new file mode 100644 index 0000000..b39616d --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/all-wcprops @@ -0,0 +1,47 @@ +K 25 +svn:wc:ra_dav:version-url +V 78 +/svn/!svn/ver/770/trunk/isoparser/src/main/java/com/googlecode/mp4parser/boxes +END +mp4-boxes.zip +K 25 +svn:wc:ra_dav:version-url +V 92 +/svn/!svn/ver/377/trunk/isoparser/src/main/java/com/googlecode/mp4parser/boxes/mp4-boxes.zip +END +AC3SpecificBox.java +K 25 +svn:wc:ra_dav:version-url +V 98 +/svn/!svn/ver/507/trunk/isoparser/src/main/java/com/googlecode/mp4parser/boxes/AC3SpecificBox.java +END +MLPSpecificBox.java +K 25 +svn:wc:ra_dav:version-url +V 98 +/svn/!svn/ver/507/trunk/isoparser/src/main/java/com/googlecode/mp4parser/boxes/MLPSpecificBox.java +END +DTSSpecificBox.java +K 25 +svn:wc:ra_dav:version-url +V 98 +/svn/!svn/ver/507/trunk/isoparser/src/main/java/com/googlecode/mp4parser/boxes/DTSSpecificBox.java +END +EC3SpecificBox.java +K 25 +svn:wc:ra_dav:version-url +V 98 +/svn/!svn/ver/755/trunk/isoparser/src/main/java/com/googlecode/mp4parser/boxes/EC3SpecificBox.java +END +AbstractSampleEncryptionBox.java +K 25 +svn:wc:ra_dav:version-url +V 111 +/svn/!svn/ver/744/trunk/isoparser/src/main/java/com/googlecode/mp4parser/boxes/AbstractSampleEncryptionBox.java +END +AbstractTrackEncryptionBox.java +K 25 +svn:wc:ra_dav:version-url +V 110 +/svn/!svn/ver/507/trunk/isoparser/src/main/java/com/googlecode/mp4parser/boxes/AbstractTrackEncryptionBox.java +END diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/entries b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/entries new file mode 100644 index 0000000..46c357c --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/entries @@ -0,0 +1,293 @@ +10 + +dir +778 +http://mp4parser.googlecode.com/svn/trunk/isoparser/src/main/java/com/googlecode/mp4parser/boxes +http://mp4parser.googlecode.com/svn + + + +2012-08-31T05:20:57.236953Z +770 +michael.stattmann@gmail.com + + + + + + + + + + + + + + +7decde4b-c250-0410-a0da-51896bc88be6 + +mp4-boxes.zip +file + + + + +2012-09-14T17:27:51.307230Z +03585a21ffb96d2fec7af185e1a9d11b +2012-03-05T23:28:24.666173Z +377 +Sebastian.Annies@gmail.com +has-props + + + + + + + + + + + + + + + + + + + + +62700 + +threegpp26244 +dir + +threegpp26245 +dir + +basemediaformat +dir + +piff +dir + +MLPSpecificBox.java +file + + + + +2012-09-14T17:27:51.307230Z +f98e12a419f1111e27ea55eca285239b +2012-04-21T22:05:38.425329Z +507 +Sebastian.Annies@gmail.com + + + + + + + + + + + + + + + + + + + + + +1868 + +DTSSpecificBox.java +file + + + + +2012-09-14T17:27:51.307230Z +7e647845ba17be37607c41420f886df0 +2012-04-21T22:05:38.425329Z +507 +Sebastian.Annies@gmail.com + + + + + + + + + + + + + + + + + + + + + +5730 + +AbstractTrackEncryptionBox.java +file + + + + +2012-09-14T17:27:51.307230Z +4621f8e06000ce397b5aae869fce1857 +2012-04-21T22:05:38.425329Z +507 +Sebastian.Annies@gmail.com + + + + + + + + + + + + + + + + + + + + + +2588 + +mp4 +dir + +apple +dir + +AC3SpecificBox.java +file + + + + +2012-09-14T17:27:51.307230Z +3f4c28d22ec46abb5263d756387a4d5f +2012-04-21T22:05:38.425329Z +507 +Sebastian.Annies@gmail.com + + + + + + + + + + + + + + + + + + + + + +2661 + +cenc +dir + +EC3SpecificBox.java +file + + + + +2012-09-14T17:27:51.307230Z +80bcdd2db3972a22acdfa12a536dd1a5 +2012-08-17T01:13:17.213046Z +755 +michael.stattmann@gmail.com + + + + + + + + + + + + + + + + + + + + + +3860 + +AbstractSampleEncryptionBox.java +file + + + + +2012-09-14T17:27:51.307230Z +b729f787e78562982c5f5cf998c58e06 +2012-08-14T13:54:34.186978Z +744 +Sebastian.Annies@gmail.com + + + + + + + + + + + + + + + + + + + + + +10292 + +ultraviolet +dir + +adobe +dir + diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/prop-base/mp4-boxes.zip.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/prop-base/mp4-boxes.zip.svn-base new file mode 100644 index 0000000..5e9587e --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/prop-base/mp4-boxes.zip.svn-base @@ -0,0 +1,5 @@ +K 13 +svn:mime-type +V 24 +application/octet-stream +END diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/AC3SpecificBox.java.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/AC3SpecificBox.java.svn-base new file mode 100644 index 0000000..a3006cd --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/AC3SpecificBox.java.svn-base @@ -0,0 +1,119 @@ +package com.googlecode.mp4parser.boxes; + +import com.googlecode.mp4parser.AbstractBox; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitReaderBuffer; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitWriterBuffer; + +import java.nio.ByteBuffer; + +public class AC3SpecificBox extends AbstractBox { + int fscod; + int bsid; + int bsmod; + int acmod; + int lfeon; + int bitRateCode; + int reserved; + + public AC3SpecificBox() { + super("dac3"); + } + + @Override + protected long getContentSize() { + return 3; + } + + @Override + public void _parseDetails(ByteBuffer content) { + BitReaderBuffer brb = new BitReaderBuffer(content); + fscod = brb.readBits(2); + bsid = brb.readBits(5); + bsmod = brb.readBits(3); + acmod = brb.readBits(3); + lfeon = brb.readBits(1); + bitRateCode = brb.readBits(5); + reserved = brb.readBits(5); + } + + @Override + protected void getContent(ByteBuffer byteBuffer) { + BitWriterBuffer bwb = new BitWriterBuffer(byteBuffer); + bwb.writeBits(fscod, 2); + bwb.writeBits(bsid, 5); + bwb.writeBits(bsmod, 3); + bwb.writeBits(acmod, 3); + bwb.writeBits(lfeon, 1); + bwb.writeBits(bitRateCode, 5); + bwb.writeBits(reserved, 5); + } + + public int getFscod() { + return fscod; + } + + public void setFscod(int fscod) { + this.fscod = fscod; + } + + public int getBsid() { + return bsid; + } + + public void setBsid(int bsid) { + this.bsid = bsid; + } + + public int getBsmod() { + return bsmod; + } + + public void setBsmod(int bsmod) { + this.bsmod = bsmod; + } + + public int getAcmod() { + return acmod; + } + + public void setAcmod(int acmod) { + this.acmod = acmod; + } + + public int getLfeon() { + return lfeon; + } + + public void setLfeon(int lfeon) { + this.lfeon = lfeon; + } + + public int getBitRateCode() { + return bitRateCode; + } + + public void setBitRateCode(int bitRateCode) { + this.bitRateCode = bitRateCode; + } + + public int getReserved() { + return reserved; + } + + public void setReserved(int reserved) { + this.reserved = reserved; + } + + @Override + public String toString() { + return "AC3SpecificBox{" + + "fscod=" + fscod + + ", bsid=" + bsid + + ", bsmod=" + bsmod + + ", acmod=" + acmod + + ", lfeon=" + lfeon + + ", bitRateCode=" + bitRateCode + + ", reserved=" + reserved + + '}'; + } +} diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/AbstractSampleEncryptionBox.java.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/AbstractSampleEncryptionBox.java.svn-base new file mode 100644 index 0000000..7ac4bba --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/AbstractSampleEncryptionBox.java.svn-base @@ -0,0 +1,350 @@ +package com.googlecode.mp4parser.boxes; + +import com.coremedia.iso.Hex; +import com.coremedia.iso.IsoTypeReader; +import com.coremedia.iso.IsoTypeWriter; +import com.coremedia.iso.boxes.Box; +import com.coremedia.iso.boxes.TrackHeaderBox; +import com.coremedia.iso.boxes.fragment.TrackFragmentHeaderBox; +import com.googlecode.mp4parser.AbstractFullBox; +import com.googlecode.mp4parser.boxes.basemediaformat.TrackEncryptionBox; +import com.googlecode.mp4parser.util.Path; + +import java.io.IOException; +import java.math.BigInteger; +import java.nio.ByteBuffer; +import java.nio.channels.WritableByteChannel; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedList; +import java.util.List; + + +public abstract class AbstractSampleEncryptionBox extends AbstractFullBox { + int algorithmId = -1; + int ivSize = -1; + byte[] kid = new byte[]{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; + List<Entry> entries = new LinkedList<Entry>(); + + protected AbstractSampleEncryptionBox(String type) { + super(type); + } + + public int getOffsetToFirstIV() { + int offset = (getSize() > (1l << 32) ? 16 : 8); + offset += isOverrideTrackEncryptionBoxParameters() ? 20 : 0; + offset += 4; //num entries + return offset; + } + + @Override + public void _parseDetails(ByteBuffer content) { + parseVersionAndFlags(content); + int useThisIvSize = -1; + if ((getFlags() & 0x1) > 0) { + algorithmId = IsoTypeReader.readUInt24(content); + ivSize = IsoTypeReader.readUInt8(content); + useThisIvSize = ivSize; + kid = new byte[16]; + content.get(kid); + } else { + List<Box> tkhds = Path.getPaths(this, "/moov[0]/trak/tkhd"); + for (Box tkhd : tkhds) { + if (((TrackHeaderBox) tkhd).getTrackId() == this.getParent().getBoxes(TrackFragmentHeaderBox.class).get(0).getTrackId()) { + AbstractTrackEncryptionBox tenc = (AbstractTrackEncryptionBox) Path.getPath(tkhd, "../mdia[0]/minf[0]/stbl[0]/stsd[0]/enc.[0]/sinf[0]/schi[0]/tenc[0]"); + if (tenc == null) { + tenc = (AbstractTrackEncryptionBox) Path.getPath(tkhd, "../mdia[0]/minf[0]/stbl[0]/stsd[0]/enc.[0]/sinf[0]/schi[0]/uuid[0]"); + } + useThisIvSize = tenc.getDefaultIvSize(); + } + } + } + long numOfEntries = IsoTypeReader.readUInt32(content); + + while (numOfEntries-- > 0) { + Entry e = new Entry(); + e.iv = new byte[useThisIvSize < 0 ? 8 : useThisIvSize]; // default to 8 + content.get(e.iv); + if ((getFlags() & 0x2) > 0) { + int numOfPairs = IsoTypeReader.readUInt16(content); + e.pairs = new LinkedList<Entry.Pair>(); + while (numOfPairs-- > 0) { + e.pairs.add(e.createPair(IsoTypeReader.readUInt16(content), IsoTypeReader.readUInt32(content))); + } + } + entries.add(e); + + } + } + + + public int getSampleCount() { + return entries.size(); + } + + public List<Entry> getEntries() { + return entries; + } + + public void setEntries(List<Entry> entries) { + this.entries = entries; + } + + public int getAlgorithmId() { + return algorithmId; + } + + public void setAlgorithmId(int algorithmId) { + this.algorithmId = algorithmId; + } + + public int getIvSize() { + return ivSize; + } + + public void setIvSize(int ivSize) { + this.ivSize = ivSize; + } + + public byte[] getKid() { + return kid; + } + + public void setKid(byte[] kid) { + this.kid = kid; + } + + + public boolean isSubSampleEncryption() { + return (getFlags() & 0x2) > 0; + } + + public boolean isOverrideTrackEncryptionBoxParameters() { + return (getFlags() & 0x1) > 0; + } + + public void setSubSampleEncryption(boolean b) { + if (b) { + setFlags(getFlags() | 0x2); + } else { + setFlags(getFlags() & (0xffffff ^ 0x2)); + } + } + + public void setOverrideTrackEncryptionBoxParameters(boolean b) { + if (b) { + setFlags(getFlags() | 0x1); + } else { + setFlags(getFlags() & (0xffffff ^ 0x1)); + } + } + + + @Override + protected void getContent(ByteBuffer byteBuffer) { + writeVersionAndFlags(byteBuffer); + if (isOverrideTrackEncryptionBoxParameters()) { + IsoTypeWriter.writeUInt24(byteBuffer, algorithmId); + IsoTypeWriter.writeUInt8(byteBuffer, ivSize); + byteBuffer.put(kid); + } + IsoTypeWriter.writeUInt32(byteBuffer, entries.size()); + for (Entry entry : entries) { + if (isOverrideTrackEncryptionBoxParameters()) { + byte[] ivFull = new byte[ivSize]; + System.arraycopy(entry.iv, 0, ivFull, ivSize - entry.iv.length, entry.iv.length); + byteBuffer.put(ivFull); + } else { + // just put the iv - i don't know any better + byteBuffer.put(entry.iv); + } + if (isSubSampleEncryption()) { + IsoTypeWriter.writeUInt16(byteBuffer, entry.pairs.size()); + for (Entry.Pair pair : entry.pairs) { + IsoTypeWriter.writeUInt16(byteBuffer, pair.clear); + IsoTypeWriter.writeUInt32(byteBuffer, pair.encrypted); + } + } + } + } + + @Override + protected long getContentSize() { + long contentSize = 4; + if (isOverrideTrackEncryptionBoxParameters()) { + contentSize += 4; + contentSize += kid.length; + } + contentSize += 4; + for (Entry entry : entries) { + contentSize += entry.getSize(); + } + return contentSize; + } + + @Override + public void getBox(WritableByteChannel os) throws IOException { + super.getBox(os); + } + + public Entry createEntry() { + return new Entry(); + } + + public class Entry { + public byte[] iv; + public List<Pair> pairs = new LinkedList<Pair>(); + + public int getSize() { + int size = 0; + if (isOverrideTrackEncryptionBoxParameters()) { + size = ivSize; + } else { + size = iv.length; + } + + + if (isSubSampleEncryption()) { + size += 2; + for (Entry.Pair pair : pairs) { + size += 6; + } + } + return size; + } + + public Pair createPair(int clear, long encrypted) { + return new Pair(clear, encrypted); + } + + + public class Pair { + public int clear; + public long encrypted; + + public Pair(int clear, long encrypted) { + this.clear = clear; + this.encrypted = encrypted; + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + Pair pair = (Pair) o; + + if (clear != pair.clear) { + return false; + } + if (encrypted != pair.encrypted) { + return false; + } + + return true; + } + + @Override + public int hashCode() { + int result = clear; + result = 31 * result + (int) (encrypted ^ (encrypted >>> 32)); + return result; + } + + @Override + public String toString() { + return "clr:" + clear + " enc:" + encrypted; + } + } + + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + Entry entry = (Entry) o; + + if (!new BigInteger(iv).equals(new BigInteger(entry.iv))) { + return false; + } + if (pairs != null ? !pairs.equals(entry.pairs) : entry.pairs != null) { + return false; + } + + return true; + } + + @Override + public int hashCode() { + int result = iv != null ? Arrays.hashCode(iv) : 0; + result = 31 * result + (pairs != null ? pairs.hashCode() : 0); + return result; + } + + @Override + public String toString() { + return "Entry{" + + "iv=" + Hex.encodeHex(iv) + + ", pairs=" + pairs + + '}'; + } + } + + @Override + public boolean equals(Object o) { + if (this == o) { + return true; + } + if (o == null || getClass() != o.getClass()) { + return false; + } + + AbstractSampleEncryptionBox that = (AbstractSampleEncryptionBox) o; + + if (algorithmId != that.algorithmId) { + return false; + } + if (ivSize != that.ivSize) { + return false; + } + if (entries != null ? !entries.equals(that.entries) : that.entries != null) { + return false; + } + if (!Arrays.equals(kid, that.kid)) { + return false; + } + + return true; + } + + @Override + public int hashCode() { + int result = algorithmId; + result = 31 * result + ivSize; + result = 31 * result + (kid != null ? Arrays.hashCode(kid) : 0); + result = 31 * result + (entries != null ? entries.hashCode() : 0); + return result; + } + + public List<Short> getEntrySizes() { + List<Short> entrySizes = new ArrayList<Short>(entries.size()); + for (Entry entry : entries) { + short size = (short) entry.iv.length; + if (isSubSampleEncryption()) { + size += 2; //numPairs + size += entry.pairs.size() * 6; + } + entrySizes.add(size); + } + return entrySizes; + } +} diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/AbstractTrackEncryptionBox.java.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/AbstractTrackEncryptionBox.java.svn-base new file mode 100644 index 0000000..fe35fde --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/AbstractTrackEncryptionBox.java.svn-base @@ -0,0 +1,93 @@ +package com.googlecode.mp4parser.boxes; + +import com.coremedia.iso.IsoTypeReader; +import com.coremedia.iso.IsoTypeWriter; +import com.googlecode.mp4parser.AbstractFullBox; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.Arrays; +import java.util.UUID; + +/** + * + */ +public abstract class AbstractTrackEncryptionBox extends AbstractFullBox { + int defaultAlgorithmId; + int defaultIvSize; + byte[] default_KID; + + protected AbstractTrackEncryptionBox(String type) { + super(type); + } + + public int getDefaultAlgorithmId() { + return defaultAlgorithmId; + } + + public void setDefaultAlgorithmId(int defaultAlgorithmId) { + this.defaultAlgorithmId = defaultAlgorithmId; + } + + public int getDefaultIvSize() { + return defaultIvSize; + } + + public void setDefaultIvSize(int defaultIvSize) { + this.defaultIvSize = defaultIvSize; + } + + public String getDefault_KID() { + ByteBuffer b = ByteBuffer.wrap(default_KID); + b.order(ByteOrder.BIG_ENDIAN); + return new UUID(b.getLong(), b.getLong()).toString(); + } + + public void setDefault_KID(byte[] default_KID) { + this.default_KID = default_KID; + } + + @Override + public void _parseDetails(ByteBuffer content) { + parseVersionAndFlags(content); + defaultAlgorithmId = IsoTypeReader.readUInt24(content); + defaultIvSize = IsoTypeReader.readUInt8(content); + default_KID = new byte[16]; + content.get(default_KID); + } + + @Override + protected void getContent(ByteBuffer byteBuffer) { + writeVersionAndFlags(byteBuffer); + IsoTypeWriter.writeUInt24(byteBuffer, defaultAlgorithmId); + IsoTypeWriter.writeUInt8(byteBuffer, defaultIvSize); + byteBuffer.put(default_KID); + } + + @Override + protected long getContentSize() { + return 24; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + AbstractTrackEncryptionBox that = (AbstractTrackEncryptionBox) o; + + if (defaultAlgorithmId != that.defaultAlgorithmId) return false; + if (defaultIvSize != that.defaultIvSize) return false; + if (!Arrays.equals(default_KID, that.default_KID)) return false; + + return true; + } + + @Override + public int hashCode() { + int result = defaultAlgorithmId; + result = 31 * result + defaultIvSize; + result = 31 * result + (default_KID != null ? Arrays.hashCode(default_KID) : 0); + return result; + } +} diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/DTSSpecificBox.java.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/DTSSpecificBox.java.svn-base new file mode 100644 index 0000000..a4cb346 --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/DTSSpecificBox.java.svn-base @@ -0,0 +1,217 @@ +package com.googlecode.mp4parser.boxes; + +import com.coremedia.iso.IsoTypeReader; +import com.coremedia.iso.IsoTypeWriter; +import com.googlecode.mp4parser.AbstractBox; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitReaderBuffer; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitWriterBuffer; + +import java.nio.ByteBuffer; + +/** + * Created by IntelliJ IDEA. + * User: magnus + * Date: 2012-03-09 + * Time: 16:11 + * To change this template use File | Settings | File Templates. + */ +public class DTSSpecificBox extends AbstractBox { + + long DTSSamplingFrequency; + long maxBitRate; + long avgBitRate; + int pcmSampleDepth; + int frameDuration; + int streamConstruction; + int coreLFEPresent; + int coreLayout; + int coreSize; + int stereoDownmix; + int representationType; + int channelLayout; + int multiAssetFlag; + int LBRDurationMod; + int reservedBoxPresent; + int reserved; + + public DTSSpecificBox() { + super("ddts"); + } + + @Override + protected long getContentSize() { + return 20; + } + + @Override + public void _parseDetails(ByteBuffer content) { + DTSSamplingFrequency = IsoTypeReader.readUInt32(content); + maxBitRate = IsoTypeReader.readUInt32(content); + avgBitRate = IsoTypeReader.readUInt32(content); + pcmSampleDepth = IsoTypeReader.readUInt8(content); + BitReaderBuffer brb = new BitReaderBuffer(content); + frameDuration = brb.readBits(2); + streamConstruction = brb.readBits(5); + coreLFEPresent = brb.readBits(1); + coreLayout = brb.readBits(6); + coreSize = brb.readBits(14); + stereoDownmix = brb.readBits(1); + representationType = brb.readBits(3); + channelLayout = brb.readBits(16); + multiAssetFlag = brb.readBits(1); + LBRDurationMod = brb.readBits(1); + reservedBoxPresent = brb.readBits(1); + reserved = brb.readBits(5); + + } + + @Override + protected void getContent(ByteBuffer byteBuffer) { + IsoTypeWriter.writeUInt32(byteBuffer, DTSSamplingFrequency); + IsoTypeWriter.writeUInt32(byteBuffer, maxBitRate); + IsoTypeWriter.writeUInt32(byteBuffer, avgBitRate); + IsoTypeWriter.writeUInt8(byteBuffer, pcmSampleDepth); + BitWriterBuffer bwb = new BitWriterBuffer(byteBuffer); + bwb.writeBits(frameDuration, 2); + bwb.writeBits(streamConstruction, 5); + bwb.writeBits(coreLFEPresent, 1); + bwb.writeBits(coreLayout, 6); + bwb.writeBits(coreSize, 14); + bwb.writeBits(stereoDownmix, 1); + bwb.writeBits(representationType, 3); + bwb.writeBits(channelLayout, 16); + bwb.writeBits(multiAssetFlag, 1); + bwb.writeBits(LBRDurationMod, 1); + bwb.writeBits(reservedBoxPresent, 1); + bwb.writeBits(reserved, 5); + + } + + public long getAvgBitRate() { + return avgBitRate; + } + + public void setAvgBitRate(long avgBitRate) { + this.avgBitRate = avgBitRate; + } + + public long getDTSSamplingFrequency() { + return DTSSamplingFrequency; + } + + public void setDTSSamplingFrequency(long DTSSamplingFrequency) { + this.DTSSamplingFrequency = DTSSamplingFrequency; + } + + public long getMaxBitRate() { + return maxBitRate; + } + + public void setMaxBitRate(long maxBitRate) { + this.maxBitRate = maxBitRate; + } + + public int getPcmSampleDepth() { + return pcmSampleDepth; + } + + public void setPcmSampleDepth(int pcmSampleDepth) { + this.pcmSampleDepth = pcmSampleDepth; + } + + public int getFrameDuration() { + return frameDuration; + } + + public void setFrameDuration(int frameDuration) { + this.frameDuration = frameDuration; + } + + public int getStreamConstruction() { + return streamConstruction; + } + + public void setStreamConstruction(int streamConstruction) { + this.streamConstruction = streamConstruction; + } + + public int getCoreLFEPresent() { + return coreLFEPresent; + } + + public void setCoreLFEPresent(int coreLFEPresent) { + this.coreLFEPresent = coreLFEPresent; + } + + public int getCoreLayout() { + return coreLayout; + } + + public void setCoreLayout(int coreLayout) { + this.coreLayout = coreLayout; + } + + public int getCoreSize() { + return coreSize; + } + + public void setCoreSize(int coreSize) { + this.coreSize = coreSize; + } + + public int getStereoDownmix() { + return stereoDownmix; + } + + public void setStereoDownmix(int stereoDownmix) { + this.stereoDownmix = stereoDownmix; + } + + public int getRepresentationType() { + return representationType; + } + + public void setRepresentationType(int representationType) { + this.representationType = representationType; + } + + public int getChannelLayout() { + return channelLayout; + } + + public void setChannelLayout(int channelLayout) { + this.channelLayout = channelLayout; + } + + public int getMultiAssetFlag() { + return multiAssetFlag; + } + + public void setMultiAssetFlag(int multiAssetFlag) { + this.multiAssetFlag = multiAssetFlag; + } + + public int getLBRDurationMod() { + return LBRDurationMod; + } + + public void setLBRDurationMod(int LBRDurationMod) { + this.LBRDurationMod = LBRDurationMod; + } + + public int getReserved() { + return reserved; + } + + public void setReserved(int reserved) { + this.reserved = reserved; + } + + public int getReservedBoxPresent() { + return reservedBoxPresent; + } + + public void setReservedBoxPresent(int reservedBoxPresent) { + this.reservedBoxPresent = reservedBoxPresent; + } +} diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/EC3SpecificBox.java.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/EC3SpecificBox.java.svn-base new file mode 100644 index 0000000..412db04 --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/EC3SpecificBox.java.svn-base @@ -0,0 +1,140 @@ +package com.googlecode.mp4parser.boxes; + +import com.googlecode.mp4parser.AbstractBox; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitReaderBuffer; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitWriterBuffer; + +import java.nio.ByteBuffer; +import java.util.LinkedList; +import java.util.List; + +/** + * + */ +public class EC3SpecificBox extends AbstractBox { + List<Entry> entries = new LinkedList<Entry>(); + int dataRate; + int numIndSub; + + public EC3SpecificBox() { + super("dec3"); + } + + @Override + public long getContentSize() { + long size = 2; + for (Entry entry : entries) { + if (entry.num_dep_sub > 0) { + size += 4; + } else { + size += 3; + } + } + return size; + } + + @Override + public void _parseDetails(ByteBuffer content) { + BitReaderBuffer brb = new BitReaderBuffer(content); + dataRate = brb.readBits(13); + numIndSub = brb.readBits(3) + 1; + // This field indicates the number of independent substreams that are present in the Enhanced AC-3 bitstream. The value + // of this field is one less than the number of independent substreams present. + + + for (int i = 0; i < numIndSub; i++) { + Entry e = new Entry(); + e.fscod = brb.readBits(2); + e.bsid = brb.readBits(5); + e.bsmod = brb.readBits(5); + e.acmod = brb.readBits(3); + e.lfeon = brb.readBits(1); + e.reserved = brb.readBits(3); + e.num_dep_sub = brb.readBits(4); + if (e.num_dep_sub > 0) { + e.chan_loc = brb.readBits(9); + } else { + e.reserved2 = brb.readBits(1); + } + entries.add(e); + } + } + + @Override + public void getContent(ByteBuffer byteBuffer) { + BitWriterBuffer bwb = new BitWriterBuffer(byteBuffer); + bwb.writeBits(dataRate, 13); + bwb.writeBits(entries.size() - 1, 3); + for (Entry e : entries) { + bwb.writeBits(e.fscod, 2); + bwb.writeBits(e.bsid, 5); + bwb.writeBits(e.bsmod, 5); + bwb.writeBits(e.acmod, 3); + bwb.writeBits(e.lfeon, 1); + bwb.writeBits(e.reserved, 3); + bwb.writeBits(e.num_dep_sub, 4); + if (e.num_dep_sub > 0) { + bwb.writeBits(e.chan_loc, 9); + } else { + bwb.writeBits(e.reserved2, 1); + } + } + } + + + public List<Entry> getEntries() { + return entries; + } + + public void setEntries(List<Entry> entries) { + this.entries = entries; + } + + public void addEntry(Entry entry) { + this.entries.add(entry); + } + + public int getDataRate() { + return dataRate; + } + + public void setDataRate(int dataRate) { + this.dataRate = dataRate; + } + + public int getNumIndSub() { + return numIndSub; + } + + public void setNumIndSub(int numIndSub) { + this.numIndSub = numIndSub; + } + + public static class Entry { + public int fscod; + public int bsid; + public int bsmod; + public int acmod; + public int lfeon; + public int reserved; + public int num_dep_sub; + public int chan_loc; + public int reserved2; + + + @Override + public String toString() { + return "Entry{" + + "fscod=" + fscod + + ", bsid=" + bsid + + ", bsmod=" + bsmod + + ", acmod=" + acmod + + ", lfeon=" + lfeon + + ", reserved=" + reserved + + ", num_dep_sub=" + num_dep_sub + + ", chan_loc=" + chan_loc + + ", reserved2=" + reserved2 + + '}'; + } + } +} diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/MLPSpecificBox.java.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/MLPSpecificBox.java.svn-base new file mode 100644 index 0000000..fe6f0d8 --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/MLPSpecificBox.java.svn-base @@ -0,0 +1,76 @@ +package com.googlecode.mp4parser.boxes; + +import com.googlecode.mp4parser.AbstractBox; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitReaderBuffer; +import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitWriterBuffer; + +import java.nio.ByteBuffer; + + +public class MLPSpecificBox extends AbstractBox { + + int format_info; + int peak_data_rate; + int reserved; + int reserved2; + + public MLPSpecificBox() { + super("dmlp"); + } + + @Override + protected long getContentSize() { + return 10; + } + + @Override + public void _parseDetails(ByteBuffer content) { + BitReaderBuffer brb = new BitReaderBuffer(content); + format_info = brb.readBits(32); + peak_data_rate = brb.readBits(15); + reserved = brb.readBits(1); + reserved2 = brb.readBits(32); + } + + @Override + protected void getContent(ByteBuffer byteBuffer) { + BitWriterBuffer bwb = new BitWriterBuffer(byteBuffer); + bwb.writeBits(format_info, 32); + bwb.writeBits(peak_data_rate, 15); + bwb.writeBits(reserved, 1); + bwb.writeBits(reserved2, 32); + //To change body of implemented methods use File | Settings | File Templates. + } + + public int getFormat_info() { + return format_info; + } + + public void setFormat_info(int format_info) { + this.format_info = format_info; + } + + public int getPeak_data_rate() { + return peak_data_rate; + } + + public void setPeak_data_rate(int peak_data_rate) { + this.peak_data_rate = peak_data_rate; + } + + public int getReserved() { + return reserved; + } + + public void setReserved(int reserved) { + this.reserved = reserved; + } + + public int getReserved2() { + return reserved2; + } + + public void setReserved2(int reserved2) { + this.reserved2 = reserved2; + } +} diff --git a/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/mp4-boxes.zip.svn-base b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/mp4-boxes.zip.svn-base Binary files differnew file mode 100644 index 0000000..c9bcf8b --- /dev/null +++ b/isoparser/src/main/java/com/googlecode/mp4parser/boxes/.svn/text-base/mp4-boxes.zip.svn-base |