media-source | Media Source Extensions | Media library

It's not implemented yet. To see a full dump of stats check this sample

While not very up-to-date https://webrtc-stats.callstats.io/verify give a high-level overview of what statistics are implemented by different browsers.

It's a hack, but you could try using a ServiceWorker.

It would be possible for your ServiceWorker to attach the appropriate authentication headers, and then you don't have to do anything special or weird in your video player at all. You can continue to use a standard tag. Additionally, the browser gets to keep its own behavior for what ranges to request, and you won't have to go through the headaches and incompatibilities of Media Source Extensions.

See also: https://serviceworke.rs/strategy-cache-and-update.html

Note though that this isn't always going to work... there are times when that Service Worker isn't loaded (such as when the user does a shift+refresh).

1. That will handle packet loss and sequencing so protocol like RTP with RTCP is not used. Is that correct?

AJAX and Fetch are just JavaScript APIs for making HTTP requests. Web Socket is just an API and protocol extended from an initial HTTP request. HTTP uses TCP. TCP takes care of ensuring packets arrive and arrive in-order. So, yes, you won't need to worry about packet loss and such, but not because of MSE.

1. But this will result in delay so it cannot be truly used for real-time communication. Yes?

That depends entirely on your goals. It's a myth that TCP isn't fast, or that TCP increases general latency for every packet. What is true is that the initial 3-way handshake takes a few round trips. It's also true that if a packet does actually get dropped, the application sees latency as suddenly sharply increased until the packet is requested again and sent again.

If your goals are something like a telephony application where the loss of a packet or two is meaningless overall, then UDP is more appropriate. (In voice communications, we talk slow enough that if a few milliseconds of sound go missing, we can still decipher what was being said. Our spoken language is robust enough that if entire words get garbled or are silent, we can figure out the gist of what was being said from context.) It's also important that immediate continuity be kept for voice communications. The tradeoff is that realtime-ness is better than accuracy at any particular instant/packet.

However, if you're doing something, say a one-way stream, you might choose a protocol over TCP. In this case, it may be important to be as realtime as possible, but more important that the audio/video don't glitch out. Consider the Super Bowl, or some other large sporting event. It's a live event and important that it stays realtime. However, if the time reference for the viewer is only 3-5 seconds delayed from live, it's still "live" enough for the viewer. The viewer would be far more angry if the video glitched out and they missed something happening in the game, rather than if they were just behind a few seconds. Since it's one-way streaming and there is no communication feedback loop, the tradeoff for reliability and quality over extreme low latency makes sense.

1. There is no security/encryption requirement for MSE like in WebRTC (DTLS/SRTP). Yes?

MSE doesn't know or care how you get your data.

1. One cannot, for example, mix a remote audio source from MSE with an audio mediaStreamTrack from a RTCPeerConnection as they do not have any common param like CNAME (RTCP) or are part of the same mediastream). In other words, the world of MSE and WebRTC cannot mix unless synchronization is not important. Correct?

Mix, where? Synchronization, where? No matter what you do, if you have streams coming from different places... or even different devices without sync/gen lock, they're out of sync. However, if you can define a point of reference where you consider things "synchronized", then it's all good. You could, for example, have independent streams going into a server and the server uses its current timestamps to set everything up and distribute together via WebRTC.

How you do this, or what you do, depends on the specifics of your application.

There have been a number of times where I would like to implement a streaming version of a ".src" for image or video elements in JS, perhaps from a stream of bytes.

Use a Service Worker to respond with a Response with a ReadableStream as the body.

but I feel this is more generally a question about object URLs.

Object URLs really only represent immutable Blobs. The MediaStream object URL is a special case, not really applicable here, and a deprecated API as srcObject exists for media elements these days.

Create a Blob and then use URL.createObjectURL(). Unfortunately, this seems to be static - but perhaps there is a way to mutate the contents?

No, Blobs are immutable.

Create a MediaSource. However, this only works for video...

... or audio.

The difference lies in the success of the completion.

The update event is only fired when either the append or removal operations did succeed, while updateend is also fired when there has been an error while appending, or when the operation has been aborted.

Looking at your questions in turn:

1. It is the downloaded buffer - the decoded content is not available to the Javascript app level typically, and is not even available to the OS if it is an encrypted media stream and the device supports a secure media path. Assuming, the video is not encrypted there is nothing in theory to stop you decoding it yourself in Javascript, but it would obviously be slow. There are some ffmpeg ports to Javascript available (e.g. https://github.com/Kagami/ffmpeg.js/) but these will still be relatively slow.

2. Most HMTML5 players will include a way to manually or programatically set or limit the maximum resolution that the player requests from the resolutions available in the manifest. Different players may have different ABR algorithms also and some will include CPU as a factor in the algorithm. Some players may even support multiple or custom ABR algorithms so you can add you own criteria. If you want to see an example of an algorithm that allows for CPU look at the 'DroppedFramesRule' in DASH.js: https://github.com/Dash-Industry-Forum/dash.js/wiki/ABR-Logic

Therefore the parsing of this XML file should be the responsibility of the video player, not of the client's app.

So you are essentially trying to create a new schema for distributing video for an underlying player (whatever that might be, to deal with). This seems like client side logic. However, you want an answer so I'll try and give you one.

First, Extractor in ExoPlayer should not be used for parsing your XML, as per the docs:

Extracts media data from a container format.

This would be used for extracting the video data from a video container e.g. MP4.

In your scenario you probably want to look at something similar to the DashManifestParser who uses the ParsingLoadable.Parser whose responsibility it is to parse your input model. This ParsingLoadable.Parser is then used by MediaSource to get the information it needs for playback.

However, I would not recommend doing any of that. The best option for you in this scenario would be to create a Parser to grab the content Url and just pass that to an underlying player. You content Url will link to an MP4 container, perhaps DRM'd content etc, but all of that can be handled by the player just fine without adding all of this other complexity.

As for creating adverts, this can be done in a number of ways:

• Have a single player instance, swapping between content and adverts. Easy but then you need to keep track of position information and also you will have buffering when you switch.
• Have a single player instance but use ConcatenatingMediaSource, for this you would parse the xml create a MediaSource for the content and each advert, you then add these to the ConcatenatingMediaSource.
• Have a single player instance but use the AdsLoader provided by ExoPlayer. This is the best solution but the documentation is sadly lacking. For this you can provide a link to load adverts and a separate link to load content.

So. To summarise.

• Create a parser that can get the info you need from the XML i.e. content link and advert links.
• Create a player that creates a media source for the content and then media sources for the adverts, add these to the concatenating media source.

If you'd like to see how to do certain aspects I would suggest taking a look at our open source library that uses Exo-Player under the hood. We've even recently started to use an AdsLoader. https://github.com/novoda/no-player

onAppOpenAttribution is triggered every time you open the app from different deep-link (In your case the One-Link).

I can get params (campaign, media-source, etc...) of One-Link if my app does not install.

Right, 1st time the two callbacks are triggered onAppOpenAttribution and onConversionDataReceived.

But if my app was installed, launched and then I click on another One-Link to open my app

It can happen if you try to open the app from One-Link that not belongs to Appsflyer.

For example, this link (Universal Link) https://rndemotest.onelink.me/7y5s/f78c46d5 will give you a media source, campaign etc. through onAppOpenAttribution, where 7y5s is your One-Link ID defined in "ONELINK CONFIGURATION" section of the dashboard.

[EDIT]

Be sure you run latest AppsFlyer SDK version,

Deep linking with short links for iOS Universal Links or Android App Links is only supported from SDK version 4.8.0

Generally, you should get a response as {"link": ""} for Full link a.e. {"link":"https://abc.onelink.me/2347196006?pid=User%20invite&c=CMTT2019einvite&af_dp=abc%3A%2F%2F"}

For One-Link, you should get all inforamtion contains media source, ... .

BTW here is a code snippet example how to handle onAppOpenAttribution response: