Blame view

node_modules/videojs-contrib-media-sources/src/flash-transmuxer-worker.js 2.64 KB
2a09d1a4   liuqimichale   添加宜春 天水 宣化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
  /**
   * @file flash-transmuxer-worker.js
   */
  import window from 'global/window';
  import flv from 'mux.js/lib/flv';
  
  /**
   * Re-emits transmuxer events by converting them into messages to the
   * world outside the worker.
   *
   * @param {Object} transmuxer the transmuxer to wire events on
   * @private
   */
  const wireTransmuxerEvents = function(transmuxer) {
    transmuxer.on('data', function(segment) {
      window.postMessage({
        action: 'data',
        segment
      });
    });
  
    transmuxer.on('done', function(data) {
      window.postMessage({ action: 'done' });
    });
  };
  
  /**
   * All incoming messages route through this hash. If no function exists
   * to handle an incoming message, then we ignore the message.
   *
   * @class MessageHandlers
   * @param {Object} options the options to initialize with
   */
  class MessageHandlers {
    constructor(options) {
      this.options = options || {};
      this.init();
    }
  
    /**
     * initialize our web worker and wire all the events.
     */
    init() {
      if (this.transmuxer) {
        this.transmuxer.dispose();
      }
      this.transmuxer = new flv.Transmuxer(this.options);
      wireTransmuxerEvents(this.transmuxer);
    }
  
    /**
     * Adds data (a ts segment) to the start of the transmuxer pipeline for
     * processing.
     *
     * @param {ArrayBuffer} data data to push into the muxer
     */
    push(data) {
      // Cast array buffer to correct type for transmuxer
      let segment = new Uint8Array(data.data, data.byteOffset, data.byteLength);
  
      this.transmuxer.push(segment);
    }
  
    /**
     * Recreate the transmuxer so that the next segment added via `push`
     * start with a fresh transmuxer.
     */
    reset() {
      this.init();
    }
  
    /**
     * Forces the pipeline to finish processing the last segment and emit its
     * results.
     */
    flush() {
      this.transmuxer.flush();
    }
  
    resetCaptions() {
      this.transmuxer.resetCaptions();
    }
  
  }
  
  /**
   * Our web wroker interface so that things can talk to mux.js
   * that will be running in a web worker. The scope is passed to this by
   * webworkify.
   *
   * @param {Object} self the scope for the web worker
   */
  const FlashTransmuxerWorker = function(self) {
    self.onmessage = function(event) {
      if (event.data.action === 'init' && event.data.options) {
        this.messageHandlers = new MessageHandlers(event.data.options);
        return;
      }
  
      if (!this.messageHandlers) {
        this.messageHandlers = new MessageHandlers();
      }
  
      if (event.data && event.data.action && event.data.action !== 'init') {
        if (this.messageHandlers[event.data.action]) {
          this.messageHandlers[event.data.action](event.data);
        }
      }
    };
  };
  
  export default (self) => {
    return new FlashTransmuxerWorker(self);
  };