@oxymoron.13/tizentube-s95b 0.2.2 → 0.3.0

package/mods/features/s95bCodec.js

@@ -0,0 +1,45 @@
+/* S95B Performance Edition – GPL-3.0-only.
+ * Pure, conservative format selector. Does not touch Samsung/Tizen APIs.
+ */
+export function selectCodecFormats(response, codec) {
+  if (!response || !response.streamingData || !Array.isArray(response.streamingData.adaptiveFormats)) {
+    return { changed: false, reason: 'no-formats' };
+  }
+  if (codec !== 'vp9' && codec !== 'av01' && codec !== 'avc1') {
+    return { changed: false, reason: 'automatic' };
+  }
+
+  const formats = response.streamingData.adaptiveFormats;
+  const video = formats.filter(item => item && typeof item.mimeType === 'string' && /^video\//i.test(item.mimeType));
+  const isMatch = item => {
+    const mime = item.mimeType.toLowerCase();
+    if (codec === 'vp9') return /(?:vp9|vp09)/.test(mime);
+    if (codec === 'av01') return /av01/.test(mime);
+    return /avc1/.test(mime);
+  };
+  const selected = video.filter(isMatch);
+  if (!selected.length) return { changed: false, reason: 'codec-unavailable' };
+  if (selected.length === video.length) return { changed: false, reason: 'already-selected' };
+
+  // Conservative quality parity: preserve original formats if filtering could
+  // remove the best available height/fps combination. Metadata absent => no filter.
+  const valid = item => Number.isFinite(item.height) && item.height > 0 &&
+    Number.isFinite(item.fps) && item.fps > 0;
+  if (!video.every(valid) || !selected.every(valid)) {
+    return { changed: false, reason: 'quality-unknown' };
+  }
+  const maxHeight = Math.max(...video.map(item => item.height));
+  const maxFpsAtHeight = Math.max(...video.filter(item => item.height === maxHeight).map(item => item.fps));
+  const bestMatch = selected.some(item => item.height >= maxHeight && item.fps >= maxFpsAtHeight);
+  if (!bestMatch) return { changed: false, reason: 'quality-fallback' };
+
+  // Keep audio and unrecognized entries untouched. No media decoding or resampling.
+  const next = formats.filter(item => !item || typeof item.mimeType !== 'string' ||
+    !/^video\//i.test(item.mimeType) || isMatch(item));
+  if (!next.some(item => item && /^audio\//i.test(item.mimeType || ''))) {
+    // Do not make a pre-existing audio problem worse by filtering streams.
+    return { changed: false, reason: 'missing-audio' };
+  }
+  response.streamingData.adaptiveFormats = next;
+  return { changed: true, reason: 'selected' };
+}

package/mods/features/s95bI18n.js

@@ -0,0 +1,28 @@
+/* S95B Performance Edition – GPL-3.0-only */
+export const STRINGS = Object.freeze({
+  de: Object.freeze({
+    title: 'S95B · Performance', language: 'Sprache', codec: 'Videocodec', quality: 'Standardqualität (alle Videos)',
+    automatic: 'Automatisch', light: 'Ressourcenschonender Modus',
+    lightHint: 'Schaltet Vorschauen und DeArrow ab; vorherige Werte werden beim Ausschalten wiederhergestellt.',
+    codecHint: 'H.264 liefert bei YouTube in der Regel höchstens 1080p; 4K gibt es nur als VP9 oder AV1. Ein Codec wird nur erzwungen, wenn dadurch keine Qualität verloren geht. Gilt ab dem nächsten Video.',
+    qualityHint: 'Gilt für alle Videos (YouTubes eigene Zeile „Qualität“ ändert nur das laufende Video). Eine feste Qualität gilt sofort. „Automatisch“ wirkt eventuell erst nach einem Neustart von YouTube.',
+    languageHint: 'Gilt für dieses Menü, beim nächsten Öffnen.',
+    statVideo: 'Video', statFrames: 'Verlorene Bilder', statCodec: 'Codec-Wunsch',
+    statUnavailable: 'nicht verfügbar', statWait: 'wartet auf Video',
+    languageDE: 'Deutsch', languageEN: 'English',
+  }),
+  en: Object.freeze({
+    title: 'S95B · Performance', language: 'Language', codec: 'Video codec', quality: 'Default quality (all videos)',
+    automatic: 'Automatic', light: 'Low-overhead mode',
+    lightHint: 'Disables previews and DeArrow; the previous values are restored when switched off.',
+    codecHint: 'On YouTube, H.264 usually tops out at 1080p; 4K is only available as VP9 or AV1. A codec is only forced if no quality is lost. Applies from the next video.',
+    qualityHint: 'Applies to all videos (YouTube’s own “Quality” row only changes the current video). A fixed quality applies immediately. “Automatic” may only take effect after restarting YouTube.',
+    languageHint: 'Applies to this menu, the next time it is opened.',
+    statVideo: 'Video', statFrames: 'Dropped frames', statCodec: 'Codec preference',
+    statUnavailable: 'not available', statWait: 'waiting for video',
+    languageDE: 'Deutsch', languageEN: 'English',
+  })
+});
+export function translate(lang, key) {
+  return (STRINGS[lang] || STRINGS.de)[key] || STRINGS.en[key] || key;
+}

package/mods/features/s95bMenu.js

@@ -0,0 +1,137 @@
+/* S95B Performance Edition – GPL-3.0-only
+ * The yellow remote key opens a menu that YouTube itself draws (TizenTube's own optionShow),
+ * the same mechanism as the green (settings) and blue (speed) menus. No DOM overlay is added to the page.
+ * Uses only existing TizenTube configRead/configWrite APIs. No firmware calls, network requests or timers.
+ */
+import { configRead, configWrite, configChangeEmitter } from '../config.js';
+import { optionShow } from '../ui/settings.js';
+import { translate } from './s95bI18n.js';
+import { codecMenu, qualityMenu, codecLabel, currentCodec } from './s95bOptions.js';
+
+const STATE_KEY = 's95b-perf-edition-v1';
+const EDITED = ['enablePreviews', 'enableDeArrow', 'enableDeArrowThumbnails'];
+const defaultState = { lang: 'de', light: false, previous: null };
+let state = { ...defaultState };
+
+function readState() {
+  try {
+    const data = JSON.parse(localStorage.getItem(STATE_KEY) || 'null');
+    if (data && typeof data === 'object') {
+      state = { ...defaultState,
+        lang: data.lang === 'en' ? 'en' : 'de', light: data.light === true,
+        previous: data.previous && typeof data.previous === 'object' ? data.previous : null };
+    }
+  } catch (_) { state = { ...defaultState }; }
+}
+function save() {
+  try { localStorage.setItem(STATE_KEY, JSON.stringify(state)); } catch (_) { /* no persistent storage */ }
+}
+function t(key) { return translate(state.lang, key); }
+
+
+// Low-overhead mode: switches off a few TizenTube features and remembers the previous values.
+function turnLight(enable) {
+  if (enable === state.light) return;
+  if (enable) {
+    const values = {};
+    EDITED.forEach(key => { values[key] = configRead(key); });
+    state.previous = values;
+    EDITED.forEach(key => configWrite(key, false));
+    state.light = true;
+  } else {
+    if (state.previous) EDITED.forEach(key => {
+      if (Object.prototype.hasOwnProperty.call(state.previous, key)) {
+        configWrite(key, state.previous[key]);
+      }
+    });
+    state.previous = null;
+    state.light = false;
+  }
+  save();
+}
+
+// Source frame rate as YouTube's own stats report it ("3840x2160@24 / ..."), same source as upstream autoFrameRate.js.
+function frameRate() {
+  try {
+    const player = document.querySelector('.html5-video-player');
+    if (!player || typeof player.getStatsForNerds !== 'function') return '';
+    const match = String(player.getStatsForNerds().resolution || '').match(/@([\d.]+)/);
+    return match ? ' @' + match[1] : '';
+  } catch (_) { return ''; }
+}
+
+// One snapshot of what the web player reports, taken each time the menu opens.
+function statsLine() {
+  const video = document.querySelector('video');
+  let size = t('statWait');
+  let dropped = t('statUnavailable');
+  if (video) {
+    const width = video.videoWidth || 0;
+    const height = video.videoHeight || 0;
+    size = width > 0 && height > 0 ? width + ' × ' + height + frameRate() : t('statUnavailable');
+    if (typeof video.getVideoPlaybackQuality === 'function') {
+      try {
+        const q = video.getVideoPlaybackQuality();
+        if (q && Number.isFinite(q.droppedVideoFrames)) dropped = String(q.droppedVideoFrames);
+      } catch (_) { /* diagnostics must never interrupt playback */ }
+    }
+  }
+  return t('statVideo') + ': ' + size + '  |  ' + t('statFrames') + ': ' + dropped +
+    '  |  ' + t('statCodec') + ': ' + codecLabel(t, currentCodec());
+}
+
+function buildOptions() {
+  return [
+    { name: t('language'), value: null, menuId: 's95b-language',
+      menuHeader: { title: t('language'), subtitle: t('languageHint') },
+      options: [
+        { name: t('languageDE'), key: 's95bLanguage', value: 'de' },
+        { name: t('languageEN'), key: 's95bLanguage', value: 'en' }
+      ] },
+    codecMenu(t),
+    qualityMenu(t),
+    { name: t('light'), subtitle: t('lightHint'), value: 's95bLowOverhead' }
+  ];
+}
+
+function openMenu() {
+  try {
+    optionShow({
+      menuId: 's95b-menu',
+      menuHeader: { title: t('title'), subtitle: statsLine() },
+      selectedIndex: 0,
+      options: buildOptions()
+    }, false);
+  } catch (e) { console.warn('[S95B] menu could not be opened:', e); }
+}
+
+function onKeys(e) {
+  const code = e.keyCode || e.which;
+  // Samsung ColorF2Yellow: 405 per Tizen docs, 170 as the alternative code TizenTube mentions, F2 on a keyboard.
+  // Red (403), green (404) and blue (406) are used by TizenTube itself. Nothing else is touched.
+  if (code === 405 || code === 170 || e.key === 'ColorF2Yellow' || e.key === 'F2') {
+    e.preventDefault(); e.stopImmediatePropagation();
+    if (e.type === undefined || e.type === 'keydown') openMenu();
+  }
+}
+
+function onConfigChange(event) {
+  const detail = event && event.detail;
+  if (!detail) return;
+  if (detail.key === 's95bLowOverhead') turnLight(detail.value === true);
+  else if (detail.key === 's95bLanguage') { state.lang = detail.value === 'en' ? 'en' : 'de'; save(); }
+}
+
+function init() {
+  // Menu entries read their current value from the TizenTube config, so mirror our stored state into it first.
+  if (configRead('s95bLowOverhead') !== state.light) configWrite('s95bLowOverhead', state.light);
+  if (configRead('s95bLanguage') !== state.lang) configWrite('s95bLanguage', state.lang);
+  configChangeEmitter.addEventListener('configChange', onConfigChange);
+  // Capture phase on window: only the yellow key is consumed.
+  window.addEventListener('keydown', onKeys, true);
+  window.addEventListener('keyup', onKeys, true);
+  window.addEventListener('keypress', onKeys, true);
+}
+
+readState();
+init();

package/mods/features/s95bOptions.js

@@ -0,0 +1,30 @@
+/* S95B Performance Edition – GPL-3.0-only
+ * Codec and default-quality choices, shared by the yellow menu and the playback settings popup.
+ * Both write TizenTube's own config keys (preferredVideoCodec, preferredVideoQuality).
+ */
+import { configRead } from '../config.js';
+
+export const CODECS = ['any', 'vp9', 'av01', 'avc1'];
+export const QUALITIES = ['auto', '2160p', '1440p', '1080p', '720p'];
+
+export function codecLabel(t, value) {
+  return value === 'any' ? t('automatic') : value === 'vp9' ? 'VP9' : value === 'av01' ? 'AV1' : 'H.264';
+}
+export function qualityLabel(t, value) {
+  return value === 'auto' ? t('automatic') : value === '2160p' ? '2160p (4K)' : String(value);
+}
+export function currentCodec() {
+  const value = configRead('preferredVideoCodec');
+  return CODECS.indexOf(value) >= 0 ? value : 'any';
+}
+
+export function codecMenu(t) {
+  return { name: t('codec'), icon: 'VIDEO_QUALITY', value: null, menuId: 's95b-codec',
+    menuHeader: { title: t('codec'), subtitle: t('codecHint') },
+    options: CODECS.map(codec => ({ name: codecLabel(t, codec), key: 'preferredVideoCodec', value: codec })) };
+}
+export function qualityMenu(t) {
+  return { name: t('quality'), icon: 'VIDEO_QUALITY', value: null, menuId: 's95b-quality',
+    menuHeader: { title: t('quality'), subtitle: t('qualityHint') },
+    options: QUALITIES.map(quality => ({ name: qualityLabel(t, quality), key: 'preferredVideoQuality', value: quality })) };
+}

package/mods/features/s95bPlayback.js

@@ -0,0 +1,29 @@
+/* S95B Performance Edition – GPL-3.0-only
+ * Two entries for YouTube's playback settings popup (opened while a video plays): video codec and
+ * default quality for all videos. They open the same YouTube-drawn choice lists as the yellow menu.
+ * buttonItem is handed in by resolveCommand.js, which already imports it.
+ */
+import { configRead } from '../config.js';
+import { translate } from './s95bI18n.js';
+import { codecMenu, qualityMenu, codecLabel, qualityLabel, currentCodec } from './s95bOptions.js';
+
+export function s95bPlaybackItems(buttonItem) {
+  const lang = configRead('s95bLanguage') === 'en' ? 'en' : 'de';
+  const t = key => translate(lang, key);
+  const entry = (menu, subtitle) => buttonItem({ title: menu.name, subtitle }, { icon: menu.icon }, [{
+    customAction: {
+      action: 'OPTIONS_SHOW',
+      parameters: {
+        options: menu.options,
+        selectedIndex: Math.max(0, menu.options.findIndex(o => o.value === configRead(o.key))),
+        update: false,
+        menuId: menu.menuId,
+        menuHeader: menu.menuHeader
+      }
+    }
+  }]);
+  return [
+    entry(codecMenu(t), codecLabel(t, currentCodec())),
+    entry(qualityMenu(t), qualityLabel(t, configRead('preferredVideoQuality')))
+  ];
+}