之前分析ExoPlayer的流程是source->buffer，从数据源读取数据到buffer中，在ExoPlayer中是用SampleQueue来保存buffer。下面看下SampleQueue是怎么工作的。
SampleQueue类有个SampleDataQueue变量，读取的数据真正保存在SampleDataQueue中，
/** A queue of media sample data. */
/* package */ class SampleDataQueue {
// References into the linked list of allocations.
private AllocationNode firstAllocationNode;
private AllocationNode readAllocationNode;
private AllocationNode writeAllocationNode;
public SampleDataQueue(Allocator allocator) {
this.allocator = allocator;
allocationLength = allocator.getIndividualAllocationLength();\\64 * 1024
scratch = new ParsableByteArray(INITIAL_SCRATCH_SIZE);
firstAllocationNode = new AllocationNode(/* startPosition= */ 0, allocationLength);
readAllocationNode = firstAllocationNode;
writeAllocationNode = firstAllocationNode;
}
}
SampleDataQueue初始化时先生成一个AllocationNode，每个AllocationNode的大小是allocationLength （64 * 1024），读写指针都指向这个AllocationNode。
先来分析writeAllocationNode 的工作，从数据源读取数据写入writeAllocationNode ，数据源封装在DefaultDataSource,读取数据时调用：
@Override
public int read(byte[] buffer, int offset, int readLength) throws IOException {
return Assertions.checkNotNull(dataSource).read(buffer, offset, readLength);
}
对于mp4文件，dataSource就是FileDataSource，其实最终是通过FileDataSource去读取:
try {
bytesRead = castNonNull(file).read(buffer, offset, (int) min(bytesRemaining, readLength));
} catch (IOException e) {
throw new FileDataSourceException(e);
}
在FileDataSource中，file被定义为RandomAccessFile file。下面看怎么把上面的几个类串起来。
在Mp4Extractor里解析mp4文件，对于Sample调用readSample保存：
private int readSample(ExtractorInput input, PositionHolder positionHolder) throws IOException {
while (sampleBytesWritten < sampleSize) {
int writtenBytes = trackOutput.sampleData(input, sampleSize - sampleBytesWritten, false);
sampleBytesRead += writtenBytes;
sampleBytesWritten += writtenBytes;
sampleCurrentNalBytesRemaining -= writtenBytes;
}
}
trackOutput就是SampleQueue,input就是FileDataSource。SampleQueue又调用SampleDataQueue的sampleData的方法:
public int sampleData(DataReader input, int length, boolean allowEndOfInput) throws IOException {
length = preAppend(length);
int bytesAppended =
input.read(
writeAllocationNode.allocation.data,
writeAllocationNode.translateOffset(totalBytesWritten),
length);
postAppend(bytesAppended);
return bytesAppended;
}
读取数据前先调用preAppend，如果writeAllocationNode没有初始化，就把当前writeAllocationNode初始化，并在队尾添加一个没有初始化的writeAllocationNode：
private int preAppend(int length) {
if (!writeAllocationNode.wasInitialized) {
writeAllocationNode.initialize(
allocator.allocate(),
new AllocationNode(writeAllocationNode.endPosition, allocationLength));
}
return min(length, (int) (writeAllocationNode.endPosition - totalBytesWritten));
}
注意，这里调用initialize，赋值了个Allocation（allocator.allocate()），allocator是DefaultAllocator，分配了64 * 1024的空间给Allocation，看Allocation的定义:
public final class Allocation {
public final byte[] data;
public final int offset;
}
由此可见，读取的数据最终保存在Allocation 的data里。这里还有个细节，每个Allocation 是串起来的，下次有数据读过来时，当前的Allocation 还没填满，这时就要计算偏移量了，计算出在当前Allocation 的哪个位置开始填充，上面的translateOffset就是做这件事:
//absolutePosition是当前读的数据总长度，startPosition是当前Allocation 的起点,减后就得到当前Allocation 要填充的起始位置
public int translateOffset(long absolutePosition) {
return (int) (absolutePosition - startPosition) + allocation.offset;
}
AllocationNode填充完当前读到的数据，调用postAppend来看当前的writeAllocationNode是否填满了，如果填满了，writeAllocationNode指针就走到下一个:
private void postAppend(int length) {
totalBytesWritten += length;
if (totalBytesWritten == writeAllocationNode.endPosition) {
writeAllocationNode = writeAllocationNode.next;
}
}
然后看readAllocationNode的使用，Exoplayer不断循环调用doSomething,会调到MediaCodecRenderer的feedInputBuffer() ，就是读取Sample往MediaCodec解码器的 InputBuffer填充，最终调到readAllocationNode（SampleDataQueue）的readData方法：
private void readData(long absolutePosition, ByteBuffer target, int length) {
advanceReadTo(absolutePosition);
int remaining = length;
while (remaining > 0) {
int toCopy = min(remaining, (int) (readAllocationNode.endPosition - absolutePosition));
Allocation allocation = readAllocationNode.allocation;
target.put(allocation.data, readAllocationNode.translateOffset(absolutePosition), toCopy);
remaining -= toCopy;
absolutePosition += toCopy;
if (absolutePosition == readAllocationNode.endPosition) {
readAllocationNode = readAllocationNode.next;
}
}
}
首先计算起始位置，如果读取位置absolutePosition比当前的readAllocationNode位置大,readAllocationNode就走到下个位置，这部分逻辑在advanceReadTo，然后读取数据到target，target就是MediaCodec的InputBuffer。
最后说明下，SampleQueue其实有两个，一个视频，一个音频，在ProgressiveMediaPeriod里创建：
private TrackOutput prepareTrackOutput(TrackId id) {
SampleQueue trackOutput =
new SampleQueue(
allocator,
/* playbackLooper= */ handler.getLooper(),
drmSessionManager,
drmEventDispatcher);
...............
sampleQueues[trackCount] = trackOutput;
this.sampleQueues = Util.castNonNullTypeArray(sampleQueues);
return trackOutput;
}
因为有音视频两个track，prepareTrackOutput这个方法会被调用两次。这样就分别构建了对应音视频的两个SampleQueue。