├── .airtap.yml
├── .gitignore
├── .npmignore
├── .travis.yml
├── LICENSE
├── README.md
├── index.js
├── package.json
└── test
    ├── basic.js
    ├── package.json
    └── test.mp4


/.airtap.yml:
--------------------------------------------------------------------------------
 1 | sauce_connect: true
 2 | loopback: airtap.local
 3 | browsers:
 4 |   - name: chrome
 5 |     version: latest
 6 |   - name: firefox
 7 |     version: latest
 8 |   - name: safari
 9 |     version: latest
10 |   - name: microsoftedge
11 |     version: latest
12 |   - name: android
13 |     version: latest
14 |   - name: iphone
15 |     version: latest
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | .airtap.yml
2 | .travis.yml
3 | test/
4 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: node_js
 2 | node_js:
 3 |   - lts/*
 4 | addons:
 5 |   sauce_connect: true
 6 |   hosts:
 7 |     - airtap.local
 8 | env:
 9 |   global:
10 |   - secure: mA8liwK511sAY/bepFwFl0qDM/WCrPSOGnwzjOJLf1cUT/kGIZ4uJah91g0zH1Afdq11zZN4QHZIBA8jA4oOPNJPNTeULf3UPkg7pvC3aTbVFLr1AVd/KvHDdnlLUUJ8QtiR5y70XRxcizZ6E3TeO3mwm13u+YIYhP4BdBD5JKxZhV5AFvwOshch0VQb90TN3E8g3PV6czJlh3CZ5rcFEDzXVZUxflDW8oaaachdEprjxj+sQSVP7cQZdcDdqoMzbxcpB6EneUcy7kqLqj6FNxfkZ+TgvyniDawjtsu4D3k0JaWJqdP+Urs9/Aqz2qtGBkR9eB3GVJNY+cXtZmnyyrJLv1HaXywm/NmLsK6bDQ+smMSTuOwryn9yar47E3r55LSiPaWJS+Xkt6CKSMHUzOEb2MC5oZRXad5eneeTM4eiVh03DrbpP7XNV4NyfPTl0wgVaXWf1tjbJVrVNVTfkXRBLVqvUknh1oi1We1pIQtVdMc2n3ObMWPwZCyzOr40nyIwpCKqP/O721xWbFOUXOl7HS3eFfheMMyTPqgg/Uo6+EXYoBkCpX+13o+6VnrmfXcG20fAWYK7l7UgR3KmIGxuiFbrZVgPdTRsdQP/7bKilIi6MJrMkVDOcbTnD9tl103LQZoJ5n++4X/KxjRoubwoNxSJzw2V1CZmUpBbUAo=
11 |   - secure: WzNEtVpO4sZkAKSpKshm1HL3Z9CZ89BU1Qwv8kVDcUAy+6iKSMZLXQmmeCkWUfPWXkXupF1oAOBjKrtvt3Q19JRrwcEeED9keRc+wE3NeJcpZ4dB7a/d1IbhTK4rym0S+yqYNWDGpGwQxrmTg9n0CyUZUVtslbv355yCpq9wRUtHI2qfxPiVmUIfMivVAJ73KHfOo/X3OrRm4Ibo1Fbeem/9VcIfViMB6d48kk6mT74GQANf3bRHmkIXZ/eqLo4f3A1hB0m1sObqt7d9SmGnmRDMFXMgUXnkrHQ1Vu+cGhV+bDueKkKGYvTdPd9Bfb73AaZQR+thxfft2c4ZJPClxjBkeCG/kqXfK7uOhFkDglyqTlDywzKtJl/8jgV1RVk7+t9NlK7ynPJyPgqobZSItN428vLgVPzN46YHnctKEqIz+oVNj4O9PCQhEeEFRMFoS2syruzGMFR5eeFR+WxzADAJDZG3XWyiGwQL9akNF501EKH2oAtKxtU9hFmsz0/eS+3yhlhl2VVSsuMsZ+T+KpJm/2aeMB2qfA2t3DQSdaaz7zZNwOhlq0Z1uM2XlkmyWhq91OyyDELM1iwI1N4pnGMDryqPjYdEezFAxYiBWDi2792EZ+9MesAkdktAmOcRTs7yLrxGMupy2wKfSYz/j6CjAu7oJEpFFF2RFGjvDDE=
12 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) Feross Aboukhadijeh
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 6 | this software and associated documentation files (the "Software"), to deal in
 7 | the Software without restriction, including without limitation the rights to
 8 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 9 | the Software, and to permit persons to whom the Software is furnished to do so,
10 | subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
17 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
18 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
19 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
20 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
21 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # mediasource [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
  2 | 
  3 | [travis-image]: https://img.shields.io/travis/feross/mediasource/master.svg
  4 | [travis-url]: https://travis-ci.org/feross/mediasource
  5 | [npm-image]: https://img.shields.io/npm/v/mediasource.svg
  6 | [npm-url]: https://npmjs.org/package/mediasource
  7 | [downloads-image]: https://img.shields.io/npm/dm/mediasource.svg
  8 | [downloads-url]: https://npmjs.org/package/mediasource
  9 | [standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
 10 | [standard-url]: https://standardjs.com
 11 | 
 12 | ### MediaSource API as a node.js Writable stream
 13 | 
 14 | [![Sauce Test Status](https://saucelabs.com/browser-matrix/mediasource.svg)](https://saucelabs.com/u/mediasource)
 15 | 
 16 | Stream video/audio into a `<video>` or `<audio>` tag by attaching node.js Writable streams.
 17 | 
 18 | This package is used by [WebTorrent](http://webtorrent.io) (along with other approaches)
 19 | to support media streaming.
 20 | 
 21 | ## install
 22 | 
 23 | ```
 24 | npm install mediasource
 25 | ```
 26 | 
 27 | ## usage
 28 | 
 29 | ```js
 30 | var MediaElementWrapper = require('mediasource')
 31 | 
 32 | function createElem (tagName) {
 33 |   var elem = document.createElement(tagName)
 34 |   elem.controls = true
 35 |   elem.autoplay = true // for chrome
 36 |   elem.play() // for firefox
 37 |   document.body.appendChild(elem)
 38 |   return elem
 39 | }
 40 | 
 41 | var elem = createElem('video')
 42 | 
 43 | var readable = // ... get a readable stream from somewhere
 44 | var wrapper = new MediaElementWrapper(elem)
 45 | // The correct mime type, including codecs, must be provided
 46 | var writable = wrapper.createWriteStream('video/webm; codecs="vorbis, vp8"')
 47 | 
 48 | elem.addEventListener('error', function () {
 49 |   // listen for errors on the video/audio element directly
 50 |   var errorCode = elem.error
 51 |   var detailedError = wrapper.detailedError
 52 |   // wrapper.detailedError will often have a more detailed error message
 53 | })
 54 | 
 55 | writable.on('error', function (err) {
 56 |   // listening to the stream 'error' event is optional
 57 | })
 58 | 
 59 | readable.pipe(writable)
 60 | 
 61 | // media should start playing now!
 62 | ```
 63 | 
 64 | ### advanced usage
 65 | 
 66 | `wrapper.createWriteStream()` can be called multiple times if different tracks (e.g. audio and video) need to
 67 | be passed in separate streams. Each call should be made with the correct mime type.
 68 | 
 69 | Instead of a mime type, an existing MediaSourceStream (as returned by `wrapper.createWriteStream()`) can be
 70 | passed as the single argument to `wrapper.createWriteStream()`, which will cause the existing stream to be
 71 | replaced by the newly returned stream. This is useful when you want to cancel the existing stream
 72 | and replace it with a new one, e.g. when seeking.
 73 | 
 74 | ### should one use this package?
 75 | 
 76 | Naively using this package will not work for many video formats, nor will it support
 77 | seeking. For an approach that is more likely to work for all video files, and
 78 | supports seeking, take a look at
 79 | [videostream](https://github.com/jhiesey/videostream).
 80 | 
 81 | Or for a package that tries multiple approaches, including `videostream` and this
 82 | package (`mediasource`), as well as a Blob API (non-streaming) approach, and works
 83 | for many non-video file types, consider
 84 | [render-media](https://github.com/feross/render-media).
 85 | 
 86 | ### options
 87 | 
 88 | #### opts.bufferDuration
 89 | 
 90 | Specify how many seconds of media should be put into the browser's buffer before applying backpressure.
 91 | 
 92 | ### errors
 93 | 
 94 | Handle errors by listening to the `'error'` event on the `<video>` or `<audio>` tag.
 95 | 
 96 | Some (but not all) errors will also cause `wrapper.detailedError` to be set to an error value that has
 97 | a more informative error message.
 98 | 
 99 | ## license
100 | 
101 | MIT. Copyright (c) [Feross Aboukhadijeh](http://feross.org).
102 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
  1 | /*! mediasource. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
  2 | module.exports = MediaElementWrapper
  3 | 
  4 | var inherits = require('inherits')
  5 | var stream = require('readable-stream')
  6 | var toArrayBuffer = require('to-arraybuffer')
  7 | 
  8 | var MediaSource = typeof window !== 'undefined' && window.MediaSource
  9 | 
 10 | var DEFAULT_BUFFER_DURATION = 60 // seconds
 11 | 
 12 | function MediaElementWrapper (elem, opts) {
 13 |   var self = this
 14 |   if (!(self instanceof MediaElementWrapper)) return new MediaElementWrapper(elem, opts)
 15 | 
 16 |   if (!MediaSource) throw new Error('web browser lacks MediaSource support')
 17 | 
 18 |   if (!opts) opts = {}
 19 |   self._debug = opts.debug
 20 |   self._bufferDuration = opts.bufferDuration || DEFAULT_BUFFER_DURATION
 21 |   self._elem = elem
 22 |   self._mediaSource = new MediaSource()
 23 |   self._streams = []
 24 |   self.detailedError = null
 25 | 
 26 |   self._errorHandler = function () {
 27 |     self._elem.removeEventListener('error', self._errorHandler)
 28 |     var streams = self._streams.slice()
 29 |     streams.forEach(function (stream) {
 30 |       stream.destroy(self._elem.error)
 31 |     })
 32 |   }
 33 |   self._elem.addEventListener('error', self._errorHandler)
 34 | 
 35 |   self._elem.src = window.URL.createObjectURL(self._mediaSource)
 36 | }
 37 | 
 38 | /*
 39 |  * `obj` can be a previous value returned by this function
 40 |  * or a string
 41 |  */
 42 | MediaElementWrapper.prototype.createWriteStream = function (obj) {
 43 |   var self = this
 44 | 
 45 |   return new MediaSourceStream(self, obj)
 46 | }
 47 | 
 48 | /*
 49 |  * Use to trigger an error on the underlying media element
 50 |  */
 51 | MediaElementWrapper.prototype.error = function (err) {
 52 |   var self = this
 53 | 
 54 |   // be careful not to overwrite any existing detailedError values
 55 |   if (!self.detailedError) {
 56 |     self.detailedError = err
 57 |   }
 58 |   self._dumpDebugData()
 59 |   try {
 60 |     self._mediaSource.endOfStream('decode')
 61 |   } catch (err) {}
 62 | 
 63 |   try {
 64 |     // Attempt to clean up object URL
 65 |     window.URL.revokeObjectURL(self._elem.src)
 66 |   } catch (err) {}
 67 | }
 68 | 
 69 | /*
 70 |  * When self._debug is set, dump all data to files
 71 |  */
 72 | MediaElementWrapper.prototype._dumpDebugData = function () {
 73 |   var self = this
 74 | 
 75 |   if (self._debug) {
 76 |     self._debug = false // prevent multiple dumps on multiple errors
 77 |     self._streams.forEach(function (stream, i) {
 78 |       downloadBuffers(stream._debugBuffers, 'mediasource-stream-' + i)
 79 |     })
 80 |   }
 81 | }
 82 | 
 83 | inherits(MediaSourceStream, stream.Writable)
 84 | 
 85 | function MediaSourceStream (wrapper, obj) {
 86 |   var self = this
 87 |   stream.Writable.call(self)
 88 | 
 89 |   self._wrapper = wrapper
 90 |   self._elem = wrapper._elem
 91 |   self._mediaSource = wrapper._mediaSource
 92 |   self._allStreams = wrapper._streams
 93 |   self._allStreams.push(self)
 94 |   self._bufferDuration = wrapper._bufferDuration
 95 |   self._sourceBuffer = null
 96 |   self._debugBuffers = []
 97 | 
 98 |   self._openHandler = function () {
 99 |     self._onSourceOpen()
100 |   }
101 |   self._flowHandler = function () {
102 |     self._flow()
103 |   }
104 |   self._errorHandler = function (err) {
105 |     if (!self.destroyed) {
106 |       self.emit('error', err)
107 |     }
108 |   }
109 | 
110 |   if (typeof obj === 'string') {
111 |     self._type = obj
112 |     // Need to create a new sourceBuffer
113 |     if (self._mediaSource.readyState === 'open') {
114 |       self._createSourceBuffer()
115 |     } else {
116 |       self._mediaSource.addEventListener('sourceopen', self._openHandler)
117 |     }
118 |   } else if (obj._sourceBuffer === null) {
119 |     obj.destroy()
120 |     self._type = obj._type // The old stream was created but hasn't finished initializing
121 |     self._mediaSource.addEventListener('sourceopen', self._openHandler)
122 |   } else if (obj._sourceBuffer) {
123 |     obj.destroy()
124 |     self._type = obj._type
125 |     self._sourceBuffer = obj._sourceBuffer // Copy over the old sourceBuffer
126 |     self._debugBuffers = obj._debugBuffers // Copy over previous debug data
127 |     self._sourceBuffer.addEventListener('updateend', self._flowHandler)
128 |     self._sourceBuffer.addEventListener('error', self._errorHandler)
129 |   } else {
130 |     throw new Error('The argument to MediaElementWrapper.createWriteStream must be a string or a previous stream returned from that function')
131 |   }
132 | 
133 |   self._elem.addEventListener('timeupdate', self._flowHandler)
134 | 
135 |   self.on('error', function (err) {
136 |     self._wrapper.error(err)
137 |   })
138 | 
139 |   self.on('finish', function () {
140 |     if (self.destroyed) return
141 |     self._finished = true
142 |     if (self._allStreams.every(function (other) { return other._finished })) {
143 |       self._wrapper._dumpDebugData()
144 |       try {
145 |         self._mediaSource.endOfStream()
146 |       } catch (err) {}
147 |     }
148 |   })
149 | }
150 | 
151 | MediaSourceStream.prototype._onSourceOpen = function () {
152 |   var self = this
153 |   if (self.destroyed) return
154 | 
155 |   self._mediaSource.removeEventListener('sourceopen', self._openHandler)
156 |   self._createSourceBuffer()
157 | }
158 | 
159 | MediaSourceStream.prototype.destroy = function (err) {
160 |   var self = this
161 |   if (self.destroyed) return
162 |   self.destroyed = true
163 | 
164 |   // Remove from allStreams
165 |   self._allStreams.splice(self._allStreams.indexOf(self), 1)
166 | 
167 |   self._mediaSource.removeEventListener('sourceopen', self._openHandler)
168 |   self._elem.removeEventListener('timeupdate', self._flowHandler)
169 |   if (self._sourceBuffer) {
170 |     self._sourceBuffer.removeEventListener('updateend', self._flowHandler)
171 |     self._sourceBuffer.removeEventListener('error', self._errorHandler)
172 |     if (self._mediaSource.readyState === 'open') {
173 |       self._sourceBuffer.abort()
174 |     }
175 |   }
176 | 
177 |   if (err) self.emit('error', err)
178 |   self.emit('close')
179 | }
180 | 
181 | MediaSourceStream.prototype._createSourceBuffer = function () {
182 |   var self = this
183 |   if (self.destroyed) return
184 | 
185 |   if (MediaSource.isTypeSupported(self._type)) {
186 |     self._sourceBuffer = self._mediaSource.addSourceBuffer(self._type)
187 |     self._sourceBuffer.addEventListener('updateend', self._flowHandler)
188 |     self._sourceBuffer.addEventListener('error', self._errorHandler)
189 |     if (self._cb) {
190 |       var cb = self._cb
191 |       self._cb = null
192 |       cb()
193 |     }
194 |   } else {
195 |     self.destroy(new Error('The provided type is not supported'))
196 |   }
197 | }
198 | 
199 | MediaSourceStream.prototype._write = function (chunk, encoding, cb) {
200 |   var self = this
201 |   if (self.destroyed) return
202 |   if (!self._sourceBuffer) {
203 |     self._cb = function (err) {
204 |       if (err) return cb(err)
205 |       self._write(chunk, encoding, cb)
206 |     }
207 |     return
208 |   }
209 | 
210 |   if (self._sourceBuffer.updating) {
211 |     return cb(new Error('Cannot append buffer while source buffer updating'))
212 |   }
213 | 
214 |   var arr = toArrayBuffer(chunk)
215 |   if (self._wrapper._debug) {
216 |     self._debugBuffers.push(arr)
217 |   }
218 | 
219 |   try {
220 |     self._sourceBuffer.appendBuffer(arr)
221 |   } catch (err) {
222 |     // appendBuffer can throw for a number of reasons, most notably when the data
223 |     // being appended is invalid or if appendBuffer is called after another error
224 |     // already occurred on the media element. In Chrome, there may be useful debugging
225 |     // info in chrome://media-internals
226 |     self.destroy(err)
227 |     return
228 |   }
229 |   self._cb = cb
230 | }
231 | 
232 | MediaSourceStream.prototype._flow = function () {
233 |   var self = this
234 | 
235 |   if (self.destroyed || !self._sourceBuffer || self._sourceBuffer.updating) {
236 |     return
237 |   }
238 | 
239 |   if (self._mediaSource.readyState === 'open') {
240 |     // check buffer size
241 |     if (self._getBufferDuration() > self._bufferDuration) {
242 |       return
243 |     }
244 |   }
245 | 
246 |   if (self._cb) {
247 |     var cb = self._cb
248 |     self._cb = null
249 |     cb()
250 |   }
251 | }
252 | 
253 | // TODO: if zero actually works in all browsers, remove the logic associated with this below
254 | var EPSILON = 0
255 | 
256 | MediaSourceStream.prototype._getBufferDuration = function () {
257 |   var self = this
258 | 
259 |   var buffered = self._sourceBuffer.buffered
260 |   var currentTime = self._elem.currentTime
261 |   var bufferEnd = -1 // end of the buffer
262 |   // This is a little over complex because some browsers seem to separate the
263 |   // buffered region into multiple sections with slight gaps.
264 |   for (var i = 0; i < buffered.length; i++) {
265 |     var start = buffered.start(i)
266 |     var end = buffered.end(i) + EPSILON
267 | 
268 |     if (start > currentTime) {
269 |       // Reached past the joined buffer
270 |       break
271 |     } else if (bufferEnd >= 0 || currentTime <= end) {
272 |       // Found the start/continuation of the joined buffer
273 |       bufferEnd = end
274 |     }
275 |   }
276 | 
277 |   var bufferedTime = bufferEnd - currentTime
278 |   if (bufferedTime < 0) {
279 |     bufferedTime = 0
280 |   }
281 | 
282 |   return bufferedTime
283 | }
284 | 
285 | function downloadBuffers (bufs, name) {
286 |   var a = document.createElement('a')
287 |   a.href = window.URL.createObjectURL(new window.Blob(bufs))
288 |   a.download = name
289 |   a.click()
290 | }
291 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "mediasource",
 3 |   "description": "MediaSource API as a node.js Writable stream",
 4 |   "version": "2.4.0",
 5 |   "author": {
 6 |     "name": "Feross Aboukhadijeh",
 7 |     "email": "feross@feross.org",
 8 |     "url": "https://feross.org"
 9 |   },
10 |   "bugs": {
11 |     "url": "https://github.com/feross/mediasource/issues"
12 |   },
13 |   "dependencies": {
14 |     "inherits": "^2.0.4",
15 |     "readable-stream": "^3.6.0",
16 |     "to-arraybuffer": "^1.0.1"
17 |   },
18 |   "devDependencies": {
19 |     "airtap": "^3.0.0",
20 |     "brfs": "^2.0.2",
21 |     "standard": "*",
22 |     "tape": "^5.0.1"
23 |   },
24 |   "homepage": "https://github.com/feross/mediasource",
25 |   "keywords": [
26 |     "mediasource",
27 |     "media source",
28 |     "mediasource api",
29 |     "writable",
30 |     "write",
31 |     "stream",
32 |     "write stream",
33 |     "writable stream"
34 |   ],
35 |   "license": "MIT",
36 |   "main": "index.js",
37 |   "repository": {
38 |     "type": "git",
39 |     "url": "git://github.com/feross/mediasource.git"
40 |   },
41 |   "scripts": {
42 |     "test": "standard && airtap -- test/*.js",
43 |     "test-local": "airtap --local -- test/*.js"
44 |   },
45 |   "funding": [
46 |     {
47 |       "type": "github",
48 |       "url": "https://github.com/sponsors/feross"
49 |     },
50 |     {
51 |       "type": "patreon",
52 |       "url": "https://www.patreon.com/feross"
53 |     },
54 |     {
55 |       "type": "consulting",
56 |       "url": "https://feross.org/support"
57 |     }
58 |   ]
59 | }
60 | 


--------------------------------------------------------------------------------
/test/basic.js:
--------------------------------------------------------------------------------
 1 | var fs = require('fs')
 2 | var MediaElementWrapper = require('../')
 3 | var path = require('path')
 4 | var stream = require('stream')
 5 | var test = require('tape')
 6 | 
 7 | var FILE = fs.readFileSync(path.join(__dirname, 'test.mp4'))
 8 | var CODEC_TYPE = 'video/mp4; codecs="avc1.42e01e"'
 9 | 
10 | if (!window.MediaSource) {
11 |   test.only('MediaSource support', (t) => {
12 |     t.pass('browser lacks support')
13 |     t.end()
14 |   })
15 | }
16 | 
17 | test('basic test', function (t) {
18 |   t.plan(2)
19 | 
20 |   var elem = createElem('video')
21 |   var readable = new stream.PassThrough()
22 |   var wrapper = new MediaElementWrapper(elem)
23 |   var writable = wrapper.createWriteStream(CODEC_TYPE)
24 | 
25 |   readable.on('error', function (err) { t.fail(err) })
26 |   writable.on('error', function (err) { t.fail(err) })
27 |   elem.addEventListener('error', function (err) { t.fail(err) })
28 | 
29 |   elem.addEventListener('playing', function () {
30 |     t.pass('got the "playing" event')
31 |   })
32 | 
33 |   elem.addEventListener('progress', onProgress)
34 | 
35 |   function onProgress () {
36 |     t.pass('got a "progress" event')
37 |     elem.removeEventListener('progress', onProgress)
38 |   }
39 | 
40 |   readable.pipe(writable)
41 |   readable.write(FILE)
42 | })
43 | 
44 | // Don't fail when createWriteStream() is called twice before mediasource opens
45 | // See: https://github.com/feross/mediasource/pull/5
46 | test('call createWriteStream() twice immediately', function (t) {
47 |   t.plan(3)
48 | 
49 |   var elem = createElem('video')
50 |   var readable = new stream.PassThrough()
51 |   var wrapper = new MediaElementWrapper(elem)
52 | 
53 |   var writable = wrapper.createWriteStream(CODEC_TYPE)
54 | 
55 |   t.doesNotThrow(function () {
56 |     writable = wrapper.createWriteStream(writable)
57 |   })
58 | 
59 |   readable.on('error', function (err) { t.fail(err) })
60 |   writable.on('error', function (err) { t.fail(err) })
61 |   elem.addEventListener('error', function (err) { t.fail(err) })
62 | 
63 |   elem.addEventListener('playing', function () {
64 |     t.pass('got the "playing" event')
65 |   })
66 | 
67 |   elem.addEventListener('progress', onProgress)
68 | 
69 |   function onProgress () {
70 |     t.pass('got a "progress" event')
71 |     elem.removeEventListener('progress', onProgress)
72 |   }
73 | 
74 |   readable.pipe(writable)
75 |   readable.write(FILE)
76 | })
77 | 
78 | function createElem (tagName) {
79 |   var elem = document.createElement(tagName)
80 |   elem.controls = true
81 |   elem.muted = true // make autoplay work
82 |   elem.autoplay = true // for chrome
83 |   document.body.insertBefore(elem, document.body.firstChild)
84 |   return elem
85 | }
86 | 


--------------------------------------------------------------------------------
/test/package.json:
--------------------------------------------------------------------------------
1 | {
2 |   "name": "test",
3 |   "version": "0.0.0",
4 |   "browserify": {
5 |     "transform": ["brfs"]
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------
/test/test.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/feross/mediasource/b46c4ed02d98cb4203afc0f7c5487323085928e1/test/test.mp4


--------------------------------------------------------------------------------