# Source: html-media-source.js

    /**
     * @file html-media-source.js
     */
    import window from 'global/window';
    import document from 'global/document';
    import videojs from 'video.js';
    import VirtualSourceBuffer from './virtual-source-buffer';
    import {durationOfVideo} from './add-text-track-data';
    import {
      isAudioCodec,
      isVideoCodec,
      parseContentType,
      translateLegacyCodecs
    } from './codec-utils';

    /**
     * Our MediaSource implementation in HTML, mimics native
     * MediaSource where/if possible.
     *
     * @link https://developer.mozilla.org/en-US/docs/Web/API/MediaSource
     * @class HtmlMediaSource
     * @extends videojs.EventTarget
     */
    export default class HtmlMediaSource extends videojs.EventTarget {
      constructor() {
        super();
        let property;

        this.nativeMediaSource_ = new window.MediaSource();
        // delegate to the native MediaSource's methods by default
        for (property in this.nativeMediaSource_) {
          if (!(property in HtmlMediaSource.prototype) &&
              typeof this.nativeMediaSource_[property] === 'function') {
            this[property] = this.nativeMediaSource_[property].bind(this.nativeMediaSource_);
          }
        }

        // emulate `duration` and `seekable` until seeking can be
        // handled uniformly for live streams
        // see https://github.com/w3c/media-source/issues/5
        this.duration_ = NaN;
        Object.defineProperty(this, 'duration', {
          get() {
            if (this.duration_ === Infinity) {
              return this.duration_;
            }
            return this.nativeMediaSource_.duration;
          },
          set(duration) {
            this.duration_ = duration;
            if (duration !== Infinity) {
              this.nativeMediaSource_.duration = duration;
              return;
            }
          }
        });
        Object.defineProperty(this, 'seekable', {
          get() {
            if (this.duration_ === Infinity) {
              return videojs.createTimeRanges([[0, this.nativeMediaSource_.duration]]);
            }
            return this.nativeMediaSource_.seekable;
          }
        });

        Object.defineProperty(this, 'readyState', {
          get() {
            return this.nativeMediaSource_.readyState;
          }
        });

        Object.defineProperty(this, 'activeSourceBuffers', {
          get() {
            return this.activeSourceBuffers_;
          }
        });

        // the list of virtual and native SourceBuffers created by this
        // MediaSource
        this.sourceBuffers = [];

        this.activeSourceBuffers_ = [];

        /**
         * update the list of active source buffers based upon various
         * imformation from HLS and video.js
         *
         * @private
         */
        this.updateActiveSourceBuffers_ = () => {
          // Retain the reference but empty the array
          this.activeSourceBuffers_.length = 0;

          // If there is only one source buffer, then it will always be active and audio will
          // be disabled based on the codec of the source buffer
          if (this.sourceBuffers.length === 1) {
            let sourceBuffer = this.sourceBuffers[0];

            sourceBuffer.appendAudioInitSegment_ = true;
            sourceBuffer.audioDisabled_ = !sourceBuffer.audioCodec_;
            this.activeSourceBuffers_.push(sourceBuffer);
            return;
          }

          // There are 2 source buffers, a combined (possibly video only) source buffer and
          // and an audio only source buffer.
          // By default, the audio in the combined virtual source buffer is enabled
          // and the audio-only source buffer (if it exists) is disabled.
          let disableCombined = false;
          let disableAudioOnly = true;

          // TODO: maybe we can store the sourcebuffers on the track objects?
          // safari may do something like this
          for (let i = 0; i < this.player_.audioTracks().length; i++) {
            let track = this.player_.audioTracks()[i];

            if (track.enabled && track.kind !== 'main') {
              // The enabled track is an alternate audio track so disable the audio in
              // the combined source buffer and enable the audio-only source buffer.
              disableCombined = true;
              disableAudioOnly = false;
              break;
            }
          }

          this.sourceBuffers.forEach((sourceBuffer) => {
            /* eslinst-disable */
            // TODO once codecs are required, we can switch to using the codecs to determine
            //      what stream is the video stream, rather than relying on videoTracks
            /* eslinst-enable */

            sourceBuffer.appendAudioInitSegment_ = true;

            if (sourceBuffer.videoCodec_ && sourceBuffer.audioCodec_) {
              // combined
              sourceBuffer.audioDisabled_ = disableCombined;
            } else if (sourceBuffer.videoCodec_ && !sourceBuffer.audioCodec_) {
              // If the "combined" source buffer is video only, then we do not want
              // disable the audio-only source buffer (this is mostly for demuxed
              // audio and video hls)
              sourceBuffer.audioDisabled_ = true;
              disableAudioOnly = false;
            } else if (!sourceBuffer.videoCodec_ && sourceBuffer.audioCodec_) {
              // audio only
              sourceBuffer.audioDisabled_ = disableAudioOnly;
              if (disableAudioOnly) {
                return;
              }
            }

            this.activeSourceBuffers_.push(sourceBuffer);
          });
        };

        this.onPlayerMediachange_ = () => {
          this.sourceBuffers.forEach((sourceBuffer) => {
            sourceBuffer.appendAudioInitSegment_ = true;
          });
        };

        this.onHlsReset_ = () => {
          this.sourceBuffers.forEach((sourceBuffer) => {
            if (sourceBuffer.transmuxer_) {
              sourceBuffer.transmuxer_.postMessage({action: 'resetCaptions'});
            }
          });
        };

        this.onHlsSegmentTimeMapping_ = (event) => {
          this.sourceBuffers.forEach(buffer => buffer.timeMapping_ = event.mapping);
        };

        // Re-emit MediaSource events on the polyfill
        [
          'sourceopen',
          'sourceclose',
          'sourceended'
        ].forEach(function(eventName) {
          this.nativeMediaSource_.addEventListener(eventName, this.trigger.bind(this));
        }, this);

        // capture the associated player when the MediaSource is
        // successfully attached
        this.on('sourceopen', (event) => {
          // Get the player this MediaSource is attached to
          let video = document.querySelector('[src="' + this.url_ + '"]');

          if (!video) {
            return;
          }

          this.player_ = videojs(video.parentNode);

          // hls-reset is fired by videojs.Hls on to the tech after the main SegmentLoader
          // resets its state and flushes the buffer
          this.player_.tech_.on('hls-reset', this.onHlsReset_);
          // hls-segment-time-mapping is fired by videojs.Hls on to the tech after the main
          // SegmentLoader inspects an MTS segment and has an accurate stream to display
          // time mapping
          this.player_.tech_.on('hls-segment-time-mapping', this.onHlsSegmentTimeMapping_);

          if (this.player_.audioTracks && this.player_.audioTracks()) {
            this.player_.audioTracks().on('change', this.updateActiveSourceBuffers_);
            this.player_.audioTracks().on('addtrack', this.updateActiveSourceBuffers_);
            this.player_.audioTracks().on('removetrack', this.updateActiveSourceBuffers_);
          }

          this.player_.on('mediachange', this.onPlayerMediachange_);
        });

        this.on('sourceended', (event) => {
          let duration = durationOfVideo(this.duration);

          for (let i = 0; i < this.sourceBuffers.length; i++) {
            let sourcebuffer = this.sourceBuffers[i];
            let cues = sourcebuffer.metadataTrack_ && sourcebuffer.metadataTrack_.cues;

            if (cues && cues.length) {
              cues[cues.length - 1].endTime = duration;
            }
          }
        });

        // explicitly terminate any WebWorkers that were created
        // by SourceHandlers
        this.on('sourceclose', function(event) {
          this.sourceBuffers.forEach(function(sourceBuffer) {
            if (sourceBuffer.transmuxer_) {
              sourceBuffer.transmuxer_.terminate();
            }
          });

          this.sourceBuffers.length = 0;
          if (!this.player_) {
            return;
          }

          if (this.player_.audioTracks && this.player_.audioTracks()) {
            this.player_.audioTracks().off('change', this.updateActiveSourceBuffers_);
            this.player_.audioTracks().off('addtrack', this.updateActiveSourceBuffers_);
            this.player_.audioTracks().off('removetrack', this.updateActiveSourceBuffers_);
          }

          // We can only change this if the player hasn't been disposed of yet
          // because `off` eventually tries to use the el_ property. If it has
          // been disposed of, then don't worry about it because there are no
          // event handlers left to unbind anyway
          if (this.player_.el_) {
            this.player_.off('mediachange', this.onPlayerMediachange_);
            this.player_.tech_.off('hls-reset', this.onHlsReset_);
            this.player_.tech_.off('hls-segment-time-mapping', this.onHlsSegmentTimeMapping_);
          }
        });
      }

      /**
       * Add a range that that can now be seeked to.
       *
       * @param {Double} start where to start the addition
       * @param {Double} end where to end the addition
       * @private
       */
      addSeekableRange_(start, end) {
        let error;

        if (this.duration !== Infinity) {
          error = new Error('MediaSource.addSeekableRange() can only be invoked ' +
                            'when the duration is Infinity');
          error.name = 'InvalidStateError';
          error.code = 11;
          throw error;
        }

        if (end > this.nativeMediaSource_.duration ||
            isNaN(this.nativeMediaSource_.duration)) {
          this.nativeMediaSource_.duration = end;
        }
      }

      /**
       * Add a source buffer to the media source.
       *
       * @link https://developer.mozilla.org/en-US/docs/Web/API/MediaSource/addSourceBuffer
       * @param {String} type the content-type of the content
       * @return {Object} the created source buffer
       */
      addSourceBuffer(type) {
        let buffer;
        let parsedType = parseContentType(type);

        // Create a VirtualSourceBuffer to transmux MPEG-2 transport
        // stream segments into fragmented MP4s
        if ((/^(video|audio)\/mp2t$/i).test(parsedType.type)) {
          let codecs = [];

          if (parsedType.parameters && parsedType.parameters.codecs) {
            codecs = parsedType.parameters.codecs.split(',');
            codecs = translateLegacyCodecs(codecs);
            codecs = codecs.filter((codec) => {
              return (isAudioCodec(codec) || isVideoCodec(codec));
            });
          }

          if (codecs.length === 0) {
            codecs = ['avc1.4d400d', 'mp4a.40.2'];
          }

          buffer = new VirtualSourceBuffer(this, codecs);

          if (this.sourceBuffers.length !== 0) {
            // If another VirtualSourceBuffer already exists, then we are creating a
            // SourceBuffer for an alternate audio track and therefore we know that
            // the source has both an audio and video track.
            // That means we should trigger the manual creation of the real
            // SourceBuffers instead of waiting for the transmuxer to return data
            this.sourceBuffers[0].createRealSourceBuffers_();
            buffer.createRealSourceBuffers_();

            // Automatically disable the audio on the first source buffer if
            // a second source buffer is ever created
            this.sourceBuffers[0].audioDisabled_ = true;
          }
        } else {
          // delegate to the native implementation
          buffer = this.nativeMediaSource_.addSourceBuffer(type);
        }

        this.sourceBuffers.push(buffer);
        return buffer;
      }
    }