shaka-player 4.7.12 → 4.8.0

package/ui/gl_matrix/matrix_4x4.js

@@ -0,0 +1,568 @@
+/*! @license
+ * glMatrix: https://github.com/toji/gl-matrix/
+ * Copyright 2015-2021, Brandon Jones, Colin MacKenzie IV
+ * SPDX-License-Identifier: MIT
+ */
+
+
+goog.provide('shaka.ui.Matrix4x4');
+
+/**
+ * 4x4 Matrix
+ * Format: column-major, when typed out it looks like row-major
+ * The matrices are being post multiplied.
+ */
+shaka.ui.Matrix4x4 = class {
+  /**
+   * Creates a new identity 4x4 Matrix
+   *
+   * @return {!Float32Array} a new 4x4 matrix
+   */
+  static create() {
+    const out = new Float32Array(16);
+    out[0] = 1;
+    out[5] = 1;
+    out[10] = 1;
+    out[15] = 1;
+    return out;
+  }
+
+  /**
+   * Generates a look-at matrix with the given eye position, focal point, and
+   * up axis.
+   *
+   * @param {!Float32Array} out 4x4 matrix frustum matrix will be written into
+   * @param {!Array.<number>} eye Position of the viewer
+   * @param {!Array.<number>} center Point the viewer is looking at
+   * @param {!Array.<number>} up Vector pointing up
+   */
+  static lookAt(out, eye, center, up) {
+    let x0;
+    let x1;
+    let x2;
+    let y0;
+    let y1;
+    let y2;
+    let z0;
+    let z1;
+    let z2;
+    let len;
+    const eyex = eye[0];
+    const eyey = eye[1];
+    const eyez = eye[2];
+    const upx = up[0];
+    const upy = up[1];
+    const upz = up[2];
+    const centerx = center[0];
+    const centery = center[1];
+    const centerz = center[2];
+
+    if (Math.abs(eyex - centerx) < shaka.ui.Matrix4x4.EPSILON_ &&
+      Math.abs(eyey - centery) < shaka.ui.Matrix4x4.EPSILON_ &&
+      Math.abs(eyez - centerz) < shaka.ui.Matrix4x4.EPSILON_) {
+      return shaka.ui.Matrix4x4.identity_(out);
+    }
+
+    z0 = eyex - centerx;
+    z1 = eyey - centery;
+    z2 = eyez - centerz;
+
+    len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);
+    z0 *= len;
+    z1 *= len;
+    z2 *= len;
+
+    x0 = upy * z2 - upz * z1;
+    x1 = upz * z0 - upx * z2;
+    x2 = upx * z1 - upy * z0;
+    len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);
+    if (!len) {
+      x0 = 0;
+      x1 = 0;
+      x2 = 0;
+    } else {
+      len = 1 / len;
+      x0 *= len;
+      x1 *= len;
+      x2 *= len;
+    }
+
+    y0 = z1 * x2 - z2 * x1;
+    y1 = z2 * x0 - z0 * x2;
+    y2 = z0 * x1 - z1 * x0;
+
+    len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);
+    if (!len) {
+      y0 = 0;
+      y1 = 0;
+      y2 = 0;
+    } else {
+      len = 1 / len;
+      y0 *= len;
+      y1 *= len;
+      y2 *= len;
+    }
+
+    out[0] = x0;
+    out[1] = y0;
+    out[2] = z0;
+    out[3] = 0;
+    out[4] = x1;
+    out[5] = y1;
+    out[6] = z1;
+    out[7] = 0;
+    out[8] = x2;
+    out[9] = y2;
+    out[10] = z2;
+    out[11] = 0;
+    out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);
+    out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);
+    out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);
+    out[15] = 1;
+
+    return out;
+  }
+
+  /**
+   * Scales the 4x4 matrix by the dimensions in the given vector not using
+   * vectorization
+   *
+   * @param {!Float32Array} out the receiving matrix
+   * @param {!Float32Array} a the matrix to scale
+   * @param {!Array.<number>} v the vector to scale the matrix by
+   */
+  static scale(out, a, v) {
+    const x = v[0];
+    const y = v[1];
+    const z = v[2];
+
+    out[0] = a[0] * x;
+    out[1] = a[1] * x;
+    out[2] = a[2] * x;
+    out[3] = a[3] * x;
+    out[4] = a[4] * y;
+    out[5] = a[5] * y;
+    out[6] = a[6] * y;
+    out[7] = a[7] * y;
+    out[8] = a[8] * z;
+    out[9] = a[9] * z;
+    out[10] = a[10] * z;
+    out[11] = a[11] * z;
+    out[12] = a[12];
+    out[13] = a[13];
+    out[14] = a[14];
+    out[15] = a[15];
+  }
+
+  /**
+   * Generates a perspective projection matrix with the given bounds.
+   * The near/far clip planes correspond to a normalized device coordinate Z
+   * range of [-1, 1], which matches WebGL's clip volume.
+   * Passing null/undefined/no value for far will generate infinite projection
+   * matrix.
+   *
+   * @param {!Float32Array} out 4x4 matrix frustum matrix will be written into
+   * @param {number} fovy Vertical field of view in radians
+   * @param {number} aspect Aspect ratio. typically viewport width/height
+   * @param {number} near Near bound of the frustum
+   * @param {number} far Far bound of the frustum, can be null or Infinity
+   */
+  static perspective(out, fovy, aspect, near, far) {
+    const f = 1.0 / Math.tan(fovy / 2);
+    out[0] = f / aspect;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[5] = f;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[11] = -1;
+    out[12] = 0;
+    out[13] = 0;
+    out[15] = 0;
+    if (far != null && far !== Infinity) {
+      const nf = 1 / (near - far);
+      out[10] = (far + near) * nf;
+      out[14] = 2 * far * near * nf;
+    } else {
+      out[10] = -1;
+      out[14] = -2 * near;
+    }
+    return out;
+  }
+
+  /**
+   * Multiplies two 4x4 matrix
+   *
+   * @param {!Float32Array} out the receiving matrix
+   * @param {!Float32Array} a the first operand
+   * @param {!Float32Array} b the second operand
+   */
+  static multiply(out, a, b) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+    const a30 = a[12];
+    const a31 = a[13];
+    const a32 = a[14];
+    const a33 = a[15];
+
+    // Cache only the current line of the second matrix
+    let b0 = b[0];
+    let b1 = b[1];
+    let b2 = b[2];
+    let b3 = b[3];
+    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[4];
+    b1 = b[5];
+    b2 = b[6];
+    b3 = b[7];
+    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[8];
+    b1 = b[9];
+    b2 = b[10];
+    b3 = b[11];
+    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[12];
+    b1 = b[13];
+    b2 = b[14];
+    b3 = b[15];
+    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+  }
+
+  /**
+   * Generates a frustum matrix with the given bounds
+   *
+   * @param {!Float32Array} out 4x4 matrix frustum matrix will be written into
+   * @param {number} left Left bound of the frustum
+   * @param {number} right Right bound of the frustum
+   * @param {number} bottom Bottom bound of the frustum
+   * @param {number} top Top bound of the frustum
+   * @param {number} near Near bound of the frustum
+   * @param {number} far Far bound of the frustum
+   */
+  static frustum(out, left, right, bottom, top, near, far) {
+    const rl = 1 / (right - left);
+    const tb = 1 / (top - bottom);
+    const nf = 1 / (near - far);
+    out[0] = near * 2 * rl;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[5] = near * 2 * tb;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = (right + left) * rl;
+    out[9] = (top + bottom) * tb;
+    out[10] = (far + near) * nf;
+    out[11] = -1;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = far * near * 2 * nf;
+    out[15] = 0;
+    return out;
+  }
+
+  /**
+   * Rotates a matrix by the given angle around the X axis
+   *
+   * @param {!Float32Array} out the receiving matrix
+   * @param {!Float32Array} a the matrix to rotate
+   * @param {number} rad the angle to rotate the matrix by
+   */
+  static rotateX(out, a, rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+
+    if (a !== out) {
+      // If the source and destination differ, copy the unchanged rows
+      out[0] = a[0];
+      out[1] = a[1];
+      out[2] = a[2];
+      out[3] = a[3];
+      out[12] = a[12];
+      out[13] = a[13];
+      out[14] = a[14];
+      out[15] = a[15];
+    }
+
+    // Perform axis-specific matrix multiplication
+    out[4] = a10 * c + a20 * s;
+    out[5] = a11 * c + a21 * s;
+    out[6] = a12 * c + a22 * s;
+    out[7] = a13 * c + a23 * s;
+    out[8] = a20 * c - a10 * s;
+    out[9] = a21 * c - a11 * s;
+    out[10] = a22 * c - a12 * s;
+    out[11] = a23 * c - a13 * s;
+  }
+
+  /**
+   * Rotates a matrix by the given angle around the Y axis
+   *
+   * @param {!Float32Array} out the receiving matrix
+   * @param {!Float32Array} a the matrix to rotate
+   * @param {number} rad the angle to rotate the matrix by
+   */
+  static rotateY(out, a, rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a20 = a[8];
+    const a21 = a[9];
+    const a22 = a[10];
+    const a23 = a[11];
+
+    if (a !== out) {
+      // If the source and destination differ, copy the unchanged rows
+      out[4] = a[4];
+      out[5] = a[5];
+      out[6] = a[6];
+      out[7] = a[7];
+      out[12] = a[12];
+      out[13] = a[13];
+      out[14] = a[14];
+      out[15] = a[15];
+    }
+
+    // Perform axis-specific matrix multiplication
+    out[0] = a00 * c - a20 * s;
+    out[1] = a01 * c - a21 * s;
+    out[2] = a02 * c - a22 * s;
+    out[3] = a03 * c - a23 * s;
+    out[8] = a00 * s + a20 * c;
+    out[9] = a01 * s + a21 * c;
+    out[10] = a02 * s + a22 * c;
+    out[11] = a03 * s + a23 * c;
+  }
+
+  /**
+   * Rotates a matrix by the given angle around the Z axis
+   *
+   * @param {!Float32Array} out the receiving matrix
+   * @param {!Float32Array} a the matrix to rotate
+   * @param {number} rad the angle to rotate the matrix by
+   */
+  static rotateZ(out, a, rad) {
+    const s = Math.sin(rad);
+    const c = Math.cos(rad);
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a03 = a[3];
+    const a10 = a[4];
+    const a11 = a[5];
+    const a12 = a[6];
+    const a13 = a[7];
+
+    if (a !== out) {
+      // If the source and destination differ, copy the unchanged last row
+      out[8] = a[8];
+      out[9] = a[9];
+      out[10] = a[10];
+      out[11] = a[11];
+      out[12] = a[12];
+      out[13] = a[13];
+      out[14] = a[14];
+      out[15] = a[15];
+    }
+
+    // Perform axis-specific matrix multiplication
+    out[0] = a00 * c + a10 * s;
+    out[1] = a01 * c + a11 * s;
+    out[2] = a02 * c + a12 * s;
+    out[3] = a03 * c + a13 * s;
+    out[4] = a10 * c - a00 * s;
+    out[5] = a11 * c - a01 * s;
+    out[6] = a12 * c - a02 * s;
+    out[7] = a13 * c - a03 * s;
+  }
+
+  /**
+   * Returns a quaternion representing the rotational component
+   * of a transformation matrix. If a matrix is built with
+   * fromRotationTranslation, the returned quaternion will be the
+   * same as the quaternion originally supplied.
+   * @param {!Float32Array} out Quaternion to receive the rotation component
+   * @param {!Float32Array} mat Matrix to be decomposed (input)
+   */
+  static getRotation(out, mat) {
+    const scaling = new Float32Array(3);
+    shaka.ui.Matrix4x4.getScaling_(scaling, mat);
+
+    const is1 = 1 / scaling[0];
+    const is2 = 1 / scaling[1];
+    const is3 = 1 / scaling[2];
+
+    const sm11 = mat[0] * is1;
+    const sm12 = mat[1] * is2;
+    const sm13 = mat[2] * is3;
+    const sm21 = mat[4] * is1;
+    const sm22 = mat[5] * is2;
+    const sm23 = mat[6] * is3;
+    const sm31 = mat[8] * is1;
+    const sm32 = mat[9] * is2;
+    const sm33 = mat[10] * is3;
+
+    const trace = sm11 + sm22 + sm33;
+    let S = 0;
+
+    if (trace > 0) {
+      S = Math.sqrt(trace + 1.0) * 2;
+      out[3] = 0.25 * S;
+      out[0] = (sm23 - sm32) / S;
+      out[1] = (sm31 - sm13) / S;
+      out[2] = (sm12 - sm21) / S;
+    } else if (sm11 > sm22 && sm11 > sm33) {
+      S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;
+      out[3] = (sm23 - sm32) / S;
+      out[0] = 0.25 * S;
+      out[1] = (sm12 + sm21) / S;
+      out[2] = (sm31 + sm13) / S;
+    } else if (sm22 > sm33) {
+      S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;
+      out[3] = (sm31 - sm13) / S;
+      out[0] = (sm12 + sm21) / S;
+      out[1] = 0.25 * S;
+      out[2] = (sm23 + sm32) / S;
+    } else {
+      S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;
+      out[3] = (sm12 - sm21) / S;
+      out[0] = (sm31 + sm13) / S;
+      out[1] = (sm23 + sm32) / S;
+      out[2] = 0.25 * S;
+    }
+
+    return out;
+  }
+
+  /**
+   * Calculates a 4x4 matrix from the given quaternion
+   *
+   * @param {!Float32Array} out 4x4 matrix receiving operation result
+   * @param {!Float32Array} q Quaternion to create matrix from
+   */
+  static fromQuat(out, q) {
+    const x = q[0];
+    const y = q[1];
+    const z = q[2];
+    const w = q[3];
+    const x2 = x + x;
+    const y2 = y + y;
+    const z2 = z + z;
+
+    const xx = x * x2;
+    const yx = y * x2;
+    const yy = y * y2;
+    const zx = z * x2;
+    const zy = z * y2;
+    const zz = z * z2;
+    const wx = w * x2;
+    const wy = w * y2;
+    const wz = w * z2;
+
+    out[0] = 1 - yy - zz;
+    out[1] = yx + wz;
+    out[2] = zx - wy;
+    out[3] = 0;
+
+    out[4] = yx - wz;
+    out[5] = 1 - xx - zz;
+    out[6] = zy + wx;
+    out[7] = 0;
+
+    out[8] = zx + wy;
+    out[9] = zy - wx;
+    out[10] = 1 - xx - yy;
+    out[11] = 0;
+
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+    out[15] = 1;
+  }
+
+
+  /**
+   * Set a 4x4 matrix to the identity matrix
+   *
+   * @param {!Float32Array} out the receiving matrix
+   * @private
+   */
+  static identity_(out) {
+    for (let i = 0; i < 16; i++) {
+      out[i] = (i % 5) == 0 ? 1 : 0;
+    }
+  }
+
+  /**
+   * Returns the scaling factor component of a transformation
+   * matrix. If a matrix is built with fromRotationTranslationScale
+   * with a normalized Quaternion paramter, the returned vector will be
+   * the same as the scaling vector
+   * originally supplied.
+   * @param  {!Float32Array} out Vector to receive scaling factor component
+   * @param  {!Float32Array} mat Matrix to be decomposed (input)
+   * @private
+   */
+  static getScaling_(out, mat) {
+    const m11 = mat[0];
+    const m12 = mat[1];
+    const m13 = mat[2];
+    const m21 = mat[4];
+    const m22 = mat[5];
+    const m23 = mat[6];
+    const m31 = mat[8];
+    const m32 = mat[9];
+    const m33 = mat[10];
+
+    out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+    out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+    out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
+  }
+};
+
+/**
+ * @const {number}
+ * @private
+ */
+shaka.ui.Matrix4x4.EPSILON_ = 0.000001;

package/ui/gl_matrix/matrix_quaternion.js

@@ -0,0 +1,45 @@
+/*! @license
+ * glMatrix: https://github.com/toji/gl-matrix/
+ * Copyright 2015-2021, Brandon Jones, Colin MacKenzie IV
+ * SPDX-License-Identifier: MIT
+ */
+
+
+goog.provide('shaka.ui.MatrixQuaternion');
+
+/**
+ * Quaternion in the format XYZW
+ */
+shaka.ui.MatrixQuaternion = class {
+  /**
+   * Creates a new identity quaternion
+   *
+   * @return {!Float32Array} a new quaternion
+   */
+  static create() {
+    const out = new Float32Array(4);
+    out[3] = 1;
+    return out;
+  }
+
+  /**
+   * Normalize a quaternion
+   *
+   * @param {!Float32Array} out the receiving quaternion
+   * @param {!Float32Array} a quaternion to normalize
+   */
+  static normalize(out, a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const w = a[3];
+    let len = x * x + y * y + z * z + w * w;
+    if (len > 0) {
+      len = 1 / Math.sqrt(len);
+    }
+    out[0] = x * len;
+    out[1] = y * len;
+    out[2] = z * len;
+    out[3] = w * len;
+  }
+};

package/ui/less/containers.less

@@ -110,6 +110,17 @@
   pointer-events: none;
 }
 
+/* A container for VR
+ * Sits inside .shaka-video-container, on top of (Z axis) .shaka-video, and
+ * below (Y axis) .shaka-play-button-container. */
+.shaka-vr-canvas-container {
+  .overlay-child();
+
+  /* Make sure pointer events can reach the video element in the case of native
+   * controls. */
+  pointer-events: none;
+}
+
 /* Container for controls positioned at the bottom of the video container:
  * controls button panel and the seek bar. */
 .shaka-bottom-controls {

package/ui/locales/en-GB.json

@@ -26,11 +26,13 @@
   "PICTURE_IN_PICTURE": "Picture-in-picture",
   "PLAY": "Play",
   "PLAYBACK_RATE": "Playback speed",
+  "RECENTER_VR": "Recenter",
   "RESOLUTION": "Resolution",
   "REWIND": "Rewind",
   "SEEK": "Seek",
   "SKIP_AD": "Skip ad",
   "SKIP_TO_LIVE": "Skip ahead to live",
+  "TOGGLE_STEREOSCOPIC": "Toggle stereoscopic",
   "UNDETERMINED_LANGUAGE": "Undetermined",
   "UNMUTE": "Unmute",
   "UNRECOGNIZED_LANGUAGE": "Unrecognised",

package/ui/locales/en.json

@@ -28,6 +28,7 @@
   "PLAY": "Play",
   "PLAYBACK_RATE": "Playback speed",
   "QUALITY": "Quality",
+  "RECENTER_VR": "Recenter",
   "REPLAY": "Replay",
   "RESOLUTION": "Resolution",
   "REWIND": "Rewind",
@@ -37,6 +38,7 @@
   "STATISTICS": "Statistics",
   "SUBTITLE_FORCED": "Forced",
   "SURROUND": "Surround",
+  "TOGGLE_STEREOSCOPIC": "Toggle stereoscopic",
   "UNDETERMINED_LANGUAGE": "Undetermined",
   "UNMUTE": "Unmute",
   "UNRECOGNIZED_LANGUAGE": "Unrecognized",

package/ui/locales/es-419.json

@@ -26,6 +26,7 @@
   "PICTURE_IN_PICTURE": "Pantalla en pantalla",
   "PLAY": "Reproducir",
   "PLAYBACK_RATE": "Velocidad de reproducción",
+  "RECENTER_VR": "Recentrar",
   "RESOLUTION": "Resolución",
   "REWIND": "Retroceder",
   "SEEK": "Buscar",
@@ -33,6 +34,7 @@
   "SKIP_TO_LIVE": "Adelantar hasta la transmisión en vivo",
   "SUBTITLE_FORCED": "Forzado",
   "SURROUND": "Envolvente",
+  "TOGGLE_STEREOSCOPIC": "Alternar estereoscópico",
   "UNDETERMINED_LANGUAGE": "Sin especificar",
   "UNMUTE": "Dejar de silenciar",
   "UNRECOGNIZED_LANGUAGE": "No reconocida",

package/ui/locales/es.json

@@ -26,6 +26,7 @@
   "PICTURE_IN_PICTURE": "Imagen en imagen",
   "PLAY": "Reproducir",
   "PLAYBACK_RATE": "Velocidad de reproducción",
+  "RECENTER_VR": "Recentrar",
   "RESOLUTION": "Resolución",
   "REWIND": "Rebobinar",
   "SEEK": "Buscar",
@@ -33,6 +34,7 @@
   "SKIP_TO_LIVE": "Ir al vídeo en directo",
   "SUBTITLE_FORCED": "Forzado",
   "SURROUND": "Envolvente",
+  "TOGGLE_STEREOSCOPIC": "Alternar estereoscópico",
   "UNDETERMINED_LANGUAGE": "Sin especificar",
   "UNMUTE": "Activar sonido",
   "UNRECOGNIZED_LANGUAGE": "No reconocida",

package/ui/locales/source.json

@@ -118,6 +118,10 @@
     "meaning": "Audio quality",
     "message": "Quality"
   },
+  "RECENTER_VR": {
+    "description": "Label for a button used to recenter the VR view.",
+    "message": "Recenter"
+  },
   "REPLAY": {
     "description": "Label for a button used to replay the video in a video player.",
     "message": "Replay"
@@ -155,6 +159,10 @@
     "description": "Label used to identify a audio track that has surround audio.",
     "message": "Surround"
   },
+  "TOGGLE_STEREOSCOPIC": {
+    "description": "Label for a button that toggle between monoscopic and stereoscopic.",
+    "message": "Toggle stereoscopic"
+  },
   "UNDETERMINED_LANGUAGE": {
     "description": "Label for a button used to select an audio track whose language is undetermined or unknown.",
     "message": "Undetermined"