stremiok 2.0.0 → 2.2.0

package/js/player-core.js

@@ -58,7 +58,8 @@ var PlayerParts = {};
         dur: 0,              // seconds
         cur: 0,              // seconds
         isLive: false,       // live stream (sports/IPTV): no fixed duration
-        playStarted: false,  // this AVPlay attempt reached playback (vs. failed early)
+        playStarted: false,  // this AVPlay attempt was prepared (opened, ready to play)
+        playing: false,      // ...and actually played: its position moved for a second (see oncurrentplaytime)
         // seek robustness (AVPlay can error if you seek mid-buffer)
         buffering: false,
         pendingSeek: null,
@@ -156,8 +157,14 @@ var PlayerParts = {};
 
     function isActive() { return S.active; }
 
-    function saveProgress() {
+    // fromTicker: the 5-second save while it plays: skipped when nothing moved since the last one
+    // (paused); a stop, a leave or a jump always saves.
+    var _savedSig = '';
+    function saveProgress(fromTicker) {
         if (!S.ctx || !S.dur || S.isLive || S.ctx.trailer || S.ctx.private || isNotice()) { return; }   // (a notice clip, private viewing: nothing saved, nothing removed)
+        var sig = progressKey(S.ctx) + '|' + Math.floor(S.cur) + '|' + Math.floor(S.dur);
+        if (fromTicker && sig === _savedSig) { return; }
+        _savedSig = sig;
         // Past the credits the episode is watched: its entry was removed and the next one
         // queued (handleCredits). Saving again would put it back next to the next episode.
         if (_creditsHandled) { return; }
@@ -292,15 +299,29 @@ var PlayerParts = {};
         } catch (er2) {}
         return out;
     }
+    // An IPTV channel's TV guide (js/epg.js): { now, next } or null.
+    function guideNow() { return (typeof EPG !== 'undefined' && S.ctx && /^iptv:/.test(S.ctx.id || '')) ? EPG.now(S.ctx.id) : null; }
+    function clock(sec) { var d = new Date(sec * 1000); return (d.getHours() < 10 ? '0' : '') + d.getHours() + ':' + (d.getMinutes() < 10 ? '0' : '') + d.getMinutes(); }
+    if (typeof EPG !== 'undefined' && EPG.onChange) { EPG.onChange(function () { if (S.active && S.isLive) { renderOSD(); } }); }
     function renderOSD() {
         U.byId('osd-title').textContent = S.ctx ? S.ctx.name : '';
+        var ck = U.byId('osd-clock');   // (the time of day, top right while the bar is on screen)
+        if (ck) { ck.textContent = clock(Date.now() / 1000); }
         renderTags();
         renderChapters();
         if (S.isLive) {
+            var cur = U.byId('osd-cur'), g = guideNow();
+            cur.className = 'live';
+            if (g && g.now) {   // an IPTV channel with a TV guide: what's on, how far along, and next
+                var t = Date.now() / 1000;
+                U.byId('osd-bar').style.display = '';
+                U.byId('osd-progress').style.width = Math.max(0, Math.min(100, Math.round((t - g.now.start) / (g.now.stop - g.now.start) * 100))) + '%';
+                cur.textContent = '● LIVE   ' + clock(g.now.start) + '–' + clock(g.now.stop) + '   ' + g.now.title;
+                U.byId('osd-dur').textContent = g.next ? 'Next  ' + clock(g.next.start) + '   ' + g.next.title : '';
+                return;
+            }
             U.byId('osd-bar').style.display = 'none';
-            var cur = U.byId('osd-cur');
             cur.textContent = '● LIVE';
-            cur.className = 'live';
             U.byId('osd-dur').textContent = '';
             return;
         }
@@ -324,6 +345,41 @@ var PlayerParts = {};
             yt: page, ytLang: lang, type: 'YouTube', id: 'yt_id:' + link.id, parent: 'yt_id:' + link.id, name: link.title || 'YouTube',
             poster: 'https://i.ytimg.com/vi/' + link.id + '/hqdefault.jpg', streams: [], private: !!(S.ctx && S.ctx.private) || undefined }, _onExit);   // (from a private one: private too)
     }
+    // ---------- a live Xtream channel's format ----------
+    // An Xtream server sends a channel as MPEG-TS (…/live/USER/PASS/123.ts) or as HLS (….m3u8).
+    // The menu's Format plays it the other way and keeps that for the channel (FORMAT_KEY, by its
+    // id, the last FORMAT_KEEP), so it starts that way next time; its playlist's own way isn't
+    // kept. ctx._ownUrl: the link as its playlist gives it.
+    var FORMAT_KEY = 'stremiok.liveformat', FORMAT_KEEP = 300;
+    var XT_LIVE = /^(https?:\/\/[^?#]+\/live\/[^\/?#]+\/[^\/?#]+\/[^\/?#.]+)\.(ts|m3u8)([?#].*)?$/i;
+    function liveFormat(url) { var m = XT_LIVE.exec(url || ''); return m ? (m[2].toLowerCase() === 'm3u8' ? 'hls' : 'ts') : ''; }
+    function withFormat(url, fmt) { var m = XT_LIVE.exec(url || ''); return m ? m[1] + '.' + (fmt === 'hls' ? 'm3u8' : 'ts') + (m[3] || '') : url; }
+    function formatStart(ctx) {
+        if (!S.isLive || !ctx.id || !liveFormat(ctx._ownUrl || ctx.url)) { return; }
+        if (!ctx._ownUrl) { ctx._ownUrl = ctx.url; }
+        var want = (U.store.get(FORMAT_KEY, {}) || {})[ctx.id];
+        ctx.url = (want === 'ts' || want === 'hls') ? withFormat(ctx._ownUrl, want) : ctx._ownUrl;
+    }
+    function setLiveFormat(fmt) {
+        var old = S.ctx;
+        if (!S.active || !old || !old._ownUrl || !liveFormat(old.url) || liveFormat(old.url) === fmt) { return; }
+        var all = U.store.get(FORMAT_KEY, {}) || {};
+        delete all[old.id];
+        if (fmt !== liveFormat(old._ownUrl)) {
+            all[old.id] = fmt;
+            var keys = Object.keys(all);
+            keys.slice(0, Math.max(0, keys.length - FORMAT_KEEP)).forEach(function (k) { delete all[k]; });   // (the oldest picked)
+        }
+        U.store.set(FORMAT_KEY, all);
+        var ctx = {};   // (the channel again, without what was learned from the other link: its relay, its look)
+        Object.keys(old).forEach(function (k) { if (!/^_(relay|relayFor|relayCc|ccOffer|liveChecked)$/.test(k)) { ctx[k] = old[k]; } });
+        ctx.switching = true;
+        play(ctx, _onExit);
+        U.spinner(true, 'Opening it as ' + (fmt === 'hls' ? 'HLS' : 'MPEG-TS') + '…');
+    }
+    P.liveFormat = function () { return S.active && S.ctx && S.isLive && S.ctx._ownUrl ? liveFormat(S.ctx.url) : ''; };
+    P.setLiveFormat = setLiveFormat;
+
     // Another source of what's playing (the player's source list): played in its place, at
     // the same point, as a playback of its own — its quality ladder, YouTube details,
     // captions, SponsorBlock sections, headers and file details are the new source's, and so
@@ -368,6 +424,7 @@ var PlayerParts = {};
         S.active = true; S.cur = 0; S.dur = 0; _bg = null; S.actual = null;
         // Stremio "tv" and "radio" types are strong live hints; refined after prepare.
         S.isLive = (ctx.type === 'tv' || ctx.type === 'radio') || /^iptv:/.test(ctx.id || '') || !!ctx.isLive;   // (an IPTV channel: live, a sports one too)
+        formatStart(ctx);
         S.ctx.resumeSec = (ctx.trailer || ctx.fromStart) ? 0 : (ctx.resumeSec || getResume(ctx.type, ctx.id));   // (Play from start: 0:00)
 
         // reset subtitle + audio + quality + on-screen controls state
@@ -376,7 +433,8 @@ var PlayerParts = {};
         resetQuality(ctx);
         resetControls();
         _stall = { t: -1, since: 0, bufSince: 0, recoveries: [] };
-        _prefetchedNext = false; S.playStarted = false;
+        recoReset();
+        _prefetchedNext = false; S.playStarted = false; S.playing = false;
         _segments = null; _creditsSec = null; _creditsHandled = false; _segmentsFor = null;
         S.buffering = false; S.pendingSeek = null; S.lastSeekAt = 0; S.settleFrom = 0; _seekRecovering = false; _jumpUndone = null; _pausedOnce = false;
         updateHint();
@@ -509,7 +567,7 @@ var PlayerParts = {};
         url = (S.ctx && S.ctx._relay && S.ctx._relayFor === url) ? S.ctx._relay : opened(url);   // (a live channel's sound repacked: see liveCheck)
         var token = ++_playToken;
         objEl.className = 'active';
-        S.playStarted = false;
+        S.playStarted = false; S.playing = false;
         _lastTickMs = null; _playedMs = 0;
         _tick = null; _pausedOnce = false;   // (a new open: the jump watch starts over, see checkJump)
         subsBeforeOpen();   // a built-in subtitle track is selected again once this attempt plays
@@ -564,6 +622,7 @@ var PlayerParts = {};
                     // Played, not just opened: a file can open and then fail (or show nothing)
                     if (_lastTickMs !== null && ms > _lastTickMs && ms - _lastTickMs < 1500) { _playedMs += ms - _lastTickMs; }
                     _lastTickMs = ms;
+                    if (!S.playing && _playedMs >= 1000) { S.playing = true; _reco.tries = 0; }   // (started: playing, not just opened; a reconnect's tries start over)
                     if (_playedMs >= 2000 && !isNotice()) { reportStart(true); }   // (a notice clip proves nothing about the format)
                     audioOnTick();
                     subsOnTick();
@@ -586,11 +645,15 @@ var PlayerParts = {};
                         setTimeout(function () { _seekRecovering = false; }, 4000);
                         return;
                     }
-                    // Failed before playback ever started → retry / step down / Auto.
-                    if (!S.playStarted && (relayFailed() || tryFallback())) { return; }
+                    // A live channel that played: its connection dropped → opened again (liveDropped).
+                    if (S.playing && liveReconnects()) { U.log('player', 'Playback error: ' + err + ' (' + where(S.ctx.url) + ')'); liveDropped('Connection lost'); return; }
+                    // A reconnect's try that didn't play → the next try.
+                    if (!S.playing && _reco.tries) { if (!relayFailed()) { liveDropped('Couldn’t reconnect'); } return; }
+                    // Failed before it ever played (opened, maybe, but nothing shown) → retry / step down / Auto.
+                    if (!S.playing && (relayFailed() || tryFallback())) { return; }
                     reportStart(false, err);   // (unless it had already played)
                     U.log('player', 'Playback error: ' + err + ' (' + where(S.ctx && S.ctx.url) + ')');
-                    if (!S.playStarted) { failedStart('Playback error: ' + err); return; }
+                    if (!S.playing) { failedStart('Playback error: ' + err); return; }
                     U.toast('Playback error: ' + err);
                     exitLater();
                 }
@@ -625,6 +688,7 @@ var PlayerParts = {};
                 if (!S.active || token !== _playToken) { return; }
                 U.spinner(false);
                 if (relayFailed()) { return; }
+                if (_reco.tries) { liveDropped('Couldn’t reconnect'); return; }   // (a reconnect's try: the next one)
                 // Prepare failed → retry / step down / Auto.
                 if (tryFallback()) { return; }
                 U.log('player', 'Could not open: ' + (err && (err.name || err.message || err)) + ' (' + where(url) + ')');
@@ -710,7 +774,7 @@ var PlayerParts = {};
         _ticker = setInterval(function () {
             if (inBackground()) { return; }   // (saved on the way there; nothing to watch until it's back)
             if (useAV) { try { S.cur = avplay.getCurrentTime() / 1000; } catch (e) {} onProgress(); checkStall(); }
-            saveProgress();
+            saveProgress(true);
         }, 5000);
     }
 
@@ -723,8 +787,8 @@ var PlayerParts = {};
         return !!S.ctx && !S.ctx.yt && !S.ctx.trailer && !S.isLive && (S.ctx.type === 'movie' || S.ctx.type === 'series') && S.dur > 0 && S.dur < NOTICE_MAX_S;
     }
     function onEnded() {
-        // a live channel whose stream ended (its server stopped it): opened again, as a stall is
-        if (S.isLive && S.ctx && !S.ctx.trailer && !S.ctx.yt) { recoverStall('The stream ended — opening the channel again…'); return; }
+        // a live channel whose stream ended (its server stopped it): opened again (liveDropped)
+        if (liveReconnects()) { liveDropped('The stream ended'); return; }
         if (isNotice()) {   // (back to its sources: another one, or this one later)
             U.toast('That source isn\'t ready yet (the debrid service is still getting it): try another, or this one later', 6000);
             exit();
@@ -834,6 +898,13 @@ var PlayerParts = {};
         if (_creditsHandled || !S.ctx || S.ctx.trailer || isNotice()) { return; }
         _creditsHandled = true;
         if (S.ctx.private) { return; }   // (private viewing: not marked watched, nothing queued)
+        // With Trakt: sent as a finish (Trakt's own way, which also clears a paused place it
+        // kept for it), not as a separate "watched"
+        if (S.dur > 0 && typeof Trakt !== 'undefined' && Trakt.onStopped && Trakt.isConnected && Trakt.isConnected()) {
+            markFinished(true);
+            Trakt.onStopped(S.ctx.type, S.ctx.id, S.cur, S.dur, S.ctx.name);
+            return;
+        }
         markFinished(false);
     }
     // Watched: off Continue Watching, the next episode queued. quiet: Trakt's been told another
@@ -937,7 +1008,7 @@ var PlayerParts = {};
     var NEXT_TRIES = 3, AV_START_MS = 45000, _openedAt = 0;
     function nextSourceOnFail(notice) {
         var c = S.ctx;
-        if (!c || !S.active || S.playStarted || S.isLive || c.trailer || c.yt || c.localFile || !c.stream || typeof c.nextSource !== 'function') { return false; }
+        if (!c || !S.active || S.playing || S.isLive || c.trailer || c.yt || c.localFile || !c.stream || typeof c.nextSource !== 'function') { return false; }
         if (typeof Stremio === 'undefined' || !Stremio.getPrefs || !Stremio.getPrefs().nextOnFail) { return false; }
         var tried = (c._tried || []).concat([Stremio.sourceId(c.stream)]);
         if (tried.length > NEXT_TRIES) { return false; }
@@ -1000,11 +1071,17 @@ var PlayerParts = {};
         else { n.text = svc + ' couldn’t give this file (' + addon + ': “' + kind.replace(/_/g, ' ') + '”)'; }
         return n;
     }
-    // Not started after AV_START_MS (no answer from the server): as a refusal, when there's a
-    // next source to try (otherwise it's left to go on waiting).
+    // Not playing after AV_START_MS (no answer from the server, or opened and nothing shown): the
+    // next source when there's one; else it stops and says so (not while you've paused it).
     function startCheck() {
-        if (!S.active || S.playStarted || !useAV || !_openedAt || Date.now() - _openedAt < AV_START_MS) { return; }
-        nextSourceOnFail();
+        if (!S.active || S.playing || !useAV || !_openedAt || Date.now() - _openedAt < AV_START_MS) { return; }
+        if (_reco.tries) { liveDropped('Couldn’t reconnect'); return; }   // (a reconnect's try: the next one)
+        if (nextSourceOnFail()) { return; }
+        if (S.playStarted && isPaused()) { return; }
+        U.log('player', 'Didn’t start: nothing played in ' + (AV_START_MS / 1000) + ' s (' + where(S.ctx && S.ctx.url) + ')');
+        U.spinner(false);
+        U.toast('Didn’t start: nothing played in ' + (AV_START_MS / 1000) + ' seconds. Try another source.', 6000);
+        exitLater();
     }
     P.startCheck = startCheck;
 
@@ -1014,6 +1091,11 @@ var PlayerParts = {};
     // cut that way, the channel restarts through the service's relay, which repacks the sound.
     // The answer is kept per link (LIVE_KEY, LIVE_DAYS): a channel known to need it starts
     // through the relay (startLive), one known not to isn't asked about again.
+    // The same look says which closed-caption channels (CC1–CC4) are in its picture (cc, kept
+    // with it once sure). They're offered in the subtitle menu (ctx._ccOffer); turned on (picked
+    // there, remembered for the channel, or in your default subtitle language), the channel plays
+    // through the relay with them as subtitle tracks (ctx._relayCc), the sound as it is unless it
+    // needs repacking too.
     var LIVE_KEY = 'stremiok.livefix', LIVE_KEEP = 300, LIVE_DAYS = 14;
     function liveFixable(ctx) {
         return useAV && S.isLive && !!ctx && !ctx.yt && !ctx.trailer && /^https?:\/\//i.test(ctx.url || '') &&
@@ -1023,22 +1105,45 @@ var PlayerParts = {};
         var k = (U.store.get(LIVE_KEY, {}) || {})[url];
         return (k && Date.now() - k.at < LIVE_DAYS * 86400000) ? k : null;
     }
-    function liveKeep(url, fix) {
+    // The caption channels kept for a link: [{ ch: 'CC1', lang: 'en' }], or null (not known yet).
+    function ccOf(k) {
+        if (!k || !Array.isArray(k.cc)) { return null; }
+        return k.cc.filter(function (c) { return c && /^CC[1-4]$/.test(c.ch) && (!c.lang || /^[a-z]{2,3}$/.test(c.lang)); }).slice(0, 4);
+    }
+    function liveKeep(url, fix, cc) {
         var all = U.store.get(LIVE_KEY, {}) || {};
         all[url] = { fix: fix ? 1 : 0, at: Date.now() };
+        if (cc) { all[url].cc = cc; }
         var keys = Object.keys(all);
         if (keys.length > LIVE_KEEP) {
             keys.sort(function (a, b) { return all[a].at - all[b].at; }).slice(0, keys.length - LIVE_KEEP).forEach(function (k) { delete all[k]; });
         }
         U.store.set(LIVE_KEY, all);
     }
+    // Captions on from the start: your choice for this channel (a closed-caption track picked
+    // there last), else one in your default subtitle language (or second choice).
+    function ccWanted(ctx, cc) {
+        if (!cc || !cc.length) { return false; }
+        var mem = P.recallSub(ctx.id);
+        if (mem) { return !!mem.embedded; }
+        var cfg = P.getSubCfg(), langs = [cfg.lang, cfg.lang2].filter(function (l) { return l && l !== 'off' && l !== 'none'; });
+        return cc.some(function (c) { return c.lang && langs.some(function (l) { return P.langMatches(l, c.lang); }); });
+    }
+    function ccIndex(cc, w) { for (var i = 0; i < cc.length; i++) { if (cc[i].ch === w.ch) { return i; } } return 0; }
+    function relayed(ctx, r, cc) {
+        if (!r || typeof r.url !== 'string' || !/^http:\/\/localhost:\d+\/live\//.test(r.url)) { return false; }
+        ctx._relay = r.url; ctx._relayFor = ctx.url; ctx._relayCc = cc || null; ctx._ccOffer = cc ? null : ctx._ccOffer;
+        return true;
+    }
     function startLive(ctx, settle) {
-        var known = liveFixable(ctx) ? liveKnown(ctx.url) : null;
-        if (!known || !known.fix) { startAV(ctx.url, settle); return; }
-        ctx._liveChecked = true;
-        YTPlay.liveOpen(ctx.url, ctx._headers, true).then(function (r) {
+        var known = liveFixable(ctx) ? liveKnown(ctx.url) : null, cc = ccOf(known);
+        if (cc && cc.length) { ctx._ccOffer = cc; }
+        var withCc = ccWanted(ctx, cc) ? cc : null;
+        if (cc) { ctx._liveChecked = true; }   // (both answers in: not asked again)
+        if (!known || (!known.fix && !withCc)) { startAV(ctx.url, settle); return; }
+        YTPlay.liveOpen(ctx.url, ctx._headers, true, { fix: !!known.fix, cc: withCc }).then(function (r) {
             if (S.ctx !== ctx || !S.active) { return; }
-            if (r && typeof r.url === 'string' && /^http:\/\/localhost:\d+\/live\//.test(r.url)) { ctx._relay = r.url; ctx._relayFor = ctx.url; }
+            relayed(ctx, r, withCc);
             startAV(ctx.url, settle);
         }, function () { if (S.ctx === ctx && S.active) { startAV(ctx.url, settle); } });
     }
@@ -1046,17 +1151,37 @@ var PlayerParts = {};
         var ctx = S.ctx;
         if (!ctx || ctx._liveChecked || !liveFixable(ctx)) { return; }
         ctx._liveChecked = true;
-        if (liveKnown(ctx.url)) { return; }
+        var known = liveKnown(ctx.url);
+        if (known && ccOf(known)) { return; }
         var url = ctx.url;
         YTPlay.liveOpen(url, ctx._headers, false).then(function (r) {
             if (!r || !r.sure) { return; }   // (couldn't tell: asked again next time)
-            liveKeep(url, !!r.fix);
-            if (!r.fix || typeof r.url !== 'string' || !/^http:\/\/localhost:\d+\/live\//.test(r.url) || S.ctx !== ctx || !S.active || ctx.url !== url) { return; }
-            ctx._relay = r.url; ctx._relayFor = url;
+            var cc = (r.ccSure || r.cc === undefined) ? (ccOf(r) || []) : null, fix = known ? !!known.fix : !!r.fix;   // (captions with no text yet: asked again next time; the sound's answer: as first found)
+            liveKeep(url, fix, cc);
+            if (S.ctx !== ctx || !S.active || ctx.url !== url) { return; }
+            if (cc && cc.length && !ctx._relayCc) { ctx._ccOffer = cc; }
+            if (cc && cc.length && ccWanted(ctx, cc)) { ccOn(ctx, 'Adding this channel’s captions…'); return; }
+            if (known || !fix || ctx._relay || !relayed(ctx, r, null)) { return; }   // (the sound: restarted for on its first look only)
             U.log('player', 'Live sound repacked by StremioK\'s service (' + (r.why || '') + ')');
             reopen('Fixing this channel’s sound…');
         }, function () {});
     }
+    // The channel again through the relay with its closed captions as subtitle tracks (the sound
+    // repacked too when it needs it); then: true once it's reopening. want: a caption track to
+    // select once it plays ({ ch, lang }).
+    function ccOn(ctx, message, want) {
+        var known = liveKnown(ctx.url), cc = ccOf(known) || ctx._ccOffer;
+        if (!cc || !cc.length || !liveFixable(ctx)) { return Promise.resolve(false); }
+        return YTPlay.liveOpen(ctx.url, ctx._headers, true, { fix: !!(known && known.fix), cc: cc }).then(function (r) {
+            if (S.ctx !== ctx || !S.active || !relayed(ctx, r, cc)) { return false; }
+            var w = want || cc.filter(function (c) { return ccWanted(ctx, [c]); })[0] || null;
+            U.log('player', 'Live captions through StremioK\'s service (' + cc.map(function (c) { return c.ch; }).join(', ') + ')');
+            reopen(message);
+            if (w && P.wantEmbedded) { P.wantEmbedded({ nth: ccIndex(cc, w), lang: w.lang }); }   // (after the reopen: on its tracks)
+            return true;
+        }, function () { return false; });
+    }
+    P.ccOn = function (want) { return S.ctx ? ccOn(S.ctx, 'Adding this channel’s captions…', want) : Promise.resolve(false); };
     // The relay didn't start (StremioK's service gone): the channel as it is.
     function relayFailed() {
         if (S.playStarted || !S.ctx || !S.ctx._relay) { return false; }
@@ -1077,14 +1202,15 @@ var PlayerParts = {};
         var now = Date.now();
         if (S.buffering) {
             if (!_stall.bufSince) { _stall.bufSince = now; }
-            else if (now - _stall.bufSince > BUFFER_STALL_SECS * 1000) { recoverStall('Stream stopped loading — reloading…'); }
+            else if (now - _stall.bufSince > BUFFER_STALL_SECS * 1000) { recoverStall('Stream stopped loading'); }
             return;
         }
         _stall.bufSince = 0;
         if (isPaused() || S.cur !== _stall.t) { _stall.t = S.cur; _stall.since = now; return; }
-        if (_stall.since && now - _stall.since > STALL_SECS * 1000) { recoverStall('Playback stalled — reloading…'); }
+        if (_stall.since && now - _stall.since > STALL_SECS * 1000) { recoverStall('Playback stalled'); }
     }
-    function recoverStall(message) {
+    function recoverStall(why) {
+        if (liveReconnects()) { liveDropped(why); return; }
         var now = Date.now();
         _stall.recoveries = _stall.recoveries.filter(function (t) { return now - t < STALL_WINDOW_MS; });
         if (_stall.recoveries.length >= STALL_MAX) {
@@ -1094,7 +1220,51 @@ var PlayerParts = {};
             return;
         }
         _stall.recoveries.push(now);
-        reopen(message);
+        reopen(why + ' — reloading…');
+    }
+
+    // ---------- a live channel that drops ----------
+    // A live channel that stops (an error once it played, its connection lost; frozen, stuck
+    // loading, or ended by its server) is opened again at the live edge, as Settings › Playback ›
+    // Seeking & buffering › Reconnect live channels says: Off (the player closes), A few times
+    // (STALL_MAX within STALL_WINDOW_MS, as any stall) or Keep trying (no limit). A try that
+    // doesn't play is followed by another, each a little later (RECO_WAIT_S); BACK stops it.
+    // Not for a trailer or YouTube (a stall there reloads as a video's does).
+    var RECO_WAIT_S = [0, 5, 10, 20, 40, 60], _reco = { tries: 0, timer: null };
+    function liveReconnects() { return S.isLive && !!S.ctx && !S.ctx.trailer && !S.ctx.yt; }
+    function recoReset() {
+        if (_reco.timer) { clearTimeout(_reco.timer); }
+        _reco = { tries: 0, timer: null };
+    }
+    function liveDropped(why) {
+        if (_reco.timer) { return; }   // (a try already waiting)
+        var mode = P.playerCfg().reconnect, now = Date.now();
+        if (mode === 'off') {
+            U.log('player', 'Live channel: ' + why + '; reconnecting is off');
+            U.spinner(false); U.toast(why + ': the channel stopped (reconnecting is off)', 5000);
+            exitLater();
+            return;
+        }
+        _stall.recoveries = _stall.recoveries.filter(function (t) { return now - t < STALL_WINDOW_MS; });
+        if (mode !== 'always' && _stall.recoveries.length >= STALL_MAX) {
+            U.log('player', 'Live channel: ' + why + '; dropped ' + STALL_MAX + ' times in ' + (STALL_WINDOW_MS / 60000) + ' minutes, given up');
+            U.spinner(false); U.toast('This channel keeps dropping — try it again later', 5000);
+            exit();
+            return;
+        }
+        _stall.recoveries.push(now);
+        var n = ++_reco.tries, wait = RECO_WAIT_S[Math.min(n - 1, RECO_WAIT_S.length - 1)] * 1000, ctx = S.ctx;
+        var msg = why + ' — reconnecting' + (n > 1 ? ' (try ' + n + ')' : '') + '…';
+        U.log('player', 'Live channel: ' + why + ', reconnecting (try ' + n + (wait ? ', in ' + (wait / 1000) + ' s' : '') + ')');
+        if (!wait) { reopen(msg); return; }
+        U.spinner(true, msg);
+        function due() {
+            _reco.timer = null;
+            if (!S.active || S.ctx !== ctx) { return; }
+            if (inBackground()) { _reco.timer = setTimeout(due, 5000); return; }   // (back first)
+            reopen(msg);
+        }
+        _reco.timer = setTimeout(due, wait);
     }
     // The stream opened again in place: VOD at the same position, live at the edge.
     function reopen(message) {
@@ -1109,6 +1279,7 @@ var PlayerParts = {};
     function exit() {
         if (!S.active) { return; }
         if (U.crumb) { U.crumb('player closed'); }
+        if (P.sleepClear) { P.sleepClear(); }   // (the sleep timer: this playback's)
         saveProgress();
         // Record partial progress to Trakt (unfinished VOD) so it shows in Continue Watching. Past
         // 85% (Trakt connected): finished, Trakt's way (it marks it watched), and here as at the credits.
@@ -1126,6 +1297,7 @@ var PlayerParts = {};
         closeControls();
         screenSaver(true);
         _playToken++;   // invalidate AVPlay/HTML5 callbacks before stop/close emits any
+        recoReset();
         if (_ticker) { clearInterval(_ticker); _ticker = null; }
         if (_osdTimer) { clearTimeout(_osdTimer); _osdTimer = null; }
         hideOSD();
@@ -1154,4 +1326,5 @@ var PlayerParts = {};
     P.sponsorHighlight = sponsorHighlight;
     P.chapters = chapters; P.chapterAt = chapterAt; P.chapterLabel = chapterLabel;
     P.seekTo = seekTo; P.doAVSeek = doAVSeek; P.seekBy = seekBy; P.exit = exit;
+    P.reload = function () { if (S.active && S.ctx) { reopen(S.isLive ? 'Reloading the channel…' : 'Reloading…'); } };   // (the menu's Reload)
 })(PlayerParts);

package/js/player-lang.js

@@ -10,7 +10,7 @@
         var info = tr && tr.extra_info;
         if (typeof info === 'string') {
             try { info = JSON.parse(info); } catch (e) {
-                var out = {}, re = /["']?([A-Za-z_]+)["']?\s*[:=]\s*["']?([^"',}]*)/g, m;
+                var out = Object.create(null), re = /["']?([A-Za-z_]+)["']?\s*[:=]\s*["']?([^"',}]*)/g, m;   // (no inherited names)
                 while ((m = re.exec(info))) { out[m[1]] = m[2].trim(); }
                 info = out;
             }

package/js/player-quality.js

@@ -26,7 +26,7 @@
     function resetQuality(ctx) {
         _variants = []; _qualityBw = null; _ytRetried = false; _switchNote = null;
         _userPicked = false; _autoRetried = false; _startNote = '';
-        loadVariants(ctx.variantUrl || ctx.url, ctx.initialQualityHeight || 0, !!ctx.variantUrl);
+        loadVariants(ctx.variantUrl || ctx.url, ctx.initialQualityHeight || 0, !!ctx.variantUrl, ctx._headers);
     }
     // Playback started: a switch is done; say where a fallback landed.
     function qualityOnStart() {
@@ -38,6 +38,8 @@
     function qualityHeight() { var v = variantByBw(_qualityBw); return v ? v.h : 0; }
     function qualityCount() { return _variants.length; }
     function hasQualities() { return _variants.length > 1; }
+    var _unread = false;   // an HLS stream whose quality list couldn't be read
+    function qualityUnread() { return _unread && !_variants.length; }
 
     // Auto lets AVPlay adapt to bandwidth; an explicit pick caps the ladder via ADAPTIVE_INFO.
     // Two cap strategies, because YouTube-style HLS breaks the usual one:
@@ -187,8 +189,11 @@
         var u = '' + (url || ''), path = u.split('#')[0].split('?')[0], query = u.split('#')[0].split('?')[1] || '';
         return /\.m3u8$/i.test(path) || /(^|&)(type|format|ext|output)=m3u8(&|$)/i.test(query);
     }
-    function getHlsMaster(url) {
-        return U.getText(url, 8000, HLS_MASTER_MAX).then(function (text) {
+    // h: the stream's own User-Agent / Referer ({ ua, ref }): the list is then read through
+    // StremioK's service, which can send them (as the TV's player does); a web page can't.
+    function getHlsMaster(url, h) {
+        var viaService = !!(h && (h.ua || h.ref) && typeof YTPlay !== 'undefined' && YTPlay.hlsMaster && YTPlay.installMode && YTPlay.installMode() !== 'browser');
+        return (viaService ? YTPlay.hlsMaster(url, h) : U.getText(url, 8000, HLS_MASTER_MAX)).then(function (text) {
             var t = ('' + (text || '')).replace(/^\uFEFF/, '').replace(/^\s+/, '');
             if (t.indexOf('#EXTM3U') !== 0) { throw new Error('not an HLS playlist'); }
             return t;
@@ -205,12 +210,13 @@
         CLASSES.forEach(function (c) { if (Math.abs(c - t) <= c * 0.06) { best = c; } });
         return best;
     }
-    function loadVariants(url, initialHeight, isMaster) {
+    function loadVariants(url, initialHeight, isMaster, headers) {
         var tok = ++_variantsToken;   // a list arriving after you've moved on is for the old stream
         _variants = [];
         _sepAudio = false;
+        _unread = false;
         if (!url || !(isMaster || isHlsUrl(url))) { return; }
-        getHlsMaster(url).then(function (text) {
+        getHlsMaster(url, headers).then(function (text) {
             if (tok !== _variantsToken) { return; }
             var t = '' + text;
             _sepAudio = t.indexOf('#EXT-X-MEDIA:TYPE=AUDIO') !== -1 || /#EXT-X-STREAM-INF[^\r\n]*[,:]AUDIO=/.test(t);
@@ -239,7 +245,9 @@
                     }
                 }
             }
-        }, function () { if (tok === _variantsToken) { _variants = []; _sepAudio = false; } });
+        }, function (e) {   // (couldn't be read: said so, not "one quality"; an answer that isn't a playlist at all: no list, as before)
+            if (tok === _variantsToken) { _variants = []; _sepAudio = false; _unread = !/not an HLS playlist/.test((e && e.message) || ''); }
+        });
     }
 
     // Switch to a different source mid-playback, keeping position (VOD): a playback of its
@@ -312,7 +320,7 @@
 
     // ----- for the other parts (and js/player.js) -----
     P.resetQuality = resetQuality; P.qualityOnStart = qualityOnStart; P.clearStartNote = clearStartNote;
-    P.qualityHeight = qualityHeight; P.qualityCount = qualityCount; P.hasQualities = hasQualities;
+    P.qualityHeight = qualityHeight; P.qualityCount = qualityCount; P.hasQualities = hasQualities; P.qualityUnread = qualityUnread;
     P.adaptiveInfo = adaptiveInfo; P.tryFallback = tryFallback; P.switchSource = switchSource;
     P.qualityLabel = qualityLabel; P.qualityMenu = qualityMenu;
     P.hasYtLanguages = hasYtLanguages; P.ytLanguageLabel = ytLanguageLabel; P.ytLanguageMenu = ytLanguageMenu;

package/js/player-store.js

@@ -107,7 +107,9 @@
         for (var i = 0; i < SUB_FONTS.length; i++) { if (SUB_FONTS[i][0] === id) { return SUB_FONTS[i][2]; } }
         return '';
     }
-    function setSubCfg(cfg) { U.store.set(SUBCFG_KEY, cfg); }
+    var _subCfgVer = 0;   // bumped on every change: a styled line knows it's up to date
+    function setSubCfg(cfg) { U.store.set(SUBCFG_KEY, cfg); _subCfgVer++; }
+    function subCfgVersion() { return _subCfgVer; }
 
     // Preferred audio language ('default' = keep the stream's first audio track) and a
     // second choice used when the first isn't on the stream ('none' = no second choice).
@@ -236,13 +238,15 @@
         ['zoom', 'Zoom (fill the screen, trims edges)', 'PLAYER_DISPLAY_MODE_CROPPED_FULL', 'cover'],
         ['stretch', 'Stretch', 'PLAYER_DISPLAY_MODE_FULL_SCREEN', 'fill']
     ];
-    // + seek: how far LEFT / RIGHT jump (s); buffer: 'normal' (the TV's own) | 'more' | 'most'
+    // + seek: how far LEFT / RIGHT jump (s); buffer: 'normal' (the TV's own) | 'more' | 'most';
+    // reconnect: a live channel that drops, 'off' | 'few' | 'always' (see player-core's liveDropped)
     // (Settings › Playback › Seeking & buffering)
     var SEEK_STEPS = [5, 10, 15, 30];
     function playerCfg() {
         var d = U.store.get(PLAYERCFG_KEY, {}) || {};
         return { aspect: d.aspect || 'fit', seek: SEEK_STEPS.indexOf(+d.seek) !== -1 ? +d.seek : 10,
             buffer: d.buffer === 'more' || d.buffer === 'most' ? d.buffer : 'normal',
+            reconnect: d.reconnect === 'off' || d.reconnect === 'always' ? d.reconnect : 'few',
             phone: d.phone === 'infuse' || d.phone === 'link' ? d.phone : 'vlc' };   // (Continue on phone: what the QR opens)
     }
     function setPlayerCfg(cfg) {   // (what's given changes; the rest stays)
@@ -251,6 +255,26 @@
         U.store.set(PLAYERCFG_KEY, d);
     }
     function aspectDef(id) { for (var i = 0; i < ASPECTS.length; i++) { if (ASPECTS[i][0] === id) { return ASPECTS[i]; } } return ASPECTS[0]; }
+    // A live channel's own picture mode (picked while it played): { channel id: mode }, the last
+    // ASPECTS_KEEP; one set back to the usual mode isn't kept apart. Anything else: the usual one.
+    var ASPECTS_KEY = 'stremiok.aspects', ASPECTS_KEEP = 300;
+    function aspectChannel() { var S = P.S; return (S && S.isLive && S.ctx && S.ctx.id) ? S.ctx.id : ''; }
+    function aspectNow() {
+        var ch = aspectChannel(), own = ch ? (U.store.get(ASPECTS_KEY, {}) || {})[ch] : '';
+        return own && aspectDef(own)[0] === own ? own : playerCfg().aspect;
+    }
+    function setAspectNow(mode) {
+        var ch = aspectChannel();
+        if (!ch) { setPlayerCfg({ aspect: mode }); return; }
+        var all = U.store.get(ASPECTS_KEY, {}) || {};
+        delete all[ch];
+        if (mode !== playerCfg().aspect) {
+            all[ch] = mode;
+            var keys = Object.keys(all);
+            keys.slice(0, Math.max(0, keys.length - ASPECTS_KEEP)).forEach(function (k) { delete all[k]; });   // (the oldest picked)
+        }
+        U.store.set(ASPECTS_KEY, all);
+    }
 
     // ----- for the other parts (and js/player.js) -----
     P.watchedState = watchedState; P.isWatched = isWatched; P.watchedAt = watchedAt; P.watchedSince = watchedSince;
@@ -261,7 +285,7 @@
     P.getResume = getResume; P.removeProgress = removeProgress; P.continueList = continueList;
     P.rememberSub = rememberSub; P.recallSub = recallSub; P.rememberAudio = rememberAudio;
     P.recallAudio = recallAudio; P.playerCfg = playerCfg; P.setPlayerCfg = setPlayerCfg;
-    P.aspectDef = aspectDef; P.SUB_FONTS = SUB_FONTS; P.SUB_COLORS = SUB_COLORS; P.SUB_BGS = SUB_BGS;
+    P.aspectDef = aspectDef; P.aspectNow = aspectNow; P.setAspectNow = setAspectNow; P.SUB_FONTS = SUB_FONTS; P.SUB_COLORS = SUB_COLORS; P.SUB_BGS = SUB_BGS;
     P.SUB_EDGES = SUB_EDGES; P.SUB_POSITIONS = SUB_POSITIONS; P.ASPECTS = ASPECTS;
-    P.isPrivate = isPrivate; P.setPrivate = setPrivate;
+    P.isPrivate = isPrivate; P.setPrivate = setPrivate; P.privateNow = privateNow; P.subCfgVersion = subCfgVersion;
 })(PlayerParts);