Merged in m3u-reduction-2 (pull request #349)

mjpeg-player: removed unused m3u hlsjs code

Approved-by: Saxon Milton

cmd/mjpeg-player/hlsjs/config.js

@@ -1,195 +1,33 @@
-/**
+/*
- * HLS config
+AUTHOR
- */
+  Trek Hopton <trek@ausocean.org>
 
-import AbrController from './controller/abr-controller';
+LICENSE
-import BufferController from './controller/buffer-controller';
+  This file is Copyright (C) 2020 the Australian Ocean Lab (AusOcean)
-import CapLevelController from './controller/cap-level-controller';
-import FPSController from './controller/fps-controller';
-import XhrLoader from './utils/xhr-loader';
-// import FetchLoader from './utils/fetch-loader';
 
-import AudioTrackController from './controller/audio-track-controller';
+  It is free software: you can redistribute it and/or modify them
-import AudioStreamController from './controller/audio-stream-controller';
+  under the terms of the GNU General Public License as published by the
+  Free Software Foundation, either version 3 of the License, or (at your
+  option) any later version.
 
-import * as Cues from './utils/cues';
+  It is distributed in the hope that it will be useful, but WITHOUT
-import TimelineController from './controller/timeline-controller';
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-import SubtitleTrackController from './controller/subtitle-track-controller';
+  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
-import { SubtitleStreamController } from './controller/subtitle-stream-controller';
+  for more details.
-import EMEController from './controller/eme-controller';
-import { requestMediaKeySystemAccess, MediaKeyFunc } from './utils/mediakeys-helper';
 
-type ABRControllerConfig = {
+  You should have received a copy of the GNU General Public License in gpl.txt.
-  abrEwmaFastLive: number,
+  If not, see http://www.gnu.org/licenses.
-  abrEwmaSlowLive: number,
-  abrEwmaFastVoD: number,
-  abrEwmaSlowVoD: number,
-  abrEwmaDefaultEstimate: number,
-  abrBandWidthFactor: number,
-  abrBandWidthUpFactor: number,
-  abrMaxWithRealBitrate: boolean,
-  maxStarvationDelay: number,
-  maxLoadingDelay: number,
-};
 
-export type BufferControllerConfig = {
+  For hls.js Copyright notice and license, see LICENSE file.
-  appendErrorMaxRetry: number,
+*/
-  liveDurationInfinity: boolean,
-  liveBackBufferLength: number,
-};
 
-type CapLevelControllerConfig = {
+import XhrLoader from './utils/xhr-loader.js';
-  capLevelToPlayerSize: boolean
-};
-
-export type EMEControllerConfig = {
-  licenseXhrSetup?: (xhr: XMLHttpRequest, url: string) => void,
-  emeEnabled: boolean,
-  widevineLicenseUrl?: string,
-  requestMediaKeySystemAccessFunc: MediaKeyFunc | null,
-};
-
-type FragmentLoaderConfig = {
-  fLoader: any, // TODO(typescript-loader): Once Loader is typed fill this in
-
-  fragLoadingTimeOut: number,
-  fragLoadingMaxRetry: number,
-  fragLoadingRetryDelay: number,
-  fragLoadingMaxRetryTimeout: number,
-};
-
-type FPSControllerConfig = {
-  capLevelOnFPSDrop: boolean,
-  fpsDroppedMonitoringPeriod: number,
-  fpsDroppedMonitoringThreshold: number,
-};
-
-type LevelControllerConfig = {
-  startLevel?: number
-};
-
-type MP4RemuxerConfig = {
-  stretchShortVideoTrack: boolean,
-  maxAudioFramesDrift: number,
-};
-
-type PlaylistLoaderConfig = {
-  pLoader: any, // TODO(typescript-loader): Once Loader is typed fill this in
-
-  manifestLoadingTimeOut: number,
-  manifestLoadingMaxRetry: number,
-  manifestLoadingRetryDelay: number,
-  manifestLoadingMaxRetryTimeout: number,
-
-  levelLoadingTimeOut: number,
-  levelLoadingMaxRetry: number,
-  levelLoadingRetryDelay: number,
-  levelLoadingMaxRetryTimeout: number
-};
-
-type StreamControllerConfig = {
-  autoStartLoad: boolean,
-  startPosition: number,
-  defaultAudioCodec?: string,
-  initialLiveManifestSize: number,
-  maxBufferLength: number,
-  maxBufferSize: number,
-  maxBufferHole: number,
-
-  lowBufferWatchdogPeriod: number,
-  highBufferWatchdogPeriod: number,
-  nudgeOffset: number,
-  nudgeMaxRetry: number,
-  maxFragLookUpTolerance: number,
-  liveSyncDurationCount: number,
-  liveMaxLatencyDurationCount: number,
-  liveSyncDuration?: number,
-  liveMaxLatencyDuration?: number,
-  maxMaxBufferLength: number,
-
-  startFragPrefetch: boolean,
-};
-
-type TimelineControllerConfig = {
-  cueHandler: any, // TODO(typescript-cues): Type once file is done
-  enableCEA708Captions: boolean,
-  enableWebVTT: boolean,
-  captionsTextTrack1Label: string,
-  captionsTextTrack1LanguageCode: string,
-  captionsTextTrack2Label: string,
-  captionsTextTrack2LanguageCode: string,
-};
-
-type TSDemuxerConfig = {
-  forceKeyFrameOnDiscontinuity: boolean,
-};
-
-export type HlsConfig =
-  {
-    debug: boolean,
-    enableWorker: boolean,
-    enableSoftwareAES: boolean,
-    minAutoBitrate: number,
-    loader: any, // TODO(typescript-xhrloader): Type once XHR is done
-    xhrSetup?: (xhr: XMLHttpRequest, url: string) => void,
-
-    // Alt Audio
-    audioStreamController?: any, // TODO(typescript-audiostreamcontroller): Type once file is done
-    audioTrackController?: any, // TODO(typescript-audiotrackcontroller): Type once file is done
-    // Subtitle
-    subtitleStreamController?: any, // TODO(typescript-subtitlestreamcontroller): Type once file is done
-    subtitleTrackController?: any, // TODO(typescript-subtitletrackcontroller): Type once file is done
-    timelineController?: any, // TODO(typescript-timelinecontroller): Type once file is done
-    // EME
-    emeController?: typeof EMEController,
-
-    abrController: any, // TODO(typescript-abrcontroller): Type once file is done
-    bufferController: typeof BufferController,
-    capLevelController: any, // TODO(typescript-caplevelcontroller): Type once file is done
-    fpsController: any, // TODO(typescript-fpscontroller): Type once file is done
-  } &
-  ABRControllerConfig &
-  BufferControllerConfig &
-  CapLevelControllerConfig &
-  EMEControllerConfig &
-  FPSControllerConfig &
-  FragmentLoaderConfig &
-  LevelControllerConfig &
-  MP4RemuxerConfig &
-  PlaylistLoaderConfig &
-  StreamControllerConfig &
-  Partial<TimelineControllerConfig> &
-  TSDemuxerConfig;
 
 // If possible, keep hlsDefaultConfig shallow
 // It is cloned whenever a new Hls instance is created, by keeping the config
 // shallow the properties are cloned, and we don't end up manipulating the default
-export const hlsDefaultConfig: HlsConfig = {
+export const hlsDefaultConfig = {
-  autoStartLoad: true, // used by stream-controller
   startPosition: -1, // used by stream-controller
-  defaultAudioCodec: void 0, // used by stream-controller
-  debug: false, // used by logger
-  capLevelOnFPSDrop: false, // used by fps-controller
-  capLevelToPlayerSize: false, // used by cap-level-controller
-  initialLiveManifestSize: 1, // used by stream-controller
-  maxBufferLength: 30, // used by stream-controller
-  maxBufferSize: 60 * 1000 * 1000, // used by stream-controller
-  maxBufferHole: 0.5, // used by stream-controller
-
-  lowBufferWatchdogPeriod: 0.5, // used by stream-controller
-  highBufferWatchdogPeriod: 3, // used by stream-controller
-  nudgeOffset: 0.1, // used by stream-controller
-  nudgeMaxRetry: 3, // used by stream-controller
-  maxFragLookUpTolerance: 0.25, // used by stream-controller
-  liveSyncDurationCount: 3, // used by stream-controller
-  liveMaxLatencyDurationCount: Infinity, // used by stream-controller
-  liveSyncDuration: void 0, // used by stream-controller
-  liveMaxLatencyDuration: void 0, // used by stream-controller
-  liveDurationInfinity: false, // used by buffer-controller
-  liveBackBufferLength: Infinity, // used by buffer-controller
-  maxMaxBufferLength: 600, // used by stream-controller
-  enableWorker: true, // used by demuxer
-  enableSoftwareAES: true, // used by decrypter
   manifestLoadingTimeOut: 10000, // used by playlist-loader
   manifestLoadingMaxRetry: 1, // used by playlist-loader
   manifestLoadingRetryDelay: 1000, // used by playlist-loader
@@ -203,62 +41,8 @@ export const hlsDefaultConfig: HlsConfig = {
   fragLoadingMaxRetry: 6, // used by fragment-loader
   fragLoadingRetryDelay: 1000, // used by fragment-loader
   fragLoadingMaxRetryTimeout: 64000, // used by fragment-loader
-  startFragPrefetch: false, // used by stream-controller
-  fpsDroppedMonitoringPeriod: 5000, // used by fps-controller
-  fpsDroppedMonitoringThreshold: 0.2, // used by fps-controller
-  appendErrorMaxRetry: 3, // used by buffer-controller
   loader: XhrLoader,
-  // loader: FetchLoader,
   fLoader: void 0, // used by fragment-loader
   pLoader: void 0, // used by playlist-loader
   xhrSetup: void 0, // used by xhr-loader
-  licenseXhrSetup: void 0, // used by eme-controller
+};
-  // fetchSetup: void 0,
-  abrController: AbrController,
-  bufferController: BufferController,
-  capLevelController: CapLevelController,
-  fpsController: FPSController,
-  stretchShortVideoTrack: false, // used by mp4-remuxer
-  maxAudioFramesDrift: 1, // used by mp4-remuxer
-  forceKeyFrameOnDiscontinuity: true, // used by ts-demuxer
-  abrEwmaFastLive: 3, // used by abr-controller
-  abrEwmaSlowLive: 9, // used by abr-controller
-  abrEwmaFastVoD: 3, // used by abr-controller
-  abrEwmaSlowVoD: 9, // used by abr-controller
-  abrEwmaDefaultEstimate: 5e5, // 500 kbps  // used by abr-controller
-  abrBandWidthFactor: 0.95, // used by abr-controller
-  abrBandWidthUpFactor: 0.7, // used by abr-controller
-  abrMaxWithRealBitrate: false, // used by abr-controller
-  maxStarvationDelay: 4, // used by abr-controller
-  maxLoadingDelay: 4, // used by abr-controller
-  minAutoBitrate: 0, // used by hls
-  emeEnabled: false, // used by eme-controller
-  widevineLicenseUrl: void 0, // used by eme-controller
-  requestMediaKeySystemAccessFunc: requestMediaKeySystemAccess, // used by eme-controller
-
-  // Dynamic Modules
-  ...timelineConfig(),
-  subtitleStreamController: (__USE_SUBTITLES__) ? SubtitleStreamController : void 0,
-  subtitleTrackController: (__USE_SUBTITLES__) ? SubtitleTrackController : void 0,
-  timelineController: (__USE_SUBTITLES__) ? TimelineController : void 0,
-  audioStreamController: (__USE_ALT_AUDIO__) ? AudioStreamController : void 0,
-  audioTrackController: (__USE_ALT_AUDIO__) ? AudioTrackController : void 0,
-  emeController: (__USE_EME_DRM__) ? EMEController : void 0
-};
-
-function timelineConfig (): TimelineControllerConfig {
-  if (!__USE_SUBTITLES__) {
-    // intentionally doing this over returning Partial<TimelineControllerConfig> above
-    // this has the added nice property of still requiring the object below to completely define all props.
-    return {} as any;
-  }
-  return {
-    cueHandler: Cues, // used by timeline-controller
-    enableCEA708Captions: true, // used by timeline-controller
-    enableWebVTT: true, // used by timeline-controller
-    captionsTextTrack1Label: 'English', // used by timeline-controller
-    captionsTextTrack1LanguageCode: 'en', // used by timeline-controller
-    captionsTextTrack2Label: 'Spanish', // used by timeline-controller
-    captionsTextTrack2LanguageCode: 'es' // used by timeline-controller
-  };
-}

cmd/mjpeg-player/hlsjs/events.js

@@ -1,110 +1,55 @@
+/*
+AUTHOR
+  Trek Hopton <trek@ausocean.org>
+
+LICENSE
+  This file is Copyright (C) 2020 the Australian Ocean Lab (AusOcean)
+
+  It is free software: you can redistribute it and/or modify them
+  under the terms of the GNU General Public License as published by the
+  Free Software Foundation, either version 3 of the License, or (at your
+  option) any later version.
+
+  It is distributed in the hope that it will be useful, but WITHOUT
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+  for more details.
+
+  You should have received a copy of the GNU General Public License in gpl.txt.
+  If not, see http://www.gnu.org/licenses.
+
+  For hls.js Copyright notice and license, see LICENSE file.
+*/
+
 /**
  * @readonly
  * @enum {string}
  */
 const HlsEvents = {
-  // fired before MediaSource is attaching to media element - data: { media }
-  MEDIA_ATTACHING: 'hlsMediaAttaching',
-  // fired when MediaSource has been succesfully attached to media element - data: { }
-  MEDIA_ATTACHED: 'hlsMediaAttached',
-  // fired before detaching MediaSource from media element - data: { }
-  MEDIA_DETACHING: 'hlsMediaDetaching',
-  // fired when MediaSource has been detached from media element - data: { }
-  MEDIA_DETACHED: 'hlsMediaDetached',
-  // fired when we buffer is going to be reset - data: { }
-  BUFFER_RESET: 'hlsBufferReset',
-  // fired when we know about the codecs that we need buffers for to push into - data: {tracks : { container, codec, levelCodec, initSegment, metadata }}
-  BUFFER_CODECS: 'hlsBufferCodecs',
-  // fired when sourcebuffers have been created - data: { tracks : tracks }
-  BUFFER_CREATED: 'hlsBufferCreated',
-  // fired when we append a segment to the buffer - data: { segment: segment object }
-  BUFFER_APPENDING: 'hlsBufferAppending',
-  // fired when we are done with appending a media segment to the buffer - data : { parent : segment parent that triggered BUFFER_APPENDING, pending : nb of segments waiting for appending for this segment parent}
-  BUFFER_APPENDED: 'hlsBufferAppended',
-  // fired when the stream is finished and we want to notify the media buffer that there will be no more data - data: { }
-  BUFFER_EOS: 'hlsBufferEos',
-  // fired when the media buffer should be flushed - data { startOffset, endOffset }
-  BUFFER_FLUSHING: 'hlsBufferFlushing',
-  // fired when the media buffer has been flushed - data: { }
-  BUFFER_FLUSHED: 'hlsBufferFlushed',
   // fired to signal that a manifest loading starts - data: { url : manifestURL}
   MANIFEST_LOADING: 'hlsManifestLoading',
   // fired after manifest has been loaded - data: { levels : [available quality levels], audioTracks : [ available audio tracks], url : manifestURL, stats : { trequest, tfirst, tload, mtime}}
   MANIFEST_LOADED: 'hlsManifestLoaded',
-  // fired after manifest has been parsed - data: { levels : [available quality levels], firstLevel : index of first quality level appearing in Manifest}
-  MANIFEST_PARSED: 'hlsManifestParsed',
-  // fired when a level switch is requested - data: { level : id of new level }
-  LEVEL_SWITCHING: 'hlsLevelSwitching',
-  // fired when a level switch is effective - data: { level : id of new level }
-  LEVEL_SWITCHED: 'hlsLevelSwitched',
   // fired when a level playlist loading starts - data: { url : level URL, level : id of level being loaded}
   LEVEL_LOADING: 'hlsLevelLoading',
   // fired when a level playlist loading finishes - data: { details : levelDetails object, level : id of loaded level, stats : { trequest, tfirst, tload, mtime} }
   LEVEL_LOADED: 'hlsLevelLoaded',
   // fired when a level's details have been updated based on previous details, after it has been loaded - data: { details : levelDetails object, level : id of updated level }
   LEVEL_UPDATED: 'hlsLevelUpdated',
-  // fired when a level's PTS information has been updated after parsing a fragment - data: { details : levelDetails object, level : id of updated level, drift: PTS drift observed when parsing last fragment }
-  LEVEL_PTS_UPDATED: 'hlsLevelPtsUpdated',
-  // fired to notify that audio track lists has been updated - data: { audioTracks : audioTracks }
-  AUDIO_TRACKS_UPDATED: 'hlsAudioTracksUpdated',
-  // fired when an audio track switching is requested - data: { id : audio track id }
-  AUDIO_TRACK_SWITCHING: 'hlsAudioTrackSwitching',
-  // fired when an audio track switch actually occurs - data: { id : audio track id }
-  AUDIO_TRACK_SWITCHED: 'hlsAudioTrackSwitched',
   // fired when an audio track loading starts - data: { url : audio track URL, id : audio track id }
   AUDIO_TRACK_LOADING: 'hlsAudioTrackLoading',
   // fired when an audio track loading finishes - data: { details : levelDetails object, id : audio track id, stats : { trequest, tfirst, tload, mtime } }
   AUDIO_TRACK_LOADED: 'hlsAudioTrackLoaded',
-  // fired to notify that subtitle track lists has been updated - data: { subtitleTracks : subtitleTracks }
-  SUBTITLE_TRACKS_UPDATED: 'hlsSubtitleTracksUpdated',
-  // fired when an subtitle track switch occurs - data: { id : subtitle track id }
-  SUBTITLE_TRACK_SWITCH: 'hlsSubtitleTrackSwitch',
   // fired when a subtitle track loading starts - data: { url : subtitle track URL, id : subtitle track id }
   SUBTITLE_TRACK_LOADING: 'hlsSubtitleTrackLoading',
   // fired when a subtitle track loading finishes - data: { details : levelDetails object, id : subtitle track id, stats : { trequest, tfirst, tload, mtime } }
   SUBTITLE_TRACK_LOADED: 'hlsSubtitleTrackLoaded',
-  // fired when a subtitle fragment has been processed - data: { success : boolean, frag : the processed frag }
-  SUBTITLE_FRAG_PROCESSED: 'hlsSubtitleFragProcessed',
-  // fired when the first timestamp is found - data: { id : demuxer id, initPTS: initPTS, frag : fragment object }
-  INIT_PTS_FOUND: 'hlsInitPtsFound',
   // fired when a fragment loading starts - data: { frag : fragment object }
   FRAG_LOADING: 'hlsFragLoading',
   // fired when a fragment loading is progressing - data: { frag : fragment object, { trequest, tfirst, loaded } }
   FRAG_LOAD_PROGRESS: 'hlsFragLoadProgress',
-  // Identifier for fragment load aborting for emergency switch down - data: { frag : fragment object }
-  FRAG_LOAD_EMERGENCY_ABORTED: 'hlsFragLoadEmergencyAborted',
   // fired when a fragment loading is completed - data: { frag : fragment object, payload : fragment payload, stats : { trequest, tfirst, tload, length } }
-  FRAG_LOADED: 'hlsFragLoaded',
+  FRAG_LOADED: 'hlsFragLoaded'
-  // fired when a fragment has finished decrypting - data: { id : demuxer id, frag: fragment object, payload : fragment payload, stats : { tstart, tdecrypt } }
-  FRAG_DECRYPTED: 'hlsFragDecrypted',
-  // fired when Init Segment has been extracted from fragment - data: { id : demuxer id, frag: fragment object, moov : moov MP4 box, codecs : codecs found while parsing fragment }
-  FRAG_PARSING_INIT_SEGMENT: 'hlsFragParsingInitSegment',
-  // fired when parsing sei text is completed - data: { id : demuxer id, frag: fragment object, samples : [ sei samples pes ] }
-  FRAG_PARSING_USERDATA: 'hlsFragParsingUserdata',
-  // fired when parsing id3 is completed - data: { id : demuxer id, frag: fragment object, samples : [ id3 samples pes ] }
-  FRAG_PARSING_METADATA: 'hlsFragParsingMetadata',
-  // fired when data have been extracted from fragment - data: { id : demuxer id, frag: fragment object, data1 : moof MP4 box or TS fragments, data2 : mdat MP4 box or null}
-  FRAG_PARSING_DATA: 'hlsFragParsingData',
-  // fired when fragment parsing is completed - data: { id : demuxer id, frag: fragment object }
-  FRAG_PARSED: 'hlsFragParsed',
-  // fired when fragment remuxed MP4 boxes have all been appended into SourceBuffer - data: { id : demuxer id, frag : fragment object, stats : { trequest, tfirst, tload, tparsed, tbuffered, length, bwEstimate } }
-  FRAG_BUFFERED: 'hlsFragBuffered',
-  // fired when fragment matching with current media position is changing - data : { id : demuxer id, frag : fragment object }
-  FRAG_CHANGED: 'hlsFragChanged',
-  // Identifier for a FPS drop event - data: { curentDropped, currentDecoded, totalDroppedFrames }
-  FPS_DROP: 'hlsFpsDrop',
-  // triggered when FPS drop triggers auto level capping - data: { level, droppedlevel }
-  FPS_DROP_LEVEL_CAPPING: 'hlsFpsDropLevelCapping',
-  // Identifier for an error event - data: { type : error type, details : error details, fatal : if true, hls.js cannot/will not try to recover, if false, hls.js will try to recover,other error specific data }
-  ERROR: 'hlsError',
-  // fired when hls.js instance starts destroying. Different from MEDIA_DETACHED as one could want to detach and reattach a media to the instance of hls.js to handle mid-rolls for example - data: { }
-  DESTROYING: 'hlsDestroying',
-  // fired when a decrypt key loading starts - data: { frag : fragment object }
-  KEY_LOADING: 'hlsKeyLoading',
-  // fired when a decrypt key loading is completed - data: { frag : fragment object, payload : key payload, stats : { trequest, tfirst, tload, length } }
-  KEY_LOADED: 'hlsKeyLoaded',
-  // fired upon stream controller state transitions - data: { previousState, nextState }
-  STREAM_STATE_TRANSITION: 'hlsStreamStateTransition'
 };
 
 export default HlsEvents;