blob: 411bfe91636f5018af5822d03d5e7eba0497de8f (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
package com.coremedia.iso.boxes;
import com.coremedia.iso.IsoTypeReader;
import com.coremedia.iso.IsoTypeWriter;
import com.googlecode.mp4parser.AbstractFullBox;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import static com.googlecode.mp4parser.util.CastUtils.l2i;
/**
* <pre>
* aligned(8) class CompositionOffsetBox
* extends FullBox(‘ctts’, version = 0, 0) {
* unsigned int(32) entry_count;
* int i;
* if (version==0) {
* for (i=0; i < entry_count; i++) {
* unsigned int(32) sample_count;
* unsigned int(32) sample_offset;
* }
* }
* else if (version == 1) {
* for (i=0; i < entry_count; i++) {
* unsigned int(32) sample_count;
* signed int(32) sample_offset;
* }
* }
* }
* </pre>
* <p/>
* This box provides the offset between decoding time and composition time.
* In version 0 of this box the decoding time must be less than the composition time, and
* the offsets are expressed as unsigned numbers such that
* CT(n) = DT(n) + CTTS(n) where CTTS(n) is the (uncompressed) table entry for sample n.
* <p/>
* In version 1 of this box, the composition timeline and the decoding timeline are
* still derived from each other, but the offsets are signed.
* It is recommended that for the computed composition timestamps, there is
* exactly one with the value 0 (zero).
*/
public class CompositionTimeToSample extends AbstractFullBox {
public static final String TYPE = "ctts";
List<Entry> entries = Collections.emptyList();
public CompositionTimeToSample() {
super(TYPE);
}
protected long getContentSize() {
return 8 + 8 * entries.size();
}
public List<Entry> getEntries() {
return entries;
}
public void setEntries(List<Entry> entries) {
this.entries = entries;
}
@Override
public void _parseDetails(ByteBuffer content) {
parseVersionAndFlags(content);
int numberOfEntries = l2i(IsoTypeReader.readUInt32(content));
entries = new ArrayList<Entry>(numberOfEntries);
for (int i = 0; i < numberOfEntries; i++) {
Entry e = new Entry(l2i(IsoTypeReader.readUInt32(content)), content.getInt());
entries.add(e);
}
}
@Override
protected void getContent(ByteBuffer byteBuffer) {
writeVersionAndFlags(byteBuffer);
IsoTypeWriter.writeUInt32(byteBuffer, entries.size());
for (Entry entry : entries) {
IsoTypeWriter.writeUInt32(byteBuffer, entry.getCount());
byteBuffer.putInt(entry.getOffset());
}
}
public static class Entry {
int count;
int offset;
public Entry(int count, int offset) {
this.count = count;
this.offset = offset;
}
public int getCount() {
return count;
}
public int getOffset() {
return offset;
}
public void setCount(int count) {
this.count = count;
}
public void setOffset(int offset) {
this.offset = offset;
}
@Override
public String toString() {
return "Entry{" +
"count=" + count +
", offset=" + offset +
'}';
}
}
/**
* Decompresses the list of entries and returns the list of composition times.
*
* @return decoding time per sample
*/
public static int[] blowupCompositionTimes(List<CompositionTimeToSample.Entry> entries) {
long numOfSamples = 0;
for (CompositionTimeToSample.Entry entry : entries) {
numOfSamples += entry.getCount();
}
assert numOfSamples <= Integer.MAX_VALUE;
int[] decodingTime = new int[(int) numOfSamples];
int current = 0;
for (CompositionTimeToSample.Entry entry : entries) {
for (int i = 0; i < entry.getCount(); i++) {
decodingTime[current++] = entry.getOffset();
}
}
return decodingTime;
}
}
|
