1 files changed, 207 insertions, 0 deletions
diff --git a/isoparser/src/main/java/com/coremedia/iso/boxes/fragment/.svn/text-base/SampleFlags.java.svn-base b/isoparser/src/main/java/com/coremedia/iso/boxes/fragment/.svn/text-base/SampleFlags.java.svn-base
new file mode 100644
index 0000000..6caaf1e
--- /dev/null
+++ b/isoparser/src/main/java/com/coremedia/iso/boxes/fragment/.svn/text-base/SampleFlags.java.svn-base
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2009 castLabs GmbH, Berlin
+ *
+ * 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.fragment;
+
+import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitReaderBuffer;
+import com.googlecode.mp4parser.boxes.mp4.objectdescriptors.BitWriterBuffer;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+/**
+ * bit(6) reserved=0;
+ * unsigned int(2) sample_depends_on;
+ * unsigned int(2) sample_is_depended_on;
+ * unsigned int(2) sample_has_redundancy;
+ * bit(3) sample_padding_value;
+ * bit(1) sample_is_difference_sample;
+ * // i.e. when 1 signals a non-key or non-sync sample
+ * unsigned int(16) sample_degradation_priority;
+ */
+public class SampleFlags {
+    private int reserved;
+    private int sampleDependsOn;
+    private int sampleIsDependedOn;
+    private int sampleHasRedundancy;
+    private int samplePaddingValue;
+    private boolean sampleIsDifferenceSample;
+    private int sampleDegradationPriority;
+
+    public SampleFlags() {
+
+    }
+
+    public SampleFlags(ByteBuffer bb) {
+        BitReaderBuffer brb = new BitReaderBuffer(bb);
+        reserved = brb.readBits(6);
+        sampleDependsOn = brb.readBits(2);
+        sampleIsDependedOn = brb.readBits(2);
+        sampleHasRedundancy = brb.readBits(2);
+        samplePaddingValue = brb.readBits(3);
+        sampleIsDifferenceSample = brb.readBits(1) == 1;
+        sampleDegradationPriority = brb.readBits(16);
+    }
+
+
+    public void getContent(ByteBuffer os) {
+        BitWriterBuffer bitWriterBuffer = new BitWriterBuffer(os);
+        bitWriterBuffer.writeBits(reserved, 6);
+        bitWriterBuffer.writeBits(sampleDependsOn, 2);
+        bitWriterBuffer.writeBits(sampleIsDependedOn, 2);
+        bitWriterBuffer.writeBits(sampleHasRedundancy, 2);
+        bitWriterBuffer.writeBits(samplePaddingValue, 3);
+        bitWriterBuffer.writeBits(this.sampleIsDifferenceSample ? 1 : 0, 1);
+        bitWriterBuffer.writeBits(sampleDegradationPriority, 16);
+    }
+
+    public int getReserved() {
+        return reserved;
+    }
+
+    public void setReserved(int reserved) {
+        this.reserved = reserved;
+    }
+
+    /**
+     * @see #setSampleDependsOn(int)
+     */
+    public int getSampleDependsOn() {
+        return sampleDependsOn;
+    }
+
+    /**
+     * sample_depends_on takes one of the following four values:
+     * <pre>
+     * 0: the dependency of this sample is unknown;
+     * 1: this sample does depend on others (not an I picture);
+     * 2: this sample does not depend on others (I picture);
+     * 3: reserved
+     * </pre>
+     *
+     */
+    public void setSampleDependsOn(int sampleDependsOn) {
+        this.sampleDependsOn = sampleDependsOn;
+    }
+
+    /**
+     * @see #setSampleIsDependedOn(int)
+     */
+    public int getSampleIsDependedOn() {
+        return sampleIsDependedOn;
+    }
+
+    /**
+     * sample_is_depended_on takes one of the following four values:
+     * <pre>
+     * 0: the dependency of other samples on this sample is unknown;
+     * 1: other samples may depend on this one (not disposable);
+     * 2: no other sample depends on this one (disposable);
+     * 3: reserved
+     * </pre>
+     *
+     */
+    public void setSampleIsDependedOn(int sampleIsDependedOn) {
+        this.sampleIsDependedOn = sampleIsDependedOn;
+    }
+
+    /**
+     * @see #setSampleHasRedundancy(int)
+     */
+    public int getSampleHasRedundancy() {
+        return sampleHasRedundancy;
+    }
+
+    /**
+     * sample_has_redundancy takes one of the following four values:
+     * <pre>
+     * 0: it is unknown whether there is redundant coding in this sample;
+     * 1: there is redundant coding in this sample;
+     * 2: there is no redundant coding in this sample;
+     * 3: reserved
+     * </pre>
+     */
+    public void setSampleHasRedundancy(int sampleHasRedundancy) {
+        this.sampleHasRedundancy = sampleHasRedundancy;
+    }
+
+    public int getSamplePaddingValue() {
+        return samplePaddingValue;
+    }
+
+    public void setSamplePaddingValue(int samplePaddingValue) {
+        this.samplePaddingValue = samplePaddingValue;
+    }
+
+    public boolean isSampleIsDifferenceSample() {
+        return sampleIsDifferenceSample;
+    }
+
+
+    public void setSampleIsDifferenceSample(boolean sampleIsDifferenceSample) {
+        this.sampleIsDifferenceSample = sampleIsDifferenceSample;
+    }
+
+    public int getSampleDegradationPriority() {
+        return sampleDegradationPriority;
+    }
+
+    public void setSampleDegradationPriority(int sampleDegradationPriority) {
+        this.sampleDegradationPriority = sampleDegradationPriority;
+    }
+
+    @Override
+    public String toString() {
+        return "SampleFlags{" +
+                "reserved=" + reserved +
+                ", sampleDependsOn=" + sampleDependsOn +
+                ", sampleHasRedundancy=" + sampleHasRedundancy +
+                ", samplePaddingValue=" + samplePaddingValue +
+                ", sampleIsDifferenceSample=" + sampleIsDifferenceSample +
+                ", sampleDegradationPriority=" + sampleDegradationPriority +
+                '}';
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        SampleFlags that = (SampleFlags) o;
+
+        if (reserved != that.reserved) return false;
+        if (sampleDegradationPriority != that.sampleDegradationPriority) return false;
+        if (sampleDependsOn != that.sampleDependsOn) return false;
+        if (sampleHasRedundancy != that.sampleHasRedundancy) return false;
+        if (sampleIsDependedOn != that.sampleIsDependedOn) return false;
+        if (sampleIsDifferenceSample != that.sampleIsDifferenceSample) return false;
+        if (samplePaddingValue != that.samplePaddingValue) return false;
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = reserved;
+        result = 31 * result + sampleDependsOn;
+        result = 31 * result + sampleIsDependedOn;
+        result = 31 * result + sampleHasRedundancy;
+        result = 31 * result + samplePaddingValue;
+        result = 31 * result + (sampleIsDifferenceSample ? 1 : 0);
+        result = 31 * result + sampleDegradationPriority;
+        return result;
+    }
+}