Home Reference Source

src/types/loader.ts

  1. import type { Fragment } from '../loader/fragment';
  2. import type { Part } from '../loader/fragment';
  3. import type { LevelDetails } from '../loader/level-details';
  4. import type { HlsUrlParameters } from './level';
  5.  
  6. export interface LoaderContext {
  7. // target URL
  8. url: string;
  9. // loader response type (arraybuffer or default response type for playlist)
  10. responseType: string;
  11. // headers
  12. headers?: Record<string, string>;
  13. // start byte range offset
  14. rangeStart?: number;
  15. // end byte range offset
  16. rangeEnd?: number;
  17. // true if onProgress should report partial chunk of loaded content
  18. progressData?: boolean;
  19. }
  20.  
  21. export interface FragmentLoaderContext extends LoaderContext {
  22. frag: Fragment;
  23. part: Part | null;
  24. }
  25.  
  26. export interface LoaderConfiguration {
  27. // Max number of load retries
  28. maxRetry: number;
  29. // Timeout after which `onTimeOut` callback will be triggered
  30. // (if loading is still not finished after that delay)
  31. timeout: number;
  32. // Delay between an I/O error and following connection retry (ms).
  33. // This to avoid spamming the server
  34. retryDelay: number;
  35. // max connection retry delay (ms)
  36. maxRetryDelay: number;
  37. // When streaming progressively, this is the minimum chunk size required to emit a PROGRESS event
  38. highWaterMark: number;
  39. }
  40.  
  41. export interface LoaderResponse {
  42. url: string;
  43. data: string | ArrayBuffer;
  44. }
  45.  
  46. export interface LoaderStats {
  47. aborted: boolean;
  48. loaded: number;
  49. retry: number;
  50. total: number;
  51. chunkCount: number;
  52. bwEstimate: number;
  53. loading: HlsProgressivePerformanceTiming;
  54. parsing: HlsPerformanceTiming;
  55. buffering: HlsProgressivePerformanceTiming;
  56. }
  57.  
  58. export interface HlsPerformanceTiming {
  59. start: number;
  60. end: number;
  61. }
  62.  
  63. export interface HlsChunkPerformanceTiming extends HlsPerformanceTiming {
  64. executeStart: number;
  65. executeEnd: number;
  66. }
  67.  
  68. export interface HlsProgressivePerformanceTiming extends HlsPerformanceTiming {
  69. first: number;
  70. }
  71.  
  72. export type LoaderOnSuccess<T extends LoaderContext> = (
  73. response: LoaderResponse,
  74. stats: LoaderStats,
  75. context: T,
  76. networkDetails: any
  77. ) => void;
  78.  
  79. export type LoaderOnProgress<T extends LoaderContext> = (
  80. stats: LoaderStats,
  81. context: T,
  82. data: string | ArrayBuffer,
  83. networkDetails: any
  84. ) => void;
  85.  
  86. export type LoaderOnError<T extends LoaderContext> = (
  87. error: {
  88. // error status code
  89. code: number;
  90. // error description
  91. text: string;
  92. },
  93. context: T,
  94. networkDetails: any
  95. ) => void;
  96.  
  97. export type LoaderOnTimeout<T extends LoaderContext> = (
  98. stats: LoaderStats,
  99. context: T,
  100. networkDetails: any
  101. ) => void;
  102.  
  103. export type LoaderOnAbort<T extends LoaderContext> = (
  104. stats: LoaderStats,
  105. context: T,
  106. networkDetails: any
  107. ) => void;
  108.  
  109. export interface LoaderCallbacks<T extends LoaderContext> {
  110. onSuccess: LoaderOnSuccess<T>;
  111. onError: LoaderOnError<T>;
  112. onTimeout: LoaderOnTimeout<T>;
  113. onAbort?: LoaderOnAbort<T>;
  114. onProgress?: LoaderOnProgress<T>;
  115. }
  116.  
  117. export interface Loader<T extends LoaderContext> {
  118. destroy(): void;
  119. abort(): void;
  120. load(
  121. context: LoaderContext,
  122. config: LoaderConfiguration,
  123. callbacks: LoaderCallbacks<T>
  124. ): void;
  125. /**
  126. * `getCacheAge()` is called by hls.js to get the duration that a given object
  127. * has been sitting in a cache proxy when playing live. If implemented,
  128. * this should return a value in seconds.
  129. *
  130. * For HTTP based loaders, this should return the contents of the "age" header.
  131. *
  132. * @returns time object being lodaded
  133. */
  134. getCacheAge?: () => number | null;
  135. context: T;
  136. stats: LoaderStats;
  137. }
  138.  
  139. export enum PlaylistContextType {
  140. MANIFEST = 'manifest',
  141. LEVEL = 'level',
  142. AUDIO_TRACK = 'audioTrack',
  143. SUBTITLE_TRACK = 'subtitleTrack',
  144. }
  145.  
  146. export enum PlaylistLevelType {
  147. MAIN = 'main',
  148. AUDIO = 'audio',
  149. SUBTITLE = 'subtitle',
  150. }
  151.  
  152. export interface PlaylistLoaderContext extends LoaderContext {
  153. loader?: Loader<PlaylistLoaderContext>;
  154.  
  155. type: PlaylistContextType;
  156. // the level index to load
  157. level: number | null;
  158. // level or track id from LevelLoadingData / TrackLoadingData
  159. id: number | null;
  160. // track group id
  161. groupId: string | null;
  162. // defines if the loader is handling a sidx request for the playlist
  163. isSidxRequest?: boolean;
  164. // internal representation of a parsed m3u8 level playlist
  165. levelDetails?: LevelDetails;
  166. // Blocking playlist request delivery directives (or null id none were added to playlist url
  167. deliveryDirectives: HlsUrlParameters | null;
  168. }