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
|
/*
* Copyright (C) 2018 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 org.mozilla.thirdparty.com.google.android.exoplayer2.source;
import android.net.Uri;
import androidx.annotation.Nullable;
import org.mozilla.thirdparty.com.google.android.exoplayer2.C;
import org.mozilla.thirdparty.com.google.android.exoplayer2.upstream.DataSource;
import org.mozilla.thirdparty.com.google.android.exoplayer2.upstream.DataSpec;
import org.mozilla.thirdparty.com.google.android.exoplayer2.upstream.TransferListener;
import org.mozilla.thirdparty.com.google.android.exoplayer2.util.Assertions;
import org.mozilla.thirdparty.com.google.android.exoplayer2.util.ParsableByteArray;
import java.io.IOException;
import java.util.List;
import java.util.Map;
/**
* Splits ICY stream metadata out from a stream.
*
* <p>Note: {@link #open(DataSpec)} and {@link #close()} are not supported. This implementation is
* intended to wrap upstream {@link DataSource} instances that are opened and closed directly.
*/
/* package */ final class IcyDataSource implements DataSource {
public interface Listener {
/**
* Called when ICY stream metadata has been split from the stream.
*
* @param metadata The stream metadata in binary form.
*/
void onIcyMetadata(ParsableByteArray metadata);
}
private final DataSource upstream;
private final int metadataIntervalBytes;
private final Listener listener;
private final byte[] metadataLengthByteHolder;
private int bytesUntilMetadata;
/**
* @param upstream The upstream {@link DataSource}.
* @param metadataIntervalBytes The interval between ICY stream metadata, in bytes.
* @param listener A listener to which stream metadata is delivered.
*/
public IcyDataSource(DataSource upstream, int metadataIntervalBytes, Listener listener) {
Assertions.checkArgument(metadataIntervalBytes > 0);
this.upstream = upstream;
this.metadataIntervalBytes = metadataIntervalBytes;
this.listener = listener;
metadataLengthByteHolder = new byte[1];
bytesUntilMetadata = metadataIntervalBytes;
}
@Override
public void addTransferListener(TransferListener transferListener) {
upstream.addTransferListener(transferListener);
}
@Override
public long open(DataSpec dataSpec) throws IOException {
throw new UnsupportedOperationException();
}
@Override
public int read(byte[] buffer, int offset, int readLength) throws IOException {
if (bytesUntilMetadata == 0) {
if (readMetadata()) {
bytesUntilMetadata = metadataIntervalBytes;
} else {
return C.RESULT_END_OF_INPUT;
}
}
int bytesRead = upstream.read(buffer, offset, Math.min(bytesUntilMetadata, readLength));
if (bytesRead != C.RESULT_END_OF_INPUT) {
bytesUntilMetadata -= bytesRead;
}
return bytesRead;
}
@Nullable
@Override
public Uri getUri() {
return upstream.getUri();
}
@Override
public Map<String, List<String>> getResponseHeaders() {
return upstream.getResponseHeaders();
}
@Override
public void close() throws IOException {
throw new UnsupportedOperationException();
}
/**
* Reads an ICY stream metadata block, passing it to {@link #listener} unless the block is empty.
*
* @return True if the block was extracted, including if its length byte indicated a length of
* zero. False if the end of the stream was reached.
* @throws IOException If an error occurs reading from the wrapped {@link DataSource}.
*/
private boolean readMetadata() throws IOException {
int bytesRead = upstream.read(metadataLengthByteHolder, 0, 1);
if (bytesRead == C.RESULT_END_OF_INPUT) {
return false;
}
int metadataLength = (metadataLengthByteHolder[0] & 0xFF) << 4;
if (metadataLength == 0) {
return true;
}
int offset = 0;
int lengthRemaining = metadataLength;
byte[] metadata = new byte[metadataLength];
while (lengthRemaining > 0) {
bytesRead = upstream.read(metadata, offset, lengthRemaining);
if (bytesRead == C.RESULT_END_OF_INPUT) {
return false;
}
offset += bytesRead;
lengthRemaining -= bytesRead;
}
// Discard trailing zero bytes.
while (metadataLength > 0 && metadata[metadataLength - 1] == 0) {
metadataLength--;
}
if (metadataLength > 0) {
listener.onIcyMetadata(new ParsableByteArray(metadata, metadataLength));
}
return true;
}
}
|
