Shaka Player 파헤치기 - DASH 매니페스트 파서#

1// preload_manager.js — parseManifestInner_ (발췌)
2this.parserFactory_ = shaka.media.ManifestParser.getFactory(
3    this.assetUri_, this.mimeType_); // DASH면 DASH 파서, HLS면 HLS 파서
4this.parser_ = this.parserFactory_();
5this.manifest_ = await this.parser_.start(
6    this.assetUri_, this.manifestPlayerInterface_);

1// dash_parser.js — start()
2async start(uri, playerInterface) {
3  this.lowLatencyMode_ = playerInterface.isLowLatencyMode();
4  this.manifestUris_ = [uri];
5  this.playerInterface_ = playerInterface;
6
7  const updateDelay = await this.requestManifest_(); // 실제 작업은 전부 여기
8
9  if (this.playerInterface_) {
10    this.setUpdateTimer_(updateDelay); // 라이브라면 갱신 타이머를 건다
11  }
12
13  goog.asserts.assert(this.manifest_, 'Manifest should be non-null!');
14  return this.manifest_;
15}

1// dash_parser.js — requestManifest_ (발췌)
2async requestManifest_() {
3  const requestType = shaka.net.NetworkingEngine.RequestType.MANIFEST;
4  let rootElement = 'MPD';
5  let manifestUris = this.manifestUris_;
6
7  // 부분 갱신용 Patch 위치가 있으면 그쪽을, 콘텐츠 스티어링이 있으면 지정 location을
8  const patchLocationUris = this.getPatchLocationUris_();
9  if (patchLocationUris.length) {
10    manifestUris = patchLocationUris;
11    rootElement = 'Patch';
12  } else if (this.manifestUris_.length > 1 && this.contentSteeringManager_) {
13    // ...content steering으로 manifestUris 교체
14  }
15
16  const request = shaka.net.NetworkingEngine.makeRequest(
17      manifestUris, this.config_.retryParameters);
18  const startTime = Date.now();
19  const response = await this.makeNetworkRequest_(request, requestType, {type});
20
21  // 리다이렉트되었다면 최종 uri를 후보 목록 맨 앞에 끼워 둔다
22  if (response.uri && response.uri != response.originalUri &&
23      !this.manifestUris_.includes(response.uri)) {
24    this.manifestUris_.unshift(response.uri);
25  }
26
27  await this.parseManifest(response.data, response.uri, rootElement);
28
29  // 갱신에 걸린 시간을 지수가중이동평균에 기록 (느린 기기 보정용)
30  const updateDuration = (Date.now() - startTime) / 1000.0;
31  this.averageUpdateDuration_.sample(1, updateDuration);
32  return updateDuration;
33}

1// dash_parser.js — parseManifest / processParsedMpd (발췌)
2parseManifest(data, finalManifestUri, rootElement) {
3  const mpd = shaka.util.TXml.parseXml(data, rootElement); // 바이트 → XML 트리
4  return this.processParsedMpd(mpd, finalManifestUri, rootElement);
5}
6
7async processParsedMpd(mpd, finalManifestUri, rootElement) {
8  // 사용자가 등록한 전처리 훅이 있으면 XML 트리를 먼저 손본다
9  const manifestPreprocessorTXml = this.config_.dash.manifestPreprocessorTXml;
10  if (manifestPreprocessorTXml != defaultManifestPreprocessorTXml) {
11    manifestPreprocessorTXml(mpd);
12  }
13
14  if (rootElement === 'Patch') {
15    return this.processPatchManifest_(mpd); // 부분 갱신 경로
16  }
17
18  if (!shaka.dash.MpdUtils.hasXlinks(mpd)) {
19    return this.processManifest_(mpd, finalManifestUri); // 일반 경로
20  }
21
22  // xlink가 있으면 외부 조각들을 먼저 당겨와 합친 뒤 처리
23  const xlinkOperation = shaka.dash.MpdUtils.processXlinks(/* ... */);
24  this.operationManager_.manage(xlinkOperation);
25  const finalMpd = await xlinkOperation.promise;
26  return this.processManifest_(finalMpd, finalManifestUri);
27}

1// dash_parser.js — processManifest_ (핵심 골격)
2async processManifest_(mpd, finalManifestUri) {
3  // 1) Location / BaseURL / ContentSteering 같은 배포 메타데이터 수집
4  // 2) MPD 속성으로 재생 타임라인의 골격을 잡는다
5  const mpdType = mpd.attributes['type'] || 'static'; // static(VOD) | dynamic(LIVE)
6  this.updatePeriod_ = TXml.parseAttr(mpd, 'minimumUpdatePeriod', ...);
7  // availabilityStartTime, timeShiftBufferDepth, maxSegmentDuration ...
8  let presentationTimeline = /* PresentationTimeline 구성 */;
9
10  // 3) 계층 파싱의 루트가 될 context(상속 프레임의 시작점)
11  const context = {
12    dynamic: mpdType != 'static',
13    presentationTimeline,
14    period: null, adaptationSet: null, representation: null,
15    // ...
16  };
17
18  // 4) Period들을 파싱한다 (여기서 트리를 타고 내려간다)
19  const periodsAndDuration = this.parsePeriods_(context, getBaseUris, mpd, false);
20  const periods = periodsAndDuration.periods;
21
22  // 5) 최초 파싱일 때만: Period들을 평탄화해 모델을 새로 조립
23  if (!this.manifest_) {
24    await this.periodCombiner_.combinePeriods(periods, context.dynamic);
25
26    this.manifest_ = {
27      presentationTimeline,
28      variants: this.periodCombiner_.getVariants(),
29      textStreams: this.periodCombiner_.getTextStreams(),
30      imageStreams: this.periodCombiner_.getImageStreams(),
31      type: shaka.media.ManifestParser.DASH,
32      nextUrl: this.parseMpdChaining_(mpd),
33      periodCount: periods.length,
34      isLowLatency: this.isLowLatency_,
35      // ...
36    };
37
38    if (presentationTimeline.usingPresentationStartTime()) {
39      // UTCTiming으로 서버-클라이언트 시계를 맞춘다 (라이브 동기화의 토대)
40      const offset = await this.parseUtcTiming_(getBaseUris, timingElements);
41      presentationTimeline.setClockOffset(offset);
42    }
43    presentationTimeline.lockStartTime();
44  } else {
45    // 6) 갱신일 때는 모델을 새로 만들지 않고 일부만 갈아끼운다
46    await this.postPeriodProcessing_(periods, /* isPatchUpdate= */ false);
47  }
48
49  this.playerInterface_.makeTextStreamsForClosedCaptions(this.manifest_);
50}

1// dash_parser.js — 계층을 타고 내려가는 호출 사슬
2parsePeriods_  // 모든 Period를 순회
3  └─ parsePeriod_           // EventStream·SupplementalProperty 처리 후
4       └─ parseAdaptationSet_   // 각 AdaptationSet을 map으로 파싱
5            └─ parseRepresentation_  // 최종적으로 Stream 하나를 만든다

1// dash_parser.js — parsePeriod_ (발췌)
2const adaptationSets =
3    TXml.findChildren(periodInfo.node, 'AdaptationSet')
4        .map((node, position) =>
5          this.parseAdaptationSet_(context, position, node))
6        .filter(Functional.isNotNull);

1// dash_parser.js — createFrame_ (발췌)
2createFrame_(elem, parent, getBaseUris) {
3  parent = parent || /* 루트 기본값 */ ({ contentType: '', mimeType: '', codecs: '', /* ... */ });
4  getBaseUris = getBaseUris || parent.getBaseUris;
5
6  // 자식에 값이 있으면 자식 것을, 없으면 부모에게서 물려받는다
7  const contentType = elem.attributes['contentType'] || parent.contentType;
8  const mimeType    = elem.attributes['mimeType']    || parent.mimeType;
9  const allCodecs   = [elem.attributes['codecs']     || parent.codecs];
10  // BaseURL, SegmentTemplate, availabilityTimeOffset ... 모두 같은 방식으로 캐스케이드
11  // ...
12}

1// dash_parser.js — processManifest_ (발췌)
2await this.periodCombiner_.combinePeriods(periods, context.dynamic);
3
4this.manifest_ = {
5  // ...
6  variants: this.periodCombiner_.getVariants(),    // 평탄화된 variant
7  textStreams: this.periodCombiner_.getTextStreams(),
8  imageStreams: this.periodCombiner_.getImageStreams(),
9  // ...
10};

1// dash_parser.js — processManifest_ (발췌)
2if (this.periodCombiner_ && !this.manifest_.presentationTimeline.isLive()) {
3  this.periodCombiner_.release(); // VOD는 더 합칠 Period가 없다
4}

1// dash_parser.js — 갱신 타이머
2this.updateTimer_ = new shaka.util.Timer(() => {
3  if (this.mediaElement_ && !this.config_.continueLoadingWhenPaused) {
4    this.eventManager_.unlisten(this.mediaElement_, 'timeupdate');
5    if (this.mediaElement_.paused) {
6      // 일시정지 중이면, 재생이 재개될 때까지 갱신을 미룬다
7      this.eventManager_.listenOnce(
8          this.mediaElement_, 'timeupdate', () => this.onUpdate_());
9      return;
10    }
11  }
12  this.onUpdate_();
13});

1// dash_parser.js — onUpdate_ (발췌)
2async onUpdate_() {
3  let updateDelay = 0;
4  try {
5    updateDelay = await this.requestManifest_(); // 같은 경로 재사용
6  } catch (error) {
7    // 실패해도 치명적이 아니면 심각도를 낮춰 재시도
8  }
9  if (!this.playerInterface_) {
10    return;
11  }
12  this.playerInterface_.onManifestUpdated(); // 플레이어에 갱신을 통지
13  this.setUpdateTimer_(updateDelay);         // 다음 갱신을 다시 예약
14}

1// dash_parser.js — postPeriodProcessing_ (발췌)
2async postPeriodProcessing_(periods, isPatchUpdate) {
3  await this.periodCombiner_.combinePeriods(periods, true, isPatchUpdate);
4  this.manifest_.variants = this.periodCombiner_.getVariants();
5  // textStreams, imageStreams 갱신 ...
6  this.playerInterface_.filter(this.manifest_); // 제약·DRM 기준 재필터링
7}

1// dash_parser.js — setUpdateTimer_ (발췌)
2const finalDelay = Math.max(
3    updateTime - offset,
4    this.averageUpdateDuration_.getEstimate());
5// repeating이 아니라 매번 async 완료 후 재예약
6this.updateTimer_.tickAfter(/* seconds= */ finalDelay);