shaka-player 4.9.7 → 4.9.9

package/lib/cea/mp4_cea_parser.js

@@ -164,53 +164,62 @@ shaka.cea.Mp4CeaParser = class {
     /** @type {!Array<!shaka.extern.ICeaParser.CaptionPacket>} **/
     const captionPackets = [];
 
-    // Fields that are found in MOOF boxes
-    let defaultSampleDuration = this.defaultSampleDuration_;
-    let defaultSampleSize = this.defaultSampleSize_;
     let moofOffset = 0;
-    /** @type {!Array<shaka.util.ParsedTRUNBox>} */
-    let parsedTRUNs = [];
-    let baseMediaDecodeTime = null;
-    let timescale = shaka.cea.CeaUtils.DEFAULT_TIMESCALE_VALUE;
+
+    /** @type {!Array<!shaka.cea.Mp4CeaParser.ParsedTRAF>} */
+    let parsedTRAFs = [];
 
     new Mp4Parser()
         .box('moof', (box) => {
           moofOffset = box.start;
-          // trun box parsing is reset on each moof.
-          parsedTRUNs = [];
+          // traf box parsing is reset on each moof.
+          parsedTRAFs = [];
+          Mp4Parser.children(box);
+        })
+        .box('traf', (box) => {
+          parsedTRAFs.push({
+            baseMediaDecodeTime: null,
+            defaultSampleDuration: this.defaultSampleDuration_,
+            defaultSampleSize: this.defaultSampleSize_,
+            parsedTRUNs: [],
+            timescale: shaka.cea.CeaUtils.DEFAULT_TIMESCALE_VALUE,
+          });
           Mp4Parser.children(box);
         })
-        .box('traf', Mp4Parser.children)
         .fullBox('trun', (box) => {
           goog.asserts.assert(
-              box.version != null && box.flags!=null,
+              box.version != null && box.flags != null,
               'TRUN is a full box and should have a valid version & flags.');
 
+          const lastTRAF = parsedTRAFs[parsedTRAFs.length - 1];
+
           const parsedTRUN = shaka.util.Mp4BoxParsers.parseTRUN(
               box.reader, box.version, box.flags);
-          parsedTRUNs.push(parsedTRUN);
+          lastTRAF.parsedTRUNs.push(parsedTRUN);
         })
         .fullBox('tfhd', (box) => {
           goog.asserts.assert(
               box.flags != null,
               'TFHD is a full box and should have valid flags.');
 
+          const lastTRAF = parsedTRAFs[parsedTRAFs.length - 1];
+
           const parsedTFHD = shaka.util.Mp4BoxParsers.parseTFHD(
               box.reader, box.flags);
 
           // If specified, defaultSampleDuration and defaultSampleSize
           // override the ones specified in the TREX box
-          defaultSampleDuration = parsedTFHD.defaultSampleDuration ||
+          lastTRAF.defaultSampleDuration = parsedTFHD.defaultSampleDuration ||
               this.defaultSampleDuration_;
 
-          defaultSampleSize = parsedTFHD.defaultSampleSize ||
+          lastTRAF.defaultSampleSize = parsedTFHD.defaultSampleSize ||
               this.defaultSampleSize_;
 
           const trackId = parsedTFHD.trackId;
 
           // Get the timescale from the track Id
           if (this.trackIdToTimescale_.has(trackId)) {
-            timescale = this.trackIdToTimescale_.get(trackId);
+            lastTRAF.timescale = this.trackIdToTimescale_.get(trackId);
           }
         })
         .fullBox('tfdt', (box) => {
@@ -218,27 +227,37 @@ shaka.cea.Mp4CeaParser = class {
               box.version != null,
               'TFDT is a full box and should have a valid version.');
 
+          const lastTRAF = parsedTRAFs[parsedTRAFs.length - 1];
+
           const parsedTFDT = shaka.util.Mp4BoxParsers.parseTFDTInaccurate(
               box.reader, box.version);
 
-          baseMediaDecodeTime = parsedTFDT.baseMediaDecodeTime;
+          lastTRAF.baseMediaDecodeTime = parsedTFDT.baseMediaDecodeTime;
         })
         .box('mdat', (box) => {
-          if (baseMediaDecodeTime === null) {
-            // This field should have been populated by the Base Media Decode
-            // Time in the tfdt box.
-            shaka.log.alwaysWarn(
-                'Unable to find base media decode time for CEA captions!');
-            throw new shaka.util.Error(
-                shaka.util.Error.Severity.CRITICAL,
-                shaka.util.Error.Category.TEXT,
-                shaka.util.Error.Code.INVALID_MP4_CEA);
-          }
-
           const offset = moofOffset - box.start - 8;
-          this.parseMdat_(box.reader, baseMediaDecodeTime, timescale,
-              defaultSampleDuration, defaultSampleSize, offset, parsedTRUNs,
-              captionPackets);
+          const initialPosition = box.reader.getPosition();
+          for (const parsedTRAF of parsedTRAFs) {
+            if (parsedTRAF.baseMediaDecodeTime === null) {
+              // This field should have been populated by the Base Media Decode
+              // Time in the tfdt box.
+              shaka.log.alwaysWarn(
+                  'Unable to find base media decode time for CEA captions!');
+              throw new shaka.util.Error(
+                  shaka.util.Error.Severity.CRITICAL,
+                  shaka.util.Error.Category.TEXT,
+                  shaka.util.Error.Code.INVALID_MP4_CEA);
+            }
+            box.reader.seek(initialPosition);
+            this.parseMdat_(box.reader,
+                parsedTRAF.baseMediaDecodeTime,
+                parsedTRAF.timescale,
+                parsedTRAF.defaultSampleDuration,
+                parsedTRAF.defaultSampleSize,
+                offset,
+                parsedTRAF.parsedTRUNs,
+                captionPackets);
+          }
         })
         .parse(mediaSegment, /* partialOkay= */ false);
 
@@ -315,7 +334,7 @@ shaka.cea.Mp4CeaParser = class {
           timeOffset = sampleData[sampleIndex].sampleCompositionTimeOffset || 0;
         }
 
-        const pts = (time + timeOffset)/timescale;
+        const pts = (time + timeOffset) / timescale;
         for (const packet of this.seiProcessor_
             .process(reader.readBytes(naluSize - naluHeaderSize))) {
           captionPackets.push({
@@ -384,5 +403,22 @@ shaka.cea.Mp4CeaParser.CodecBitstreamMap_ = {
   'dvhe': shaka.cea.Mp4CeaParser.BitstreamFormat.H265,
 };
 
+/**
+ * @typedef {{
+ *    baseMediaDecodeTime: ?number,
+ *    defaultSampleDuration: number,
+ *    defaultSampleSize: number,
+ *    parsedTRUNs: !Array<shaka.util.ParsedTRUNBox>,
+ *    timescale: number
+ * }}
+ *
+ * @property {?number} baseMediaDecodeTime
+ * @property {number} defaultSampleDuration
+ * @property {number} defaultSampleSize
+ * @property {!Array<shaka.util.ParsedTRUNBox>} parsedTRUNs
+ * @property {?number} timescale
+ */
+shaka.cea.Mp4CeaParser.ParsedTRAF;
+
 shaka.media.ClosedCaptionParser.registerParser('video/mp4',
     () => new shaka.cea.Mp4CeaParser());

package/lib/hls/hls_parser.js

@@ -2319,24 +2319,32 @@ shaka.hls.HlsParser = class {
           this.config_.hls.disableCodecGuessing) ||
           (this.needsClosedCaptionsDetection_ && type == ContentType.VIDEO &&
           !this.config_.hls.disableClosedCaptionsDetection)) {
-        this.needsClosedCaptionsDetection_ = false;
-
-        const basicInfo = await this.getMediaPlaylistBasicInfo_(
-            playlist, getUris, mediaVariables);
-
-        goog.asserts.assert(
-            type === basicInfo.type, 'Media types should match!');
-
-        if (basicInfo.closedCaptions.size && (!closedCaptions ||
-            closedCaptions.size != basicInfo.closedCaptions.size)) {
-          closedCaptions = basicInfo.closedCaptions;
-          closedCaptionsUpdated = true;
+        let canRequestBasicInfo = playlist.segments.length > 0;
+        if (canRequestBasicInfo) {
+          const segment = playlist.segments[0];
+          if (shaka.hls.Utils.getFirstTagWithName(segment.tags, 'EXT-X-GAP')) {
+            canRequestBasicInfo = false;
+          }
         }
+        if (canRequestBasicInfo) {
+          this.needsClosedCaptionsDetection_ = false;
+          const basicInfo = await this.getMediaPlaylistBasicInfo_(
+              playlist, getUris, mediaVariables);
+
+          goog.asserts.assert(
+              type === basicInfo.type, 'Media types should match!');
+
+          if (basicInfo.closedCaptions.size && (!closedCaptions ||
+              closedCaptions.size != basicInfo.closedCaptions.size)) {
+            closedCaptions = basicInfo.closedCaptions;
+            closedCaptionsUpdated = true;
+          }
 
-        if (!this.codecInfoInManifest_ &&
-            this.config_.hls.disableCodecGuessing) {
-          mimeType = basicInfo.mimeType;
-          codecs = basicInfo.codecs;
+          if (!this.codecInfoInManifest_ &&
+              this.config_.hls.disableCodecGuessing) {
+            mimeType = basicInfo.mimeType;
+            codecs = basicInfo.codecs;
+          }
         }
       }
 
@@ -3944,9 +3952,14 @@ shaka.hls.HlsParser = class {
         'Playlist should have segments!');
     const middleSegmentIdx = Math.trunc((playlist.segments.length - 1) / 2);
 
+    const middleSegment = playlist.segments[middleSegmentIdx];
+    if (shaka.hls.Utils.getFirstTagWithName(middleSegment.tags, 'EXT-X-GAP')) {
+      return this.guessMimeTypeFallback_(contentType);
+    }
+
     const middleSegmentUris = shaka.hls.Utils.constructSegmentUris(
         getUris(),
-        playlist.segments[middleSegmentIdx].verbatimSegmentUri,
+        middleSegment.verbatimSegmentUri,
         variables);
 
     const parsedUri = new goog.Uri(middleSegmentUris[0]);

package/lib/hls/manifest_text_parser.js

@@ -312,4 +312,5 @@ shaka.hls.ManifestTextParser.SEGMENT_TAGS = [
   'EXT-X-KEY',
   'EXT-X-DATERANGE',
   'EXT-X-MAP',
+  'EXT-X-GAP',
 ];

package/lib/media/segment_utils.js

@@ -140,7 +140,7 @@ shaka.media.SegmentUtils = class {
     const SegmentUtils = shaka.media.SegmentUtils;
 
     const audioCodecs = [];
-    const videoCodecs = [];
+    let videoCodecs = [];
 
     let hasAudio = false;
     let hasVideo = false;
@@ -179,6 +179,7 @@ shaka.media.SegmentUtils = class {
           break;
         case 'ac-3':
         case 'ec-3':
+        case 'ac-4':
         case 'opus':
         case 'flac':
           audioCodecs.push(codecLC);
@@ -207,6 +208,19 @@ shaka.media.SegmentUtils = class {
     /** @type {?string} */
     let baseBox;
 
+    const genericAudioBox = (box) => {
+      const parsedAudioSampleEntryBox =
+          shaka.util.Mp4BoxParsers.audioSampleEntry(box.reader);
+      channelCount = parsedAudioSampleEntryBox.channelCount;
+      sampleRate = parsedAudioSampleEntryBox.sampleRate;
+      codecBoxParser(box);
+    };
+
+    const genericVideoBox = (box) => {
+      baseBox = box.name;
+      Mp4Parser.visualSampleEntry(box);
+    };
+
     new Mp4Parser()
         .box('moov', Mp4Parser.children)
         .box('trak', Mp4Parser.children)
@@ -235,9 +249,10 @@ shaka.media.SegmentUtils = class {
         // AUDIO
         // These are the various boxes that signal a codec.
         .box('mp4a', (box) => {
-          const parsedMP4ABox = shaka.util.Mp4BoxParsers.parseMP4A(box.reader);
-          channelCount = parsedMP4ABox.channelCount;
-          sampleRate = parsedMP4ABox.sampleRate;
+          const parsedAudioSampleEntryBox =
+              shaka.util.Mp4BoxParsers.audioSampleEntry(box.reader);
+          channelCount = parsedAudioSampleEntryBox.channelCount;
+          sampleRate = parsedAudioSampleEntryBox.sampleRate;
           if (box.reader.hasMoreData()) {
             Mp4Parser.children(box);
           } else {
@@ -249,54 +264,24 @@ shaka.media.SegmentUtils = class {
           audioCodecs.push(parsedESDSBox.codec);
           hasAudio = true;
         })
-        .box('ac-3', codecBoxParser)
-        .box('ec-3', codecBoxParser)
-        .box('opus', codecBoxParser)
-        .box('Opus', codecBoxParser)
-        .box('fLaC', codecBoxParser)
+        .box('ac-3', genericAudioBox)
+        .box('ec-3', genericAudioBox)
+        .box('ac-4', genericAudioBox)
+        .box('Opus', genericAudioBox)
+        .box('fLaC', genericAudioBox)
 
         // VIDEO
         // These are the various boxes that signal a codec.
-        .box('avc1', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
-        .box('avc3', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
-        .box('hev1', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
-        .box('hvc1', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
-        .box('dva1', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
-        .box('dvav', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
-        .box('dvh1', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
-        .box('dvhe', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
-        .box('vp09', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
-        .box('av01', (box) => {
-          baseBox = box.name;
-          Mp4Parser.visualSampleEntry(box);
-        })
+        .box('avc1', genericVideoBox)
+        .box('avc3', genericVideoBox)
+        .box('hev1', genericVideoBox)
+        .box('hvc1', genericVideoBox)
+        .box('dva1', genericVideoBox)
+        .box('dvav', genericVideoBox)
+        .box('dvh1', genericVideoBox)
+        .box('dvhe', genericVideoBox)
+        .box('vp09', genericVideoBox)
+        .box('av01', genericVideoBox)
         .box('avcC', (box) => {
           let codecBase = baseBox || '';
           switch (baseBox) {
@@ -375,6 +360,13 @@ shaka.media.SegmentUtils = class {
         })
 
         .box('colr', (box) => {
+          videoCodecs = videoCodecs.map((codec) => {
+            if (codec.startsWith('av01.')) {
+              return shaka.util.Mp4BoxParsers.updateAV1CodecWithCOLRBox(
+                  codec, box.reader);
+            }
+            return codec;
+          });
           const {videoRange, colorGamut} =
               shaka.util.Mp4BoxParsers.parseCOLR(box.reader);
           realVideoRange = videoRange;

package/lib/media/streaming_engine.js

@@ -134,6 +134,12 @@ shaka.media.StreamingEngine = class {
       projection: null,
       hfov: null,
     };
+
+    /** @private {number} */
+    this.playRangeStart_ = 0;
+
+    /** @private {number} */
+    this.playRangeEnd_ = Infinity;
   }
 
   /** @override */
@@ -251,6 +257,20 @@ shaka.media.StreamingEngine = class {
   }
 
 
+  /**
+   * Applies a playback range. This will only affect non-live content.
+   *
+   * @param {number} playRangeStart
+   * @param {number} playRangeEnd
+   */
+  applyPlayRange(playRangeStart, playRangeEnd) {
+    if (!this.manifest_.presentationTimeline.isLive()) {
+      this.playRangeStart_ = playRangeStart;
+      this.playRangeEnd_ = playRangeEnd;
+    }
+  }
+
+
   /**
    * Initialize and start streaming.
    *
@@ -1899,10 +1919,11 @@ shaka.media.StreamingEngine = class {
     // Rounding issues can cause us to remove the first frame of a Period, so
     // reduce the window start time slightly.
     const appendWindowStart = Math.max(0,
-        reference.appendWindowStart -
+        Math.max(reference.appendWindowStart, this.playRangeStart_) -
         StreamingEngine.APPEND_WINDOW_START_FUDGE_);
     const appendWindowEnd =
-        reference.appendWindowEnd + StreamingEngine.APPEND_WINDOW_END_FUDGE_;
+        Math.min(reference.appendWindowEnd, this.playRangeEnd_) +
+        StreamingEngine.APPEND_WINDOW_END_FUDGE_;
 
     goog.asserts.assert(
         reference.startTime <= appendWindowEnd,
@@ -2670,7 +2691,10 @@ shaka.media.StreamingEngine = class {
     }
 
     // First fire an error event.
-    this.playerInterface_.onError(error);
+    if (!error.handled ||
+        error.code != shaka.util.Error.Code.SEGMENT_MISSING) {
+      this.playerInterface_.onError(error);
+    }
 
     // If the error was not handled by the application, call the failure
     // callback.

package/lib/player.js

@@ -2401,6 +2401,8 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
         this.config_.playRangeStart,
         this.config_.playRangeEnd);
 
+    this.streamingEngine_.applyPlayRange(
+        this.config_.playRangeStart, this.config_.playRangeEnd);
 
     const setupPlayhead = (startTime) => {
       this.playhead_ = this.createPlayhead(startTime);
@@ -7457,7 +7459,7 @@ shaka.Player.TYPICAL_BUFFERING_THRESHOLD_ = 0.5;
  * @export
  */
 // eslint-disable-next-line no-useless-concat
-shaka.Player.version = 'v4.9.7' + '-uncompiled';  // x-release-please-version
+shaka.Player.version = 'v4.9.9' + '-uncompiled';  // x-release-please-version
 
 // Initialize the deprecation system using the version string we just set
 // on the player.

package/lib/util/mime_utils.js

@@ -174,7 +174,12 @@ shaka.util.MimeUtils = class {
         return 'hevc'; // H265
       case base === 'dvh1':
       case base === 'dvhe':
-        return 'dovi'; // Dolby Vision
+        return 'dovi-hevc'; // Dolby Vision based in HEVC
+      case base === 'dvav':
+      case base === 'dva1':
+        return 'dovi-avc'; // Dolby Vision based in AVC
+      case base === 'dav1':
+        return 'dovi-av1'; // Dolby Vision based in AV1
     }
     return base;
   }

package/lib/util/mp4_box_parsers.js

@@ -275,11 +275,11 @@ shaka.util.Mp4BoxParsers = class {
   }
 
   /**
-   * Parses a MP4A box.
+   * Parses an audio sample entry box.
    * @param {!shaka.util.DataViewReader} reader
-   * @return {!shaka.util.ParsedMP4ABox}
+   * @return {!shaka.util.ParsedAudioSampleEntryBox}
    */
-  static parseMP4A(reader) {
+  static audioSampleEntry(reader) {
     reader.skip(6); // Skip "reserved"
     reader.skip(2); // Skip "data_reference_index"
     reader.skip(8); // Skip "reserved"
@@ -604,6 +604,42 @@ shaka.util.Mp4BoxParsers = class {
     };
   }
 
+  /**
+   * Parses AV1 codec string with COLR box information.
+   *
+   * AV1 codec info: https://aomediacodec.github.io/av1-isobmff/#codecsparam
+   *
+   * @param {string} codec
+   * @param {!shaka.util.DataViewReader} reader
+   * @return {string}
+   */
+  static updateAV1CodecWithCOLRBox(codec, reader) {
+    const Mp4BoxParsers = shaka.util.Mp4BoxParsers;
+    const initialPosition = reader.getPosition();
+    const data = reader.readBytes(4);
+    let colorType = '';
+    colorType += String.fromCharCode(data[0]);
+    colorType += String.fromCharCode(data[1]);
+    colorType += String.fromCharCode(data[2]);
+    colorType += String.fromCharCode(data[3]);
+    if (colorType === 'nclx') {
+      const colorPrimaries = reader.readUint16();
+      const transferCharacteristics = reader.readUint16();
+      const matrixCoefficients = reader.readUint16();
+      const videoFullRangeFlag = reader.readUint8() >> 7;
+      const codecParts = codec.split('.');
+      if (codecParts.length == 10) {
+        codecParts[6] = Mp4BoxParsers.addLeadingZero_(colorPrimaries);
+        codecParts[7] = Mp4BoxParsers.addLeadingZero_(transferCharacteristics);
+        codecParts[8] = Mp4BoxParsers.addLeadingZero_(matrixCoefficients);
+        codecParts[9] = String(videoFullRangeFlag);
+        codec = codecParts.join('.');
+      }
+    }
+    reader.seek(initialPosition);
+    return codec;
+  }
+
   /**
    * Convert a number to hex
    * @param {number} x
@@ -820,7 +856,7 @@ shaka.util.ParsedTENCBox;
  *
  * @exportDoc
  */
-shaka.util.ParsedMP4ABox;
+shaka.util.ParsedAudioSampleEntryBox;
 
 /**
  * @typedef {{

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shaka-player",
   "description": "DASH/EME video player library",
-  "version": "4.9.7",
+  "version": "4.9.9",
   "homepage": "https://github.com/shaka-project/shaka-player",
   "author": "Google",
   "maintainers": [

package/ui/locales/es.json

@@ -2,6 +2,7 @@
   "AD_DURATION": "Duración del anuncio",
   "AD_PROGRESS": "Anuncio [AD_ON] de [NUM_ADS]",
   "AD_TIME": "Anuncio: [AD_TIME]",
+  "AIRPLAY": "AirPlay",
   "AUTO_QUALITY": "Automático",
   "BACK": "Atrás",
   "CAPTIONS": "Subtítulos",
@@ -26,6 +27,7 @@
   "PICTURE_IN_PICTURE": "Imagen en imagen",
   "PLAY": "Reproducir",
   "PLAYBACK_RATE": "Velocidad de reproducción",
+  "QUALITY": "Calidad",
   "RECENTER_VR": "Recentrar",
   "RESOLUTION": "Resolución",
   "REWIND": "Rebobinar",

package/ui/locales/fr.json

@@ -1,7 +1,9 @@
 {
   "AD_DURATION": "Durée de l'annonce",
-  "AD_PROGRESS": "Annonce [AD_ON] sur [NUM_ADS]",
-  "AD_TIME": "Annonce : [AD_TIME]",
+  "AD_PROGRESS": "Annonce [AD_ON] sur [NUM_ADS]",
+  "AD_STATISTICS": "Statistiques de la annonce",
+  "AD_TIME": "Annonce : [AD_TIME]",
+  "AIRPLAY": "AirPlay",
   "AUTO_QUALITY": "Automatique",
   "BACK": "Retour",
   "CAPTIONS": "Sous-titres",
@@ -10,7 +12,7 @@
   "ENTER_PICTURE_IN_PICTURE": "Utiliser le mode Picture-in-Picture",
   "EXIT_FULL_SCREEN": "Quitter le mode plein écran",
   "EXIT_LOOP_MODE": "Arrêter la lecture en boucle de la vidéo en cours",
-  "EXIT_PICTURE_IN_PICTURE": "Quitter le mode PIP (Picture-in-picture)",
+  "EXIT_PICTURE_IN_PICTURE": "Quitter le mode PIP (Picture-in-picture)",
   "FAST_FORWARD": "Avance rapide",
   "FULL_SCREEN": "Plein écran",
   "LANGUAGE": "Langue",
@@ -26,11 +28,18 @@
   "PICTURE_IN_PICTURE": "Picture-in-Picture",
   "PLAY": "Visionner",
   "PLAYBACK_RATE": "Vitesse de lecture",
+  "QUALITY": "Qualité",
+  "RECENTER_VR": "Recentrer",
+  "REPLAY": "Rejouer",
   "RESOLUTION": "Résolution",
   "REWIND": "Retour arrière",
   "SEEK": "Chercher",
   "SKIP_AD": "Passer l'annonce",
   "SKIP_TO_LIVE": "Accéder à la partie la plus récente du direct",
+  "STATISTICS": "Statistiques",
+  "SUBTITLE_FORCED": "Forcé",
+  "SURROUND": "Surround",
+  "TOGGLE_STEREOSCOPIC": "Stéréoscopique ON/OFF",
   "UNDETERMINED_LANGUAGE": "Langue indéterminée",
   "UNMUTE": "Réactiver le son",
   "UNRECOGNIZED_LANGUAGE": "Non reconnu",

package/ui/locales/pt-BR.json

@@ -1,7 +1,9 @@
 {
   "AD_DURATION": "Duração do anúncio",
   "AD_PROGRESS": "Anúncio [AD_ON] de [NUM_ADS]",
+  "AD_STATISTICS": "Estatísticas de anúncios",
   "AD_TIME": "Anúncio: [AD_TIME]",
+  "AIRPLAY": "AirPlay",
   "AUTO_QUALITY": "Automática",
   "BACK": "Voltar",
   "CAPTIONS": "Legendas",
@@ -26,11 +28,18 @@
   "PICTURE_IN_PICTURE": "Picture-in-picture",
   "PLAY": "Reproduzir",
   "PLAYBACK_RATE": "Velocidade da reprodução",
+  "QUALITY": "Qualidade",
+  "RECENTER_VR": "Recentralizar",
+  "REPLAY": "Replay",
   "RESOLUTION": "Resolução",
   "REWIND": "Retroceder",
   "SEEK": "Procurar",
   "SKIP_AD": "Pular anúncio",
   "SKIP_TO_LIVE": "Pular para transmissão ao vivo",
+  "STATISTICS": "Estatísticas",
+  "SUBTITLE_FORCED": "Forçado",
+  "SURROUND": "Surround",
+  "TOGGLE_STEREOSCOPIC": "Alternar estereoscópico",
   "UNDETERMINED_LANGUAGE": "Indeterminado",
   "UNMUTE": "Ativar som",
   "UNRECOGNIZED_LANGUAGE": "Não reconhecido",

package/ui/locales/pt-PT.json

@@ -1,7 +1,9 @@
 {
   "AD_DURATION": "Duração do anúncio",
   "AD_PROGRESS": "Anúncio [AD_ON] de [NUM_ADS]",
+  "AD_STATISTICS": "Estatísticas de anúncios",
   "AD_TIME": "Anúncio: [AD_TIME]",
+  "AIRPLAY": "AirPlay",
   "AUTO_QUALITY": "Automático",
   "BACK": "Anterior",
   "CAPTIONS": "Legendas",
@@ -26,11 +28,18 @@
   "PICTURE_IN_PICTURE": "Ecrã no ecrã",
   "PLAY": "Reproduzir",
   "PLAYBACK_RATE": "Velocidade de reprodução",
+  "QUALITY": "Qualidade",
+  "RECENTER_VR": "Recentrar",
+  "REPLAY": "Repetição",
   "RESOLUTION": "Resolução",
   "REWIND": "Rebobinar",
   "SEEK": "Procurar",
   "SKIP_AD": "Ignorar anúncio",
   "SKIP_TO_LIVE": "Avançar para o direto",
+  "STATISTICS": "Estatísticas",
+  "SUBTITLE_FORCED": "Forçado",
+  "SURROUND": "Envolvente",
+  "TOGGLE_STEREOSCOPIC": "Alternar estereoscópico",
   "UNDETERMINED_LANGUAGE": "Indeterminado",
   "UNMUTE": "Reativar o som",
   "UNRECOGNIZED_LANGUAGE": "Não reconhecido",