Class CastFrameQueue

src/Frame.ts:106–157

}

export class CastFrameQueue implements IFrameQueue {
  private _endFrame: IFrame
  private _frames: Array<IFrame> = []

  constructor(
    cast: ICastObject,
    step: number = DEFAULT_FRAME_EVENTS_STEP,
    snapshotFn: FrameSnapshotFn = DEFAULT_FRAME_SNAPSHOT_FN
  ) {
    const duration = cast.header.duration
    const events = cast.events

    this._frames = new Array<IFrame>(2 + Math.ceil(events.length / step))
    this._frames[0] = START_FRAME
    this._frames[this._frames.length - 1] = this._endFrame = new NullFrame(duration, duration)

    for (let start = 0, n = 1, prev: IFrame = START_FRAME; start < events.length; start += step) {
      const end = start + step
      const slice = new Slice<ICastEvent>(cast.events, start, end) // TODO: Do a benchmark of [].slice vs Slice
      const startTime = slice.get(0).time
      const endTime = end < events.length ? events[end].time : duration
      const f = new CastEventsFrame(startTime, endTime, slice, snapshotFn)
      f.prev = prev
      this._frames[n++] = prev = f
    }

    this._endFrame.prev = this._frames[this._frames.length - 2]
  }
  public isEnd(frame: IFrame): boolean { return frame === this._endFrame }
  public len(): number { return this._frames.length - 2 }
  public frame(time: number): IFrame {
    if (time < 0) { throw new Error('Time must not be negative') }
    if (!this.len()) { throw new Error('Empty frames') }
    // bisearch
    const frames = this._frames
    let min = 1, mid = 0, max = this.len()
    if (time >= this._frames[max].endTime) { return this._endFrame }
    while (max >= min) {
      mid = (min + max) >> 1
      const f = frames[mid]
      if (time >= f.endTime) {
        min = mid + 1
      } else if (time < f.startTime) {
        max = mid - 1
      } else {
        return f
      }
    }
    return NULL_FRAME
  }
  public dispose(): void { this._frames = [] }
}