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
151
152
153
154
155
156
157
158
159
160
161
162
163
|
/*
* Copyright (C) 2009 The Android Open Source Project
*
* 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.
*/
#ifndef SAMPLE_TABLE_H_
#define SAMPLE_TABLE_H_
#include <sys/types.h>
#include <stdint.h>
#include <media/stagefright/MediaErrors.h>
#include <utils/RefBase.h>
#include <utils/threads.h>
namespace android {
class DataSource;
struct SampleIterator;
class SampleTable : public RefBase {
public:
SampleTable(const sp<DataSource> &source);
bool isValid() const;
// type can be 'stco' or 'co64'.
status_t setChunkOffsetParams(
uint32_t type, off64_t data_offset, size_t data_size);
status_t setSampleToChunkParams(off64_t data_offset, size_t data_size);
// type can be 'stsz' or 'stz2'.
status_t setSampleSizeParams(
uint32_t type, off64_t data_offset, size_t data_size);
status_t setTimeToSampleParams(off64_t data_offset, size_t data_size);
status_t setCompositionTimeToSampleParams(
off64_t data_offset, size_t data_size);
status_t setSyncSampleParams(off64_t data_offset, size_t data_size);
////////////////////////////////////////////////////////////////////////////
uint32_t countChunkOffsets() const;
uint32_t countSamples() const;
status_t getMaxSampleSize(size_t *size);
status_t getMetaDataForSample(
uint32_t sampleIndex,
off64_t *offset,
size_t *size,
uint32_t *compositionTime,
bool *isSyncSample = NULL,
uint32_t *sampleDuration = NULL);
enum {
kFlagBefore,
kFlagAfter,
kFlagClosest
};
status_t findSampleAtTime(
uint64_t req_time, uint64_t scale_num, uint64_t scale_den,
uint32_t *sample_index, uint32_t flags);
status_t findSyncSampleNear(
uint32_t start_sample_index, uint32_t *sample_index,
uint32_t flags);
status_t findThumbnailSample(uint32_t *sample_index);
protected:
~SampleTable();
private:
struct CompositionDeltaLookup;
static const uint32_t kChunkOffsetType32;
static const uint32_t kChunkOffsetType64;
static const uint32_t kSampleSizeType32;
static const uint32_t kSampleSizeTypeCompact;
sp<DataSource> mDataSource;
Mutex mLock;
off64_t mChunkOffsetOffset;
uint32_t mChunkOffsetType;
uint32_t mNumChunkOffsets;
off64_t mSampleToChunkOffset;
uint32_t mNumSampleToChunkOffsets;
off64_t mSampleSizeOffset;
uint32_t mSampleSizeFieldSize;
uint32_t mDefaultSampleSize;
uint32_t mNumSampleSizes;
uint32_t mTimeToSampleCount;
uint32_t *mTimeToSample;
struct SampleTimeEntry {
uint32_t mSampleIndex;
uint32_t mCompositionTime;
};
SampleTimeEntry *mSampleTimeEntries;
uint32_t *mCompositionTimeDeltaEntries;
size_t mNumCompositionTimeDeltaEntries;
CompositionDeltaLookup *mCompositionDeltaLookup;
off64_t mSyncSampleOffset;
uint32_t mNumSyncSamples;
uint32_t *mSyncSamples;
size_t mLastSyncSampleIndex;
SampleIterator *mSampleIterator;
struct SampleToChunkEntry {
uint32_t startChunk;
uint32_t samplesPerChunk;
uint32_t chunkDesc;
};
SampleToChunkEntry *mSampleToChunkEntries;
friend struct SampleIterator;
// normally we don't round
inline uint64_t getSampleTime(
size_t sample_index, uint64_t scale_num, uint64_t scale_den) const {
return (sample_index < (size_t)mNumSampleSizes && mSampleTimeEntries != NULL
&& scale_den != 0)
? (mSampleTimeEntries[sample_index].mCompositionTime * scale_num) / scale_den : 0;
}
status_t getSampleSize_l(uint32_t sample_index, size_t *sample_size);
uint32_t getCompositionTimeOffset(uint32_t sampleIndex);
static int CompareIncreasingTime(const void *, const void *);
void buildSampleEntriesTable();
SampleTable(const SampleTable &);
SampleTable &operator=(const SampleTable &);
};
} // namespace android
#endif // SAMPLE_TABLE_H_
|
