Source: transmuxer-worker.js

  1. /**
  2.  * @file transmuxer-worker.js
  3.  */
  5. /**
  6.  * videojs-contrib-media-sources
  7.  *
  8.  * Copyright (c) 2015 Brightcove
  9.  * All rights reserved.
  10.  *
  11.  * Handles communication between the browser-world and the mux.js
  12.  * transmuxer running inside of a WebWorker by exposing a simple
  13.  * message-based interface to a Transmuxer object.
  14.  */
  15. import window from 'global/window';
  16. import mp4 from 'mux.js/lib/mp4';
  18. /**
  19.  * Re-emits transmuxer events by converting them into messages to the
  20.  * world outside the worker.
  21.  *
  22.  * @param {Object} transmuxer the transmuxer to wire events on
  23.  * @private
  24.  */
  25. const wireTransmuxerEvents = function(transmuxer) {
  26.   transmuxer.on('data', function(segment) {
  27.     // transfer ownership of the underlying ArrayBuffer
  28.     // instead of doing a copy to save memory
  29.     // ArrayBuffers are transferable but generic TypedArrays are not
  30.     // @link https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers#Passing_data_by_transferring_ownership_(transferable_objects)
  31.     let initArray = segment.initSegment;
  33.     segment.initSegment = {
  34.       data: initArray.buffer,
  35.       byteOffset: initArray.byteOffset,
  36.       byteLength: initArray.byteLength
  37.     };
  39.     let typedArray = segment.data;
  41.     segment.data = typedArray.buffer;
  42.     window.postMessage({
  43.       action: 'data',
  44.       segment,
  45.       byteOffset: typedArray.byteOffset,
  46.       byteLength: typedArray.byteLength
  47.     }, [segment.data]);
  48.   });
  50.   if (transmuxer.captionStream) {
  51.     transmuxer.captionStream.on('data', function(caption) {
  52.       window.postMessage({
  53.         action: 'caption',
  54.         data: caption
  55.       });
  56.     });
  57.   }
  59.   transmuxer.on('done', function(data) {
  60.     window.postMessage({ action: 'done' });
  61.   });
  63.   transmuxer.on('gopInfo', function(gopInfo) {
  64.     window.postMessage({
  65.       action: 'gopInfo',
  66.       gopInfo
  67.     });
  68.   });
  69. };
  71. /**
  72.  * All incoming messages route through this hash. If no function exists
  73.  * to handle an incoming message, then we ignore the message.
  74.  *
  75.  * @class MessageHandlers
  76.  * @param {Object} options the options to initialize with
  77.  */
  78. class MessageHandlers {
  79.   constructor(options) {
  80.     this.options = options || {};
  81.     this.init();
  82.   }
  84.   /**
  85.    * initialize our web worker and wire all the events.
  86.    */
  87.   init() {
  88.     if (this.transmuxer) {
  89.       this.transmuxer.dispose();
  90.     }
  91.     this.transmuxer = new mp4.Transmuxer(this.options);
  92.     wireTransmuxerEvents(this.transmuxer);
  93.   }
  95.   /**
  96.    * Adds data (a ts segment) to the start of the transmuxer pipeline for
  97.    * processing.
  98.    *
  99.    * @param {ArrayBuffer} data data to push into the muxer
  100.    */
  101.   push(data) {
  102.     // Cast array buffer to correct type for transmuxer
  103.     let segment = new Uint8Array(data.data, data.byteOffset, data.byteLength);
  105.     this.transmuxer.push(segment);
  106.   }
  108.   /**
  109.    * Recreate the transmuxer so that the next segment added via `push`
  110.    * start with a fresh transmuxer.
  111.    */
  112.   reset() {
  113.     this.init();
  114.   }
  116.   /**
  117.    * Set the value that will be used as the `baseMediaDecodeTime` time for the
  118.    * next segment pushed in. Subsequent segments will have their `baseMediaDecodeTime`
  119.    * set relative to the first based on the PTS values.
  120.    *
  121.    * @param {Object} data used to set the timestamp offset in the muxer
  122.    */
  123.   setTimestampOffset(data) {
  124.     let timestampOffset = data.timestampOffset || 0;
  126.     this.transmuxer.setBaseMediaDecodeTime(Math.round(timestampOffset * 90000));
  127.   }
  129.   setAudioAppendStart(data) {
  130.     this.transmuxer.setAudioAppendStart(Math.ceil(data.appendStart * 90000));
  131.   }
  133.   /**
  134.    * Forces the pipeline to finish processing the last segment and emit it's
  135.    * results.
  136.    *
  137.    * @param {Object} data event data, not really used
  138.    */
  139.   flush(data) {
  140.     this.transmuxer.flush();
  141.   }
  143.   resetCaptions() {
  144.     this.transmuxer.resetCaptions();
  145.   }
  147.   alignGopsWith(data) {
  148.     this.transmuxer.alignGopsWith(data.gopsToAlignWith.slice());
  149.   }
  150. }
  152. /**
  153.  * Our web wroker interface so that things can talk to mux.js
  154.  * that will be running in a web worker. the scope is passed to this by
  155.  * webworkify.
  156.  *
  157.  * @param {Object} self the scope for the web worker
  158.  */
  159. const TransmuxerWorker = function(self) {
  160.   self.onmessage = function(event) {
  161.     if (event.data.action === 'init' && event.data.options) {
  162.       this.messageHandlers = new MessageHandlers(event.data.options);
  163.       return;
  164.     }
  166.     if (!this.messageHandlers) {
  167.       this.messageHandlers = new MessageHandlers();
  168.     }
  170.     if (event.data && event.data.action && event.data.action !== 'init') {
  171.       if (this.messageHandlers[event.data.action]) {
  172.         this.messageHandlers[event.data.action](event.data);
  173.       }
  174.     }
  175.   };
  176. };
  178. export default (self) => {
  179.   return new TransmuxerWorker(self);
  180. };