@brandbrigade/ott-bb-player 1.0.43 → 1.0.45

package/src/utils/FPSFetter.js

@@ -0,0 +1,94 @@
+export const FPSGetter = () => {
+    const possibleFps29_30 = [
+      30000 / 1001, //29.97
+      30 / 1, //30,0
+    ];
+    const possibleFps59_60 = [
+      60000 / 1001, //59.94
+      60 / 1, ///60
+    ];
+    let bestFPSMatches = [];
+    let deltaStorage = [];
+    let deltaCount = 0;
+    let lastMediaTimeForFPSGetting = -1;
+    let possibleFps
+    //let fps = 60;
+    let count = 0;
+    const addTime = (mediaTime) => {
+      count++;
+      //let fraction2PossibleFPS = new Map();
+      let minFraction = 999;
+      let minCandidateFps = 0;
+      if (lastMediaTimeForFPSGetting == -1) {
+        lastMediaTimeForFPSGetting = mediaTime;
+        return;
+      } else {
+        let delta = mediaTime - lastMediaTimeForFPSGetting;
+        if (deltaCount < 100) {
+          deltaStorage.push(delta);
+          deltaCount++;
+          return;
+        } else {
+          deltaStorage.push(delta);
+          deltaStorage.shift();
+        }
+        let total = 0;
+        for (let i = 0; i < deltaStorage.length; i++) {
+          total += deltaStorage[i];
+        }
+        delta = total / deltaStorage.length;
+        //console.log("delta= " +  delta.toFixed(5) + " fps= " + (1/delta).toFixed(2));
+        if (1 / delta < 40) possibleFps = possibleFps29_30;
+        else possibleFps = possibleFps59_60;
+      }
+      //possibleFps = possibleFps59_60;
+      lastMediaTimeForFPSGetting = mediaTime;
+  
+      for (let i = 0; i < possibleFps.length; ++i) {
+        let candidateFps = possibleFps[i];
+        let dblFrame = mediaTime * candidateFps;
+        let intFrame = Math.round(dblFrame);
+        let fraction = Math.abs(dblFrame - intFrame);
+        if (fraction < minFraction) {
+          minFraction = fraction;
+          minCandidateFps = candidateFps;
+        }
+  
+        //fraction2PossibleFPS.set(fraction, candidateFps);
+      }
+      let bestFPSMatch = minCandidateFps; //fraction2PossibleFPS.entries().next().value[1];
+      bestFPSMatches.push(bestFPSMatch);
+      //console.log("bestFPSMatch = " + bestFPSMatch);
+      if (count > 1000) bestFPSMatches.shift(); //deleting the first el
+    };
+  
+    const getProbableFPS = () => {
+      let count = {};
+      let mostOccurringValue;
+      let maxCount = 0;
+  
+      // Count the occurrences of each value in the array
+      for (let i = 0; i < bestFPSMatches.length; i++) {
+        let value = bestFPSMatches[i];
+        count[value] = (count[value] || 0) + 1;
+  
+        // Update the most occurring value and its count if necessary
+        if (count[value] > maxCount) {
+          mostOccurringValue = value;
+          maxCount = count[value];
+        }
+      }
+  
+      return mostOccurringValue;
+    };
+  
+    const howMany = () => {
+      return count;
+    };
+  
+    return {
+      addTime: addTime,
+      getProbableFPS: getProbableFPS,
+      howMany: howMany,
+    };
+  };

package/src/utils/MedianCalculator.js

@@ -0,0 +1,27 @@
+export const MedianCalculator = (maxSize_) => {
+    let maxSize = maxSize_ || 9999999999;
+    let values = [];
+    let count = 0;
+  
+    const add = (value) => {
+      ++count;
+      values.push(value);
+      while (values.length > maxSize) values.shift();
+    };
+    const getMedian = () => {
+      if (values.length == 0) return -1;
+      let sortedValues = Array.from(values).sort((a, b) => {
+        return a - b;
+      });
+      return sortedValues[Math.floor(sortedValues.length / 2)];
+    };
+    const howMany = () => {
+      return count;
+    };
+  
+    return {
+      add,
+      getMedian,
+      howMany,
+    };
+  };

package/src/utils/index.js

@@ -0,0 +1,5 @@
+export * from './FPSFetter'
+export * from './MedianCalculator'
+export * from './platform'
+export * from './timeCodeUtils'
+export * from './isPowerOf2'

package/src/utils/isPowerOf2.js

@@ -0,0 +1,3 @@
+export const isPowerOf2 = (value) => {
+    return (value & (value - 1)) == 0;
+}

package/src/utils/platform.js

@@ -0,0 +1,191 @@
+export const Platform = (() => {
+    const getCurrentPlatform = () => {
+      const userAgent = navigator.userAgent;
+      if (/windows/i.test(userAgent)) {
+        return "Windows";
+      } else if (/android/i.test(userAgent)) {
+        return "Android";
+      } else if (/iphone|ipad|ipod/i.test(userAgent)) {
+        return "iOS";
+      } else if (/mac/i.test(userAgent)) {
+        return "Mac"; //tmp alal
+        let isIPadAnyhow =
+          "ontouchstart" in window ||
+          navigator.maxTouchPoints > 0 ||
+          navigator.msMaxTouchPoints > 0;
+        if (isIPadAnyhow) return "iPad";
+        else return "Mac";
+      } else if (/ipad/i.test(userAgent)) {
+        return "iPad";
+      } else {
+        return "Something else";
+      }
+    };
+    const isMac = () => {
+      let platform = getCurrentPlatform();
+      return platform == "Mac";
+    };
+    const isiPad = () => {
+      let platform = getCurrentPlatform();
+      return platform == "iPad";
+    };
+    const isiPhone = () => {
+      let platform = getCurrentPlatform();
+      return platform == "iOS";
+    };
+    const isApple = () => {
+      let platform = getCurrentPlatform();
+      return platform == "iOS" || platform == "Mac" || platform == "iPad";
+    };
+    const isWindows = () => {
+      //return true;
+      let platform = getCurrentPlatform();
+      return platform == "Windows";
+    };
+    const isAndroid = () => {
+      let platform = getCurrentPlatform();
+      return platform == "Android";
+    };
+    const getDeviceDescription = () => {
+      let deviceType = getCurrentPlatform();
+      if (deviceType == "Windows") return "a Windows PC";
+      else if (deviceType == "Android") return "an Android phone";
+      else if (deviceType == "iOS") return "an iPhone";
+      else if (deviceType == "Mac") return "a Mac";
+      else if (deviceType == "iPad") return "an iPad";
+      else return "an Unknown device";
+    };
+    const getDeviceName = () => {
+      let module = {
+        options: [],
+        header: [
+          navigator.platform,
+          navigator.userAgent,
+          navigator.appVersion,
+          navigator.vendor,
+          window.opera,
+        ],
+        dataos: [
+          { name: "Windows Phone", value: "Windows Phone", version: "OS" },
+          { name: "Windows", value: "Win", version: "NT" },
+          { name: "iPhone", value: "iPhone", version: "OS" },
+          { name: "iPad", value: "iPad", version: "OS" },
+          { name: "Kindle", value: "Silk", version: "Silk" },
+          { name: "Android", value: "Android", version: "Android" },
+          { name: "PlayBook", value: "PlayBook", version: "OS" },
+          { name: "BlackBerry", value: "BlackBerry", version: "/" },
+          { name: "Macintosh", value: "Mac", version: "OS X" },
+          { name: "Linux", value: "Linux", version: "rv" },
+          { name: "Palm", value: "Palm", version: "PalmOS" },
+        ],
+        databrowser: [
+          { name: "Chrome", value: "Chrome", version: "Chrome" },
+          { name: "Firefox", value: "Firefox", version: "Firefox" },
+          { name: "Safari", value: "Safari", version: "Version" },
+          { name: "Internet Explorer", value: "MSIE", version: "MSIE" },
+          { name: "Opera", value: "Opera", version: "Opera" },
+          { name: "BlackBerry", value: "CLDC", version: "CLDC" },
+          { name: "Mozilla", value: "Mozilla", version: "Mozilla" },
+        ],
+        init: function () {
+          let agent = this.header.join(" "),
+            os = this.matchItem(agent, this.dataos),
+            browser = this.matchItem(agent, this.databrowser);
+  
+          return { os: os, browser: browser };
+        },
+        matchItem: function (string, data) {
+          let i = 0,
+            j = 0,
+            html = "",
+            regex,
+            regexv,
+            match,
+            matches,
+            version;
+  
+          for (i = 0; i < data.length; i += 1) {
+            regex = new RegExp(data[i].value, "i");
+            match = regex.test(string);
+            if (match) {
+              regexv = new RegExp(data[i].version + "[- /:;]([\\d._]+)", "i");
+              matches = string.match(regexv);
+              version = "";
+              if (matches) {
+                if (matches[1]) {
+                  matches = matches[1];
+                }
+              }
+              if (matches) {
+                matches = matches.split(/[._]+/);
+                for (j = 0; j < matches.length; j += 1) {
+                  if (j === 0) {
+                    version += matches[j] + ".";
+                  } else {
+                    version += matches[j];
+                  }
+                }
+              } else {
+                version = "0";
+              }
+              return {
+                name: data[i].name,
+                version: parseFloat(version),
+              };
+            }
+          }
+          return { name: "unknown", version: 0 };
+        },
+      };
+  
+      let e = module.init();
+      return e.os.name;
+    };
+    const getBrowserName = () => {
+      const userAgent = navigator.userAgent;
+  
+      if (userAgent.indexOf("Chrome") > -1 && userAgent.indexOf("Edge") === -1) {
+        return "Chrome";
+      } else if (
+        userAgent.indexOf("Safari") > -1 &&
+        userAgent.indexOf("Chrome") === -1
+      ) {
+        return "Safari";
+      } else if (userAgent.indexOf("Firefox") > -1) {
+        return "Firefox";
+      } else if (
+        userAgent.indexOf("MSIE") > -1 ||
+        userAgent.indexOf("Trident") > -1
+      ) {
+        return "Internet Explorer";
+      } else if (userAgent.indexOf("Edge") > -1) {
+        return "Edge";
+      } else {
+        return "Unknown";
+      }
+    };
+    const isSafariMac = () => {
+      return isMac() && getBrowserName() == "Safari";
+    };
+    const isChromeMac = () => {
+      return isMac() && getBrowserName() == "Chrome";
+    };
+    const isChromeWin = () => {
+      return isWindows() && getBrowserName() == "Chrome";
+    };
+    return {
+      getDeviceName,
+      getCurrentPlatform,
+      isApple,
+      isWindows,
+      isAndroid,
+      isMac,
+      isiPhone,
+      isiPad,
+      getDeviceDescription,
+      getBrowserName,
+      isSafariMac,
+      isChromeMac,
+      isChromeWin,
+    };
+  })();

package/src/utils/timeCodeUtils.js

@@ -0,0 +1,274 @@
+import { Platform } from "./platform";
+
+const padZero = (num) => {
+    return num.toString().padStart(2, "0");
+};
+  
+const timecodeDelimeter = ":";
+
+  export const printTimecode = (timecode, duplicated, dot2) => {
+    let str = "";
+    if (Array.isArray(timecode)) {
+      str = [
+        padZero(timecode[0]),
+        padZero(timecode[1]),
+        padZero(timecode[2]),
+        padZero(timecode[3]),
+      ].join(":");
+      if (dot2 == true) {
+        if (timecode[4] == 1 && (duplicated === undefined || duplicated))
+          str += ".2";
+        else str += ".1";
+      } else {
+        if (timecode[4] == 1 && (duplicated === undefined || duplicated))
+          str += ".1";
+      }
+    } else {
+      str =
+        ("0" + timecode.h).slice(-2) +
+        timecodeDelimeter +
+        ("0" + timecode.m).slice(-2) +
+        timecodeDelimeter +
+        ("0" + timecode.s).slice(-2) +
+        timecodeDelimeter +
+        ("0" + timecode.f).slice(-2);
+      if (duplicated) str += "." + (timecode.field ? "1" : "2");
+    }
+  
+    return str;
+  };
+
+  export const str2TimeCode = (str, delimiter) => {
+    const list = str.split(delimiter);
+    const timecode = {
+      h: parseInt(list[0]),
+      m: parseInt(list[1]),
+      s: parseInt(list[2]),
+      f: parseInt(list[3]),
+    };
+    return timecode;
+  };
+  
+  export const timeCodeStr2TimeCodeArray = (timecodeStr) => {
+    let tokens = timecodeStr.split(":");
+    if (tokens.length != 4) {
+      console.error("timeCodeStr2TimeCodeArray: Failed to parse " + timecodeStr);
+      return [0, 0, 0, 0, 0];
+    }
+    let timeCodeArray = [
+      parseInt(tokens[0]), //hours
+      parseInt(tokens[1]), //minutes
+      parseInt(tokens[2]),
+    ]; //seconds
+    if (tokens[3].indexOf(".") >= 0) {
+      let framesAndField = tokens[3].split(".");
+      timeCodeArray.push(parseInt(framesAndField[0])); //frames
+      timeCodeArray.push(parseInt(framesAndField[1])); //field
+    } else {
+      timeCodeArray.push(parseInt(tokens[3])); //frames
+      timeCodeArray.push(0); //field
+    }
+    return timeCodeArray;
+  };
+  
+  export const timecode2Frames = (timecode, fps, duplicated) => {
+    //timecode [hh,mm,ss,ff,.1] //.1= 1|0, fps (60,59.94,30.29.96), duplicated (true|false)
+    // finding counting fps and dropped frames
+    let countingFps = 60;
+    let dropFrames = 0;
+    if (Math.floor(fps) == 60) {
+      countingFps = 60;
+      dropFrames = 0;
+    } else if (Math.floor(fps) == 59) {
+      countingFps = 60;
+      dropFrames = 4;
+    } else if (Math.floor(fps) == 30) {
+      countingFps = 30;
+      dropFrames = 0;
+    } else if (Math.floor(fps) == 29) {
+      countingFps = 30;
+      dropFrames = 2;
+    }
+    let result = 0;
+    let framesPerMinute = Math.floor(fps * 60); //3600|3596|1800|1798
+    let framesPer10Minutes = Math.floor(fps * 60 * 10); //36000|35964|18000|17982
+    let framesPerHour = framesPer10Minutes * 6;
+    let hh = timecode[0];
+    let mm = timecode[1];
+    let ss = timecode[2];
+    let ff = timecode[3];
+    let dotOne = timecode[4]; //(timecode[4]==0)?false:true;
+    result += hh * framesPerHour;
+    result += mm * (countingFps * 60);
+    result += ss * countingFps;
+    if (duplicated) result += ff * 2 + dotOne;
+    else result += ff;
+    result -= dropFrames * mm;
+    result += dropFrames * Math.floor(mm / 10); //drop Frames on every minute exept every 10th
+    return result;
+  };
+  
+  export const frames2Timecode = (frames, fps, duplicated) => {
+    //timecode [hh,mm,ss,ff,.1] //.1= 1|0, fps (60,59.94,30.29.96), duplicated (true|false)
+  
+    // finding counting fps and dropped frames
+    let countingFps = 60;
+    let dropFrames = 0;
+    if (Math.floor(fps) == 60) {
+      countingFps = 60;
+      dropFrames = 0;
+    } else if (Math.floor(fps) == 59) {
+      countingFps = 60;
+      dropFrames = 4;
+    } else if (Math.floor(fps) == 30) {
+      countingFps = 30;
+      dropFrames = 0;
+    } else if (Math.floor(fps) == 29) {
+      countingFps = 30;
+      dropFrames = 2;
+    }
+    let result = 0;
+    let framesPerMinute = Math.floor(fps * 60); //3600|3596|1800|1798
+    let framesPer10Minutes = Math.floor(fps * 60 * 10); //36000|35964|18000|17982
+    let framesPerHour = framesPer10Minutes * 6;
+  
+    let framesLeft = frames;
+    let hh = Math.floor(framesLeft / framesPerHour);
+    framesLeft -= hh * framesPerHour;
+    let mm10 = Math.floor(framesLeft / framesPer10Minutes);
+  
+    framesLeft -= mm10 * framesPer10Minutes;
+  
+    if (framesLeft >= countingFps * 60)
+      //3600 (in 59.94fps)
+      framesLeft +=
+        dropFrames *
+        (Math.floor((framesLeft - countingFps * 60) / framesPerMinute) + 1); //3600 /3596 (in 59.94fps)
+  
+    //framesLeft-= Math.floor(framesLeft / framesPerMinute)*(dropFrames)
+  
+    let mm = Math.floor(framesLeft / (countingFps * 60)); //3600 (in 59.94fps)
+  
+    framesLeft -= mm * (countingFps * 60); //3600 (in 59.94fps)
+  
+    let ss = Math.floor(framesLeft / countingFps);
+    framesLeft -= ss * countingFps;
+    let ff = framesLeft;
+    mm += mm10 * 10;
+  
+    let dotOne = 0;
+    if (duplicated) {
+      dotOne = ff % 2;
+      ff = Math.floor(ff / 2);
+    }
+    let returnTimecode = [hh, mm, ss, ff, dotOne];
+    return returnTimecode;
+  };
+  
+  export const timeCodeAddFrames = (tc, framesToAdd, fps) => {
+    let duplicated = fps > 30;
+    let frames = timecode2Frames(tc, fps, duplicated);
+    frames += framesToAdd;
+    return frames2Timecode(frames, fps, duplicated);
+  };
+  
+  export const timeCodeArray2TimeCodeJson = (timeCodeArray) => {
+    return {
+      h: timeCodeArray[0],
+      m: timeCodeArray[1],
+      s: timeCodeArray[2],
+      f: timeCodeArray[3],
+      field: timeCodeArray[4],
+    };
+  };
+  
+  export const timeDate2TCString = (timeDate, fps) => {
+    let tc = timeDate2TC(timeDate, fps);
+    //didn't check new version
+    if (fps > 59) {
+      return printTimecode(tcFromMessage, true);
+    } else {
+      return printTimecode(tcFromMessage, false);
+    }
+  };
+  
+  export const timeDate2TC = (timeDate, fps) => {
+    let timeStampStr = "";
+    if (Platform.isApple()) {
+      timeStampStr = timeDate;
+    } else {
+      timeStampStr = timeDate.toISOString();
+    }
+    let timeStr = timeStampStr.split("T")[1];
+    let arr1 = timeStr.split(":");
+    let hrs = parseInt(arr1[0]);
+    let mins = parseInt(arr1[1]);
+    let arr2 = arr1[2].split(".");
+    let secs = parseInt(arr2[0]);
+    let msec = parseInt(arr2[1].substring(0, 3));
+    //let frames = Math.round(((msec / 1000) * fps)+0.02 /*+ 0.45*/);
+    if (fps > 59) {
+      //let field = (frames % 2 == 0 ? 1 : 2);
+      //frames = Math.floor(frames / 2);
+      //let returnTimecode = [hrs,mins,secs,frames,field-1];
+      let allFrames = Math.round(
+        (msec / 1000 + secs + mins * 60 + hrs * 60 * 60) * fps,
+      );
+      let returnTimecode = frames2Timecode(allFrames, fps, true);
+      return returnTimecode;
+    } else {
+      //let returnTimecode = [hrs,mins,secs,frames,0];
+      //let returnTimecode = BB.Utils.TimeCodesFramesTranslator.frames2Timecode(frames+secs*fps+mins*fps*60+hrs*fps*60*60,fps,false);
+      let allFrames = Math.round(
+        (msec / 1000 + secs + mins * 60 + hrs * 60 * 60) * fps,
+      );
+      let returnTimecode = frames2Timecode(allFrames, fps, false);
+      return returnTimecode;
+    }
+  };
+
+  export const timeCode2Str = (timecode) => {
+    const str = ("0" + timecode.h).slice(-2) + timecodeDelimeter +
+                ("0" + timecode.m).slice(-2) + timecodeDelimeter +
+                ("0" + timecode.s).slice(-2) + timecodeDelimeter +
+                ("0" + timecode.f).slice(-2)
+
+    return str
+  };
+
+  export const addSecondsToTimeCode = (timecode, seconds) => {
+    let ret = { ...timecode }; //cloning araay
+    ret.s += seconds;
+    if (ret.s >= 60) {
+      ret.s = 0;
+      ret.m++;
+      if (ret.m >= 60) {
+        ret.m = 0;
+        ret.h++;
+      }
+    }
+    return ret;
+  };
+
+  export const getNextTimeCode_TC = (tc, seconds = 0) => {
+    let timecode = str2TimeCode(tc, ':');
+    if (seconds) timecode = addSecondsToTimeCode(timecode, seconds);
+    return timecode;
+  };
+
+  export const getNextTimeCode = (tc, seconds = 0) => {
+    let timecode = getNextTimeCode_TC(tc, seconds);
+    return timeCode2Str(timecode);
+  };
+
+  export const isTCBigger = (tc1, tc2) => {
+    //return true iif tc1 > tc2
+    if (tc1.h > tc2.h) return true;
+    else if (tc1.h < tc2.h) return false;
+    else if (tc1.m > tc2.m) return true;
+    else if (tc1.m < tc2.m) return false;
+    else if (tc1.s > tc2.s) return true;
+    else if (tc1.s < tc2.s) return false;
+    else if (tc1.f > tc2.f) return true;
+    else return false;
+  };