ExoPlayer架构详解与源码分析(7)——SampleQueue

系列文章目录

ExoPlayer架构详解与源码分析(1)——前言
ExoPlayer架构详解与源码分析(2)——Player
ExoPlayer架构详解与源码分析(3)——Timeline
ExoPlayer架构详解与源码分析(4)——整体架构
ExoPlayer架构详解与源码分析(5)——MediaSource
ExoPlayer架构详解与源码分析(6)——MediaPeriod
ExoPlayer架构详解与源码分析(7)——SampleQueue
ExoPlayer架构详解与源码分析(8)——Loader


文章目录

  • 系列文章目录
  • 前言
  • ProgressiveMediaPeriod
  • SampleQueue
  • SampleQueue动态分析
  • SpannedData< SharedSampleMetadata >
  • SampleDataQueue
  • Allocator
  • 总结


前言

ProgressiveMediaPeriod中的SampleQueue部分相对其他部分,结构相对完整独立,没有像加载媒体那部分拆分出很多其他的概念,所以优先了解下SampleQueue。本篇主要解答媒体数据是如何在播放器内部缓存的,以及ExoPlayer是如何保证这些数据稳定高效的读写。

ProgressiveMediaPeriod

先预习下上篇的整体结构,本篇主要分析左半部分的SampleQueue:
在这里插入图片描述

SampleQueue

这是一个保存Sample的队列。MediaoPeriod向外提供的SampleStream其实就是从SampleQueue中读取的数据,一个SampleQueue就对应一个SampleStream。
在这里插入图片描述

SampleQueue主要有3大功能:

  • 管理 通过内部的一个环形Info数组(包含offsets数组、sizes数等sampleData数据)管理SampleDataQueue和SharedSampleMetadata这2个数据源。SampleQueue实际的数据其实是保存在SampleDataQueue和SharedSampleMetadata中的,数据的管理实现在SampleQueue里。
    这部分可以从SampleQueue初始化部分源码看出来:

      private final SampleDataQueue sampleDataQueue;//用于播放的数据
      private final SampleExtrasHolder extrasHolder;
      private final SpannedData<SharedSampleMetadata> sharedSampleMetadata;//Meta数据
      private int capacity;//Info数组的总长度
      private long[] offsets;//每段SampleData的数据偏移量
      private int[] sizes;//每段SampleData的数据大小
      private int[] flags;//每段SampleData flags 数据
      private long[] timesUs;//每段SampleData 时间戳
      private int length;//有效的(没有被释放且已分配的数据)Info数组数据的长度
      private int absoluteFirstIndex;//绝对的开始位置,指向数据段的开始位置,+readPosition就是当前读取的绝对位置
      private int relativeFirstIndex;//一个在Info数据上循环的相对位置
      private int readPosition;//当前的读取位置,这个值是相对relativeFirstIndex的位置偏移量
      protected SampleQueue(
          Allocator allocator,
          @Nullable DrmSessionManager drmSessionManager,
          @Nullable DrmSessionEventListener.EventDispatcher drmEventDispatcher) {
          ...
        sampleDataQueue = new SampleDataQueue(allocator);//内存分配器供SampleDataQueue使用
        extrasHolder = new SampleExtrasHolder();
        capacity = SAMPLE_CAPACITY_INCREMENT;//默认的分段属是1000
    
        sourceIds = new long[capacity];
        offsets = new long[capacity];
        timesUs = new long[capacity];
        flags = new int[capacity];
        sizes = new int[capacity];
        
        sharedSampleMetadata =
            new SpannedData<>(/* removeCallback= */ metadata -> metadata.drmSessionReference.release());
            ...
      }
    

    上面主要是初始化出一个SampleDataQueue和一个sharedSampleMetadata数据集,然后初始化出一个1000个块的Info数组,用于管理这2块数据。这里将offsets、timesUs、sourceIds 、flags、sizes 几个数组统称为 Info数组,因为这里面共同保存着每个Sample的信息。

  • 输入 同时SampleQueue实现了TrackOutput接口,对外提供sampleMetadataformat 函数使得调用者可以输入Meta信息,sampleData函数可以输入播放数据。这里的输入调用者主要是后面要说的ProgressiveMediaPeriod另一部分。
    下面分析下源码数据是如何输入的:

    //输入Metadata
      @Override
      public void sampleMetadata(
          long timeUs,//与当前数据关联的媒体时间戳
          @C.BufferFlags int flags,//是否关键帧
          int size,//样本数据大小
          int offset,//块间偏移量,距离上一次已经SmapleMeta的SampleData的偏移量,我们知道媒体文件中用于播放数据不一定是连续的,其中可能包含一些其他数据,这些数据可以看成是之间的偏移量
          @Nullable CryptoData cryptoData) {
        if (upstreamFormatAdjustmentRequired) {
          format(Assertions.checkStateNotNull(unadjustedUpstreamFormat));
        }
    
        boolean isKeyframe = (flags & C.BUFFER_FLAG_KEY_FRAME) != 0;
        if (upstreamKeyframeRequired) {//从关键帧开始Sample
          if (!isKeyframe) {
            return;
          }
          upstreamKeyframeRequired = false;
        }
    
        timeUs += sampleOffsetUs;
        if (upstreamAllSamplesAreSyncSamples) {
          if (timeUs < startTimeUs) {
            // 如果所有轨道都是同步的,那么在当前Smaple点之前的时间数据就可以丢弃了
            return;
          }
          if ((flags & C.BUFFER_FLAG_KEY_FRAME) == 0) {
            if (!loggedUnexpectedNonSyncSample) {
              Log.w(TAG, "Overriding unexpected non-sync sample for format: " + upstreamFormat);
              loggedUnexpectedNonSyncSample = true;
            }
            flags |= C.BUFFER_FLAG_KEY_FRAME;//保证设置为关键帧
          }
        }
        if (pendingSplice) {//判断是否是拼接数据,如HLS切换流的时候就会用到
          if (!isKeyframe || !attemptSplice(timeUs)) {
            return;
          }
          pendingSplice = false;
        }
    
         //当前Info的偏移量=数据总长度-样本数据长度-块间偏移量
        long absoluteOffset = sampleDataQueue.getTotalBytesWritten() - size - offset;
        commitSample(timeUs, flags, absoluteOffset, size, cryptoData);
      }
    
    
    private synchronized void commitSample(
          long timeUs,
          @C.BufferFlags int sampleFlags,
          long offset,
          int size,
          @Nullable CryptoData cryptoData) {
        if (length > 0) {
          // 保证最后一个的end位置要小于等于下一个的开始位置
          int previousSampleRelativeIndex = getRelativeIndex(length - 1);
          checkArgument(
              offsets[previousSampleRelativeIndex] + sizes[previousSampleRelativeIndex] <= offset);
        }
    
        isLastSampleQueued = (sampleFlags & C.BUFFER_FLAG_LAST_SAMPLE) != 0;
        largestQueuedTimestampUs = max(largestQueuedTimestampUs, timeUs);
    
        int relativeEndIndex = getRelativeIndex(length);//获取Info里的下一个位置索引
        timesUs[relativeEndIndex] = timeUs;//开始赋值
        offsets[relativeEndIndex] = offset;
        sizes[relativeEndIndex] = size;
        flags[relativeEndIndex] = sampleFlags;
        cryptoDatas[relativeEndIndex] = cryptoData;
        sourceIds[relativeEndIndex] = upstreamSourceId;
    
        if (sharedSampleMetadata.isEmpty()
            || !sharedSampleMetadata.getEndValue().format.equals(upstreamFormat)) {
            //开始写入Metadata
          sharedSampleMetadata.appendSpan(
              getWriteIndex(),
              new SharedSampleMetadata(checkNotNull(upstreamFormat), drmSessionReference));
        }
    
        length++;//有效长度++
        if (length == capacity) {//如果写入数据已经超过Info的最大长度
          // Increase the capacity.
          int newCapacity = capacity + SAMPLE_CAPACITY_INCREMENT;//则将Info数组长度扩展至2倍
          long[] newSourceIds = new long[newCapacity];
          long[] newOffsets = new long[newCapacity];
          long[] newTimesUs = new long[newCapacity];
          int[] newFlags = new int[newCapacity];
          int[] newSizes = new int[newCapacity];
          CryptoData[] newCryptoDatas = new CryptoData[newCapacity];
          //将旧的数据,移入新的数组,将相对开始位置作为新数组的第一个位置
          int beforeWrap = capacity - relativeFirstIndex;
          System.arraycopy(offsets, relativeFirstIndex, newOffsets, 0, beforeWrap);
          System.arraycopy(timesUs, relativeFirstIndex, newTimesUs, 0, beforeWrap);
          System.arraycopy(flags, relativeFirstIndex, newFlags, 0, beforeWrap);
          System.arraycopy(sizes, relativeFirstIndex, newSizes, 0, beforeWrap);
          System.arraycopy(cryptoDatas, relativeFirstIndex, newCryptoDatas, 0, beforeWrap);
          System.arraycopy(sourceIds, relativeFirstIndex, newSourceIds, 0, beforeWrap);
          int afterWrap = relativeFirstIndex;
          System.arraycopy(offsets, 0, newOffsets, beforeWrap, afterWrap);
          System.arraycopy(timesUs, 0, newTimesUs, beforeWrap, afterWrap);
          System.arraycopy(flags, 0, newFlags, beforeWrap, afterWrap);
          System.arraycopy(sizes, 0, newSizes, beforeWrap, afterWrap);
          System.arraycopy(cryptoDatas, 0, newCryptoDatas, beforeWrap, afterWrap);
          System.arraycopy(sourceIds, 0, newSourceIds, beforeWrap, afterWrap);
          offsets = newOffsets;
          timesUs = newTimesUs;
          flags = newFlags;
          sizes = newSizes;
          cryptoDatas = newCryptoDatas;
          sourceIds = newSourceIds;
          relativeFirstIndex = 0;
          capacity = newCapacity;
        }
      }
     
      //获取当前Info数组的相对位置,传入相对第一个位置的偏移量
      private int getRelativeIndex(int offset) {
        int relativeIndex = relativeFirstIndex + offset;
        return relativeIndex < capacity ? relativeIndex : relativeIndex - capacity;//环形指针
      }
      //获取当前写入MetaData的绝对位置
      public final int getWriteIndex() {
        return absoluteFirstIndex + length;//等于当前绝开始位置+有效的长度
      }  
      //输入Format
      @Override
      public final void format(Format format) {
        Format adjustedUpstreamFormat = getAdjustedUpstreamFormat(format);
        upstreamFormatAdjustmentRequired = false;
        unadjustedUpstreamFormat = format;
        boolean upstreamFormatChanged = setUpstreamFormat(adjustedUpstreamFormat);
        if (upstreamFormatChangeListener != null && upstreamFormatChanged) {
          upstreamFormatChangeListener.onUpstreamFormatChanged(adjustedUpstreamFormat);
        }
      }
    

    Metadata输入主要分3部分:

    1. 确保当前为关键帧。
    2. 获取Info环形数组的下一个索引,将当前Sampledata的数据保存到Info数组并记录Meta信息。
    3. 确保Info数组足够大可以容纳足够多的数据。

    下面看下sampleData部分

      @Override
      public final void sampleData(
          ParsableByteArray data, int length, @SampleDataPart int sampleDataPart) {
        sampleDataQueue.sampleData(data, length);
      }
    

    没了就这么多。😂,你只管告诉sampleDataQueue数据的大小和长度,sampleDataQueue来添加,具体sampleDataQueue是怎么有效管理数据的后面会讲到,现在不是重点

    通过sampleDataQueue和sampleMetadata对比你会发现sampleMetadata比sampleDataQueue复杂多个,而且sampleMetadata方法添加了synchronized 同步块,多线程的时候会阻塞,而sampleDataQueue没有任何同步代码包括到sampleDataQueue里也一样。这样做是因为sampleMetadata的数据量很少,即使阻塞也能很高效的执行。而sampleData数据量往往比较大,写入的时间也比较长,所以不能阻塞。那么为什么要这么做呢,后面我们看到数据的读取部分就能理解了。

  • 输出 SampleQueue提供了read方法输出数据
    分析下对应源码:

    public int read(
          FormatHolder formatHolder,
          DecoderInputBuffer buffer,
          @ReadFlags int readFlags,
          boolean loadingFinished) {
          //首先读取Metadata
        int result =
            peekSampleMetadata(
                formatHolder,
                buffer,
                /* formatRequired= */ (readFlags & FLAG_REQUIRE_FORMAT) != 0,
                loadingFinished,
                extrasHolder);
        if (result == C.RESULT_BUFFER_READ && !buffer.isEndOfStream()) {
          boolean peek = (readFlags & FLAG_PEEK) != 0;
          if ((readFlags & FLAG_OMIT_SAMPLE_DATA) == 0) {
            if (peek) {
              sampleDataQueue.peekToBuffer(buffer, extrasHolder);
            } else {
              sampleDataQueue.readToBuffer(buffer, extrasHolder);//将sampleData的位置信息通过extrasHolder传递给sampleDataQueue读取数据
            }
          }
          if (!peek) {
            readPosition++;//读取位置++
          }
        }
        return result;
      }
      //读取Metadata
     private synchronized int peekSampleMetadata(
          FormatHolder formatHolder,
          DecoderInputBuffer buffer,
          boolean formatRequired,
          boolean loadingFinished,
          SampleExtrasHolder extrasHolder) {
        ...
        Format format = sharedSampleMetadata.get(getReadIndex()).format; //用绝对开始位置+读取位置(absoluteFirstIndex + readPosition)获取读取的绝对位置
        ...
    
        int relativeReadIndex = getRelativeIndex(readPosition);//获取当前Info数组的相对位置
        ...
        extrasHolder.size = sizes[relativeReadIndex];//取出Info数据
        extrasHolder.offset = offsets[relativeReadIndex];
        extrasHolder.cryptoData = cryptoDatas[relativeReadIndex];
    
        return C.RESULT_BUFFER_READ;
      }
      //获取读取的绝对位置
      public final int getReadIndex() {
        return absoluteFirstIndex + readPosition;
      }
    

    要读取sampleData和sampleMetadata的数据,首先要确定当前读取点的Info的位置,然后通过Info数组才能知道读取的位置和长度,最后读取sampleData,同样sampleMetadata读取是加锁的,而sampleData没有。可以看出sampleData的读写是不受线程限制的,通过SampleQueue内部维护的Info数组来维护sampleData,可以最大化保证多线程下sampleData读写的效率。

  • 释放 通过discardSamples等释放不需要的数据
    分析下对应源码:

     public final void discardTo(long timeUs, boolean toKeyframe, boolean stopAtReadPosition) {
        sampleDataQueue.discardDownstreamTo(
            discardSampleMetadataTo(timeUs, toKeyframe, stopAtReadPosition));//先释放Metadata
      }
      
     private synchronized long discardSampleMetadataTo(
          long timeUs, boolean toKeyframe, boolean stopAtReadPosition) {
        if (length == 0 || timeUs < timesUs[relativeFirstIndex]) {
          return C.INDEX_UNSET;
        }
        int searchLength = stopAtReadPosition && readPosition != length ? readPosition + 1 : length;
        //根据时间戳来确定要释放数据块的数量
        int discardCount = findSampleBefore(relativeFirstIndex, searchLength, timeUs, toKeyframe);
        if (discardCount == -1) {
          return C.INDEX_UNSET;
        }
        return discardSamples(discardCount);
    }
    
     private long discardSamples(int discardCount) {
        largestDiscardedTimestampUs =
            max(largestDiscardedTimestampUs, getLargestTimestamp(discardCount));
        length -= discardCount;//有效长度=有效长度-释放数量
        absoluteFirstIndex += discardCount;//绝对开始位置后移
        relativeFirstIndex += discardCount;//相对开始位置后移
        if (relativeFirstIndex >= capacity) {//环形数组
          relativeFirstIndex -= capacity;
        }
        readPosition -= discardCount;//因为relativeFirstIndex后移,相对它的位置在缩小
        if (readPosition < 0) {
          readPosition = 0;
        }
        sharedSampleMetadata.discardTo(absoluteFirstIndex);//释放Metadata
    
        if (length == 0) {
          int relativeLastDiscardIndex = (relativeFirstIndex == 0 ? capacity : relativeFirstIndex) - 1;
          return offsets[relativeLastDiscardIndex] + sizes[relativeLastDiscardIndex];
        } else {
          return offsets[relativeFirstIndex];//返回SampleData的释放偏移量
        }
    }
    

    同样数据的释放和读写一样,通过内部的Info来管理,释放后会更新Info上的相关位置。

SampleQueue动态分析

上面一直在说环形数组,静态的看代码可能感受不到这点,下面我们通过几个图来动态分析下SampleQueue的运作原理,这部分需要结合上面的源码一起看才好理解。

首先为了方便分析假设数组最大长度为capacity=6,当前已经写入了4段sampleData对应图中的sample0-3,同时也写入了4个数据到Info数组对应图中的0-2的size、offset、time结构,每个结构的size、offset、time在图的最下方都有标记,这里可以看下加深下对这个结构数值的含义的理解,所以此时有效长度length=4,由于是刚开始读写这个时候的relativeFirstIndex=absoluteFirstIndex=0处于开始位置,当前的读取位置相对于relativeFirstIndex也就是和relativeFirstIndex差值,readPosition=2。接下来sample会从右侧箭头处不断写入。同样上方的Info数组随着读取也会不断变化。
在这里插入图片描述
好了,此时先向Sample队列写入一个Sample length+1,然后同时读取2个Sample readPosition+2=4
在这里插入图片描述
随着数据被使用(已经播放)之前的数据需要丢弃,以便下次写入,释放3个Sample,可以看到relativeFirstIndex和absoluteFirstIndex同时前移,虽然readPosiition的位置没有移动,也就是没有读取新的数据,但是readPosiition的值变小,有效长度缩小为2。到这里relativeFirstIndex还是和absoluteFirstIndex相等的还看不出环形的特性。
在这里插入图片描述
此时开始写入3个Sample,这个时候就可以看出Info环形特性,之前释放的0号和1号会重新指向数据队列的最前端,同时更新offset,size相关数据,有效数据长度增加到5,length=5。
在这里插入图片描述
这个时候再读取3个Sample时,readPosiition的值增加3此时指向Info数组的下标1,readPosiition=4。
在这里插入图片描述
好了我们继续释放数据,这次再次释放3个,可以看到relativeFirstIndex和absoluteFirstIndex值开始不一样了,由于又回到了Info数组的开始位置所以relativeFirstIndex=0,readPosiition缩短为1,有效长度length=2,而absoluteFirstIndex是相对于Smaple的绝对位置,这个时候absoluteFirstIndex继续后移到6号位置的sample6。
在这里插入图片描述
把上面的图连续不断的执行,可以想象出,Info数组像一个不断前行的履带行驶在sample铺平的道路上(读取)。被履带压过的道路(已经读取过的数据)就会被释放,此时路还在不断的向前铺设(新的sample数据在不断的写入到SampleQueen中),整个过程中如果新增数据比释放数据快,履带的大小会动态的扩充变长,图中为了方便理解并没有体现这点。

至此我们可以总结出几个规律:

  • 当前写入数据的绝对位置永远等于absoluteFirstIndex+length
  • 当前读取数据的绝对位置永远等于absoluteFirstIndex + readPosition
  • Info数组可以理解成一个首尾相连的环形数组,数组最后一个位置的下个位置就是数组的开始位置
    这几个规律在源码中经常被用到,感兴趣的同学可以深入阅读下。

下面来分析下实际存储数据的2个结构

SpannedData< SharedSampleMetadata >

本质是一个Android里实现SparseArray的map,通过int 类型key可以快速向指定key存入数据或者取出数据,这里数据跟随SampleQueue里的Info来管理,添加或者释放指定位置的Metadata数据。

SampleDataQueue

重点来说下SampleDataQueue,由于SampleData的数据量要远远大于Metadata,而且还需要频繁的读写释放,所以向SpannedData<SharedSampleMetadata>那样简单粗暴的管理数据,效率会非常低,因为JVM要频繁的申请内存GC释放内存。为了解决这个问题SampleDataQueue内部维护了一个链表,同时维护了链表中3个重要的节点,firstAllocationNode,readAllocationNode,writeAllocationNode,用于快速获取读写点。

  private AllocationNode firstAllocationNode;//第一个节点位置
  private AllocationNode readAllocationNode;//当前读取节点位置
  private AllocationNode writeAllocationNode;//当前写入节点位置

这里顺带提下AllocationNode的数据结构,主要就是封装了Allocation,allocation才是实际存储数据的部分,同时提供了next AllocationNode 提供下一个AllocationNode 的指针,形成一个链表结构。

 private static final class AllocationNode implements Allocator.AllocationNode {
    public long startPosition;//此段allocation的开始位置
    public long endPosition;//此段allocation的结束位置
    public Allocation allocation;//实际缓存数据部分
    public AllocationNode next;//指向下一个
    ...
    public void initialize(Allocation allocation, AllocationNode next) {
      this.allocation = allocation;
      this.next = next;
    }
    ...

回到SampleDataQueue中,调用sampleData循环写入数据时,每次循环写入主要分为3步:

  1. 调用preAppend初始化通过writeAllocationNode,同时也初始化出了下个writeAllocationNode。重点看下allocator.allocate(),这里才是初始化了AllocationNode的实际内存数据allocation的地方,后面会详细分析。
  2. 将数据循环写入writeAllocationNode的实际缓存位置allocation.data中。
  3. 调用preAppend更新SampleDataQueue已写入总长度,如果总长度已经超过当前写入节点的结束位置,将当前写入节点,更新为下一写入节点。

  private int preAppend(int length) {
    if (writeAllocationNode.allocation == null) {
      writeAllocationNode.initialize(
          allocator.allocate(),//分配内存
          new AllocationNode(writeAllocationNode.endPosition, allocationLength));
    }
    return min(length, (int) (writeAllocationNode.endPosition - totalBytesWritten));
  }

  public void sampleData(ParsableByteArray buffer, int length) {
    while (length > 0) {
      int bytesAppended = preAppend(length);
      buffer.readBytes(
          writeAllocationNode.allocation.data,
          writeAllocationNode.translateOffset(totalBytesWritten),
          bytesAppended);
      length -= bytesAppended;
      postAppend(bytesAppended);
    }
  }
  
  private void postAppend(int length) {
    totalBytesWritten += length;//增加总长度
    if (totalBytesWritten == writeAllocationNode.endPosition) {//总长度已经超过当前写入节点的结束位置
      writeAllocationNode = writeAllocationNode.next;//将当前写入节点,更新为下一写入节点
    }
  }

读取和写入类似,直接看下释放数据的地方,首先释放指定位置之前的链表数据,其次重置开始节点和读取节点。

  public void discardDownstreamTo(long absolutePosition) {
    if (absolutePosition == C.INDEX_UNSET) {
      return;
    }
    while (absolutePosition >= firstAllocationNode.endPosition) {
      //从第一个节点开始依次取出下一个节点通过allocator释放内存,并清除AllocationNode,一直到指定的absolutePosition
      allocator.release(firstAllocationNode.allocation);
      firstAllocationNode = firstAllocationNode.clear();
    }
    if (readAllocationNode.startPosition < firstAllocationNode.startPosition) {
      //保证当前的读取位置在开始节点之后
      readAllocationNode = firstAllocationNode;
    }
  }

看完是不是发现目前也没没有解决上面说的内存问题,内存感觉是在不断新增的。注意看下上面源码实际获取内存的地方allocator.allocate(),原来这些都交给了Allocator,通过Allocator实现内存的循环高效利用。

Allocator

这是一个接口用于媒体数据的内存分配,默认有一个DefaultAllocator实现。
先看下主要的源码

public final class DefaultAllocator implements Allocator {

  private static final int AVAILABLE_EXTRA_CAPACITY = 100;//额外的初始化Allocation数量

  private final boolean trimOnReset;
  private final int individualAllocationSize;
  @Nullable private final byte[] initialAllocationBlock;//初始化的一个连续的数组,指向默认数量的的Allocations,参考下图

  private int targetBufferSize;
  private int allocatedCount;//已分配的Allocation数量,参考下图
  private int availableCount;//可用的Allocation数量,参考下图
  private @NullableType Allocation[] availableAllocations;//可用的Allocations,参考下图
  public DefaultAllocator(
      boolean trimOnReset, int individualAllocationSize, int initialAllocationCount) {
    this.trimOnReset = trimOnReset;
    this.individualAllocationSize = individualAllocationSize;
    this.availableCount = initialAllocationCount;
    this.availableAllocations = new Allocation[initialAllocationCount + AVAILABLE_EXTRA_CAPACITY];//添加了部分冗余
    if (initialAllocationCount > 0) {//将初始化的Allocations通过指定offset分配initialAllocationBlock
      initialAllocationBlock = new byte[initialAllocationCount * individualAllocationSize];
      for (int i = 0; i < initialAllocationCount; i++) {
        int allocationOffset = i * individualAllocationSize;
        availableAllocations[i] = new Allocation(initialAllocationBlock, allocationOffset);
      }
    } else {
      initialAllocationBlock = null;
    }
  }
  //这个方法用于获取一个Allocation,注意在调用此方法后必须调用release方法将分配Allocation返还
 @Override
  public synchronized Allocation allocate() {
    allocatedCount++;//已分配数量+1
    Allocation allocation;
    if (availableCount > 0) {
      allocation = Assertions.checkNotNull(availableAllocations[--availableCount]);//从尾部取出,可用数量-1
      availableAllocations[availableCount] = null;//清空
    } else {
      allocation = new Allocation(new byte[individualAllocationSize], 0);//不够用了,创建新的Allocation,直接初始化出一段新的数组分配给它
      if (allocatedCount > availableAllocations.length) {//可用Allocations扩充2倍
        availableAllocations = Arrays.copyOf(availableAllocations, availableAllocations.length * 2);
      }
    }
    return allocation;
  }

 //返还分配的Allocation
  @Override
  public synchronized void release(Allocation allocation) {
    availableAllocations[availableCount++] = allocation;//可用数量加1
    allocatedCount--;//已分配数量减1
  }
  ...
}

@Override//释无用的空块
public synchronized void trim() {
    //如果重新定义了缓存区大小,计算需要的Allocation块总数量
    int targetAllocationCount = Util.ceilDivide(targetBufferSize, individualAllocationSize);
    int targetAvailableCount = max(0, targetAllocationCount - allocatedCount);//减去目前空余的块,则为剩余需要的块数量
    //不存在冗余,无需trim
    if (targetAvailableCount >= availableCount) {
      return;
    }

    if (initialAllocationBlock != null) {
      // 从头尾查找第一个不是空的块,将其位置向前
      int lowIndex = 0;
      int highIndex = availableCount - 1;
      while (lowIndex <= highIndex) {
        //未分配出的Allocation 不可能为null
        Allocation lowAllocation = Assertions.checkNotNull(availableAllocations[lowIndex]);
        if (lowAllocation.data == initialAllocationBlock) {//当前低位为初始值,从未被分配过
          lowIndex++;//lowIndex后移
        } else {//当前低位Allocation已分配过
          //未分配出的Allocation 不可能为null
          Allocation highAllocation = Assertions.checkNotNull(availableAllocations[highIndex]);
          if (highAllocation.data != initialAllocationBlock) {//当前高位Allocation已分配过
            highIndex--;//highIndex前移
          } else {//当前高位Allocation未分配过
            //将当前未分配过高位和已分配过的低位交换位置,未分配过的放到数组低位
            availableAllocations[lowIndex++] = highAllocation;
            availableAllocations[highIndex--] = lowAllocation;
          }
        }
      }
      //到这里lowIndex之前的所有Allocation都是未分配过的初始initialAllocationBlock
      // 获取他们的最大值,也就是最大可释放
      targetAvailableCount = max(targetAvailableCount, lowIndex);
      //只有一种情况lowIndex正好等于availableCount,也就是当前未分配块都是初始值,从未被分配,当前可能为初始状态跳过trim
      if (targetAvailableCount >= availableCount) {
        return;
      }
    }

    // 释放空块
    Arrays.fill(availableAllocations, targetAvailableCount, availableCount, null);
    availableCount = targetAvailableCount;
  }

Allocator保存了一组Allocation列表,和一个默认的字节数组,每个Allocation对于数据块的长度由individualAllocationSize决定,通过offset确定在数组中的起始位置。同时维护着可用数量和已分配数量,当外部需要新的Allocation时会调用allocate获取,使用完毕后调用release将Allocation返还。可以看到这种设计特别适合播放器的缓冲数据,开始播放时分配一个默认的缓冲区域大小,随着播放进度,当前播放位置前会不断获取新Allocation用于提前缓冲,当这些数据已被渲染播放,离开了缓冲区域,这个时候又会将之前获取Allocation返还,依次循环,滚动的循环利用已分配的内存,整个过程只要不超最大值,就不会再分配新的内存,效率非常高。
下面用一张图来解释下整个过程:
在这里插入图片描述
如上图,是一个有着6个Allocation的Allocator,单个Allocation包含2个block(individualAllocationSize=2),initialAllocationBlock也就是block数组总长度为initialAllocationCountindividualAllocationSize=62=12。

初始化时会将每个Allocation依次指向initialAllocationBlock中的Block,通过Offset记录位置,当前已经分配出2个Allocation(上图表示为null),空余4个Allocation可分配,此时如果外部再需要获取Allocation时,也就是调用allocate,会将Allocation4,分配出去同时置为null,这个时候Allocation4的指向的Block并没有变化,外部调用者会向Block中填充数据用于缓存。
如果外部释放Allocation时,也就是调用release,会将Allocation填充至Allocation4后面一个位置,记为Allocation5,此过程Allocation5一直都是指向initialAllocationBlock的某段Block的。

这两个过程availableCount和allocatedCount也会相应增加或者减少,如果一个Allocation从来没有被分配过,则Block为初始值initialAllocationBlock,如上图的Allocation1,可以通过判断当前的Allocation的data是否等于initialAllocationBlock判断当前Allocation是否被分配过。

整个过程会让人不禁联想到 Android MediaCodec缓冲区,这里部分应该在Renderer部分提到,这里先提前贴下Android MediaCodec缓冲区使用的图,看看是不是很相似呢。
在这里插入图片描述


总结

SampleQueue只对Info数组这种小数据量的读写操作做多线程加锁操作,通过短时间阻塞读取Info数组的方式,查询读取关联的sampleData的数据,保证对sampleData这种大数据量耗时的读写不会阻塞,保证了数据的读写效率。

同时SampleQueue的环形数组的数据管理方式令人印象深刻,这种结构特别适合媒体播放这种场景,完美的平衡了性能与内存使用之间的矛盾。

有了SampleQueue这个数据大总管,ProgressiveMediaPeriod就可以随心所欲的写入数据并将媒体数据提供给上游读取。
到这里算是讲完了ProgressiveMediaPeriod的SampleQueue部分。后面将会讲到数据是如何加载到SampleQueue的,也就是首图的右半部分。


版权声明 ©
本文为CSDN作者山雨楼原创文章
转载请注明出处
原创不易,觉得有用的话,收藏转发点赞支持

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/148342.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

2024CFA一级二级三级双机构网课资源

复习流程 我自己的复习流程是这样的&#xff0c;按照这个踏实去复习的话100&#xff05;可以过&#xff1a; 第一轮学习&#xff08;30-40天左右&#xff09;&#xff1a;把所有reading学习一遍&#xff0c;每天上午看新的reading&#xff0c;下午复习前一天上午学习的reading…

arf_1解题

arf_1解题 镜像环境 version: 3.2services:web:image: registry.cn-hangzhou.aliyuncs.com/n1book/web-file-read-1:latestports:- 80:80新建yml文件将代码保存在当前位置 使用docker-compost up -d 拉取镜像 解题 访问该镜像映射端口为1520 可以看到页面只有一个holle但…

vue中一个页面引入多个相同组件重复请求的问题?

⚠️&#xff01;&#xff01;&#xff01;此内容需要了解一下内容&#xff01;&#xff01;&#xff01; 1、会使用promise&#xff1f;&#xff1f;&#xff1f; 2、 promise跟 async 的区别&#xff1f;&#xff1f;&#xff1f; async 会终止后面的执行&#xff0c;后续…

【广州华锐互动】地震防灾减灾科普3D虚拟展厅:向公众普及地震安全知识

在面对自然灾害时&#xff0c;我们都需要有足够的知识和准备来保护自己和他人。这就是为什么地震安全知识的普及如此重要。然而&#xff0c;传统的教育方法可能无法满足所有人的需求&#xff0c;特别是在这个数字化的时代。为了解决这个问题&#xff0c;广州华锐互动制作开发了…

微签:电子签章实力派,这19年从幕后走向台前

微签是什么&#xff1f;尽管在电子签章领域已深耕19年 &#xff0c;是国内电子签名市场的拓荒者之一&#xff0c;但因为其低调的风格&#xff0c;一直不为众人所知。不过&#xff0c;如果现在你想对目前市面上的电子签名厂商做一个专业客观的盘点的话&#xff0c;不管从哪个角度…

优雅写代码之《项目规范》-附加树状图生成

阿丹&#xff1a; 最近有一些小伙伴在跳槽之后接触到了新的项目小组&#xff0c;在讨论如何整理出漂亮的项目结构以及代码书写的时候&#xff0c;既然有小伙伴发问了&#xff0c;那当然就要一起学习&#xff0c;来&#xff01;开卷&#xff01;本文章只作为一个分享&#xff0c…

别试错了,是该关注一下软件内在质量了

太多这种例子了&#xff0c;老板们早上出的新想法&#xff0c;恨不得第二天就能上线。。每个互联网公司都试图突破固定领地&#xff0c;不断地尝试新的业务&#xff0c;一旦发现不行&#xff0c;就立刻砍掉&#xff0c;名曰“试错”。 研发部门&#xff0c;为了应对压力&#…

企业传统纸质设备维修方式的痛点以及解决方案

传统的纸质设备维修方式有很多痛点&#xff1a; 数据更新和访问的低效率&#xff1a;传统的纸质记录方法在更新和检索数据时效率极低。这种方式无法实时更新设备的维修状态&#xff0c;导致管理层和维修人员无法及时获取最新信息&#xff0c;影响决策的速度和质量。 记录的易…

SAPRouter Certificate即将过期更新证书

今日收到SAP发的一封邮件提示SAPRouter Certificate即将过期&#xff0c;顺便记录下更新证书的方法步骤。 1、登录SAProuter服务器&#xff0c;用户使用安装SAProuter的用户&#xff0c;我的是saprter用户 进入到/saprouter目录&#xff0c;备份certreq cred_V2 local.pse src…

移动端实现彩色导航

一、所需代码 &#xff08;1&#xff09;html部分 <div class"pres_nav"><ul><li v-for"(item, index) in menuList" :key"item.id" click"topage()" :style"{ backgroundColor: getBackgroundColor(index, li)…

PDF如何转word文档

强烈推荐&#xff1a;Solid Converter PDF https://wzhonghe.com/?p6878#p1 嘎嘎猛&#xff1a; 将PDF文件转换为Word文档并保留原始格式可能会涉及到一些复杂的布局和格式问题。在这里&#xff0c;我将提供一种常见的方法&#xff0c;但请注意&#xff0c;它可能不是100%准…

企业APP软件定制开发的关键步骤|网站小程序搭建

企业APP软件定制开发的关键步骤|网站小程序搭建 在当今数字化快速发展的时代&#xff0c;企业越来越意识到拥有自己的APP软件对于提高业务效率和用户体验的重要性。然而&#xff0c;企业APP软件定制开发并不是一项简单的任务&#xff0c;它需要经过一系列关键步骤来确保最终的产…

Pikachu漏洞练习平台之CSRF(跨站请求伪造)

本质&#xff1a;挟制用户在当前已登录的Web应用程序上执行非本意的操作&#xff08;由客户端发起&#xff09; 耐心看完皮卡丘靶场的这个例子你就明白什么是CSRF了 CSRF(get) 使用提示里给的用户和密码进行登录&#xff08;这里以lili为例&#xff09; 登录成功后显示用户…

【git】远程远程仓库命令操作详解

这篇文章主要是针对git的命令行操作进行讲解&#xff0c;工具操作的基础也是命令行&#xff0c;如果基本命令操作都不理解&#xff0c;就算是会工具操作&#xff0c;真正遇到问题还是一脸懵逼 如果需要查看本地仓库的详细操作可以看我上篇文件 【git】git本地仓库命令操作详解…

vue-router路由(二)

​&#x1f308;个人主页&#xff1a;前端青山 &#x1f525;系列专栏&#xff1a;Vue篇 &#x1f516;人终将被年少不可得之物困其一生 依旧青山,本期给大家带来vue篇专栏内容:vue-router路由(二) 目录 1. Vue-Router 的懒加载如何实现 2. 路由的hash和history模式的区别 1…

精益管理3个阶段,如何实现高效企业管理?

在现今竞争激烈的市场环境下&#xff0c;企业需要不断提高经营效率和降低成本来保持竞争力。其中&#xff0c;精益管理是一种不错的管理方式&#xff0c;在各大企业得到广泛的运用。今天我们来了解一下精益管理的3个阶段&#xff0c;以及如何使用精益管理工具来实现高效企业管理…

ubuntu20安装opencv4和opencv_contrib 多版本共存

openCV 卸载 openCV 安装后的源码尽可能保留&#xff0c;因为可以直接从build文件夹下卸载已经安装的openCV. 参考链接&#xff1a;视觉学习笔记10——opencv的卸载、安装与多版本管理 如果已经安装完openCV,后续想重新装&#xff0c;需要先卸载掉安装的openCV. 在ubuntu终端…

实验室EM3电磁铁

锦正茂EM3电磁铁&#xff0c;可以通过更换电磁铁极头在一定范围内改善磁场的大小和磁场的均匀度 &#xff0c;并且可以通过调整极头间距改变磁场的大小。主要用于磁滞现象研究、磁化系数测量、霍尔效应研究、磁光实验、磁场退火、核磁共振、电子顺磁共振、生物学研究、磁性测量…

【JavaEE】Servlet API 详解(HttpServletResponse类方法演示、实现自动刷新、实现自动重定向)

一、HttpServletResponse HttpServletResponse表示一个HTTP响应 Servlet 中的 doXXX 方法的目的就是根据请求计算得到相应, 然后把响应的数据设置到 HttpServletResponse 对象中 然后 Tomcat 就会把这个 HttpServletResponse 对象按照 HTTP 协议的格式, 转成一个字符串, 并通…