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
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/*
* Copyright (C) 2015 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.
*/
package com.android.tv.tuner.exoplayer;
import com.google.android.exoplayer.C;
import com.google.android.exoplayer.MediaFormat;
import com.google.android.exoplayer.MediaFormatHolder;
import com.google.android.exoplayer.SampleHolder;
import com.google.android.exoplayer.SampleSource;
import com.google.android.exoplayer.SampleSource.SampleSourceReader;
import com.google.android.exoplayer.util.Assertions;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/** {@link SampleSource} that extracts sample data using a {@link SampleExtractor}. */
public final class MpegTsSampleSource implements SampleSource, SampleSourceReader {
private static final int TRACK_STATE_DISABLED = 0;
private static final int TRACK_STATE_ENABLED = 1;
private static final int TRACK_STATE_FORMAT_SENT = 2;
private final SampleExtractor mSampleExtractor;
private final List<Integer> mTrackStates = new ArrayList<>();
private final List<Boolean> mPendingDiscontinuities = new ArrayList<>();
private boolean mPrepared;
private IOException mPreparationError;
private int mRemainingReleaseCount;
private long mLastSeekPositionUs;
private long mPendingSeekPositionUs;
/**
* Creates a new sample source that extracts samples using {@code mSampleExtractor}.
*
* @param sampleExtractor a sample extractor for accessing media samples
*/
public MpegTsSampleSource(SampleExtractor sampleExtractor) {
mSampleExtractor = Assertions.checkNotNull(sampleExtractor);
}
@Override
public SampleSourceReader register() {
mRemainingReleaseCount++;
return this;
}
@Override
public boolean prepare(long positionUs) {
if (!mPrepared) {
if (mPreparationError != null) {
return false;
}
try {
if (mSampleExtractor.prepare()) {
int trackCount = mSampleExtractor.getTrackFormats().size();
mTrackStates.clear();
mPendingDiscontinuities.clear();
for (int i = 0; i < trackCount; ++i) {
mTrackStates.add(i, TRACK_STATE_DISABLED);
mPendingDiscontinuities.add(i, false);
}
mPrepared = true;
} else {
return false;
}
} catch (IOException e) {
mPreparationError = e;
return false;
}
}
return true;
}
@Override
public int getTrackCount() {
Assertions.checkState(mPrepared);
return mSampleExtractor.getTrackFormats().size();
}
@Override
public MediaFormat getFormat(int track) {
Assertions.checkState(mPrepared);
return mSampleExtractor.getTrackFormats().get(track);
}
@Override
public void enable(int track, long positionUs) {
Assertions.checkState(mPrepared);
Assertions.checkState(mTrackStates.get(track) == TRACK_STATE_DISABLED);
mTrackStates.set(track, TRACK_STATE_ENABLED);
mSampleExtractor.selectTrack(track);
seekToUsInternal(positionUs, positionUs != 0);
}
@Override
public void disable(int track) {
Assertions.checkState(mPrepared);
Assertions.checkState(mTrackStates.get(track) != TRACK_STATE_DISABLED);
mSampleExtractor.deselectTrack(track);
mPendingDiscontinuities.set(track, false);
mTrackStates.set(track, TRACK_STATE_DISABLED);
}
@Override
public boolean continueBuffering(int track, long positionUs) {
return mSampleExtractor.continueBuffering(positionUs);
}
@Override
public long readDiscontinuity(int track) {
if (mPendingDiscontinuities.get(track)) {
mPendingDiscontinuities.set(track, false);
return mLastSeekPositionUs;
}
return NO_DISCONTINUITY;
}
@Override
public int readData(int track, long positionUs, MediaFormatHolder formatHolder,
SampleHolder sampleHolder) {
Assertions.checkState(mPrepared);
Assertions.checkState(mTrackStates.get(track) != TRACK_STATE_DISABLED);
if (mPendingDiscontinuities.get(track)) {
return NOTHING_READ;
}
if (mTrackStates.get(track) != TRACK_STATE_FORMAT_SENT) {
mSampleExtractor.getTrackMediaFormat(track, formatHolder);
mTrackStates.set(track, TRACK_STATE_FORMAT_SENT);
return FORMAT_READ;
}
mPendingSeekPositionUs = C.UNKNOWN_TIME_US;
return mSampleExtractor.readSample(track, sampleHolder);
}
@Override
public void maybeThrowError() throws IOException {
if (mPreparationError != null) {
throw mPreparationError;
}
if (mSampleExtractor != null) {
mSampleExtractor.maybeThrowError();
}
}
@Override
public void seekToUs(long positionUs) {
Assertions.checkState(mPrepared);
seekToUsInternal(positionUs, false);
}
@Override
public long getBufferedPositionUs() {
Assertions.checkState(mPrepared);
return mSampleExtractor.getBufferedPositionUs();
}
@Override
public void release() {
Assertions.checkState(mRemainingReleaseCount > 0);
if (--mRemainingReleaseCount == 0) {
mSampleExtractor.release();
}
}
private void seekToUsInternal(long positionUs, boolean force) {
// Unless forced, avoid duplicate calls to the underlying extractor's seek method
// in the case that there have been no interleaving calls to readSample.
if (force || mPendingSeekPositionUs != positionUs) {
mLastSeekPositionUs = positionUs;
mPendingSeekPositionUs = positionUs;
mSampleExtractor.seekTo(positionUs);
for (int i = 0; i < mTrackStates.size(); ++i) {
if (mTrackStates.get(i) != TRACK_STATE_DISABLED) {
mPendingDiscontinuities.set(i, true);
}
}
}
}
}
|
