rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/parsers/manifest/dash/wasm-parser/rs/reportable.rs

@@ -1,4 +1,5 @@
 use core::mem;
+use std::borrow::Cow;
 use crate::events::AttributeName;
 use crate::processor::SegmentObject;
 use crate::onAttribute;
@@ -90,7 +91,27 @@ impl ReportableAttribute for &[SegmentObject] {
     }
 }
 
-impl<'a> ReportableAttribute for std::borrow::Cow<'a, [u8]> {
+// For key-value couples (such as XML namespaces)
+impl<'a> ReportableAttribute for (&'a [u8], Cow<'a, [u8]>) {
+    #[inline(always)]
+    fn report_as_attr(&self, attr_name: AttributeName) {
+        use crate::utils;
+        let len_key = self.0.len() as u32;
+        let len_val = self.1.len() as u32;
+
+        let mut msg = Vec::with_capacity((len_key + len_val + 8) as usize);
+        msg.extend(utils::u32_to_u8_slice_be(len_key));
+        msg.extend(self.0);
+        msg.extend(utils::u32_to_u8_slice_be(len_val));
+        msg.extend(self.1.to_vec());
+
+        // UNSAFE: We're using FFI, so we don't know how the pointer is used.
+        // Hopefully, the JavaScript-side should clone that value synchronously.
+        unsafe { onAttribute(attr_name, msg.as_ptr(), msg.len()); };
+    }
+}
+
+impl<'a> ReportableAttribute for Cow<'a, [u8]> {
     #[inline(always)]
     fn report_as_attr(&self, attr_name: AttributeName) {
         debug_assert!(attr_name as u64 <= u8::MAX as u64);

package/src/parsers/manifest/dash/wasm-parser/rs/utils.rs

@@ -60,6 +60,9 @@ pub fn parse_bool(value : &[u8]) -> Result<bool> {
     }
 }
 
+// TODO Is something like 5- also valid here?
+// It seems to be but it's not yet handled here
+// (We could use e.g. the `INFINITY` float value)
 pub fn parse_byte_range(value : &[u8]) -> Result<(f64, f64)> {
     let mut cursor = 0usize;
     let start;
@@ -85,7 +88,7 @@ pub fn parse_byte_range(value : &[u8]) -> Result<(f64, f64)> {
 /// to, mainly because I didn't want to incur the size cost of importing regex
 /// code in here
 pub fn parse_iso_8601_duration(value : &[u8]) -> Result<f64> {
-    if value[0] != b'P' {
+    if value.is_empty() || value[0] != b'P' {
         let err = ParsingError("Unexpected duration. Should start with \"P\"".to_owned());
         return Err(err);
     }
@@ -176,3 +179,39 @@ fn read_next_float(
     let val_f64 = val_str.parse::<f64>()?;
     Ok((val_f64, i))
 }
+
+pub fn u32_to_u8_slice_be(x:u32) -> [u8;4] {
+    let b1 : u8 = ((x >> 24) & 0xff) as u8;
+    let b2 : u8 = ((x >> 16) & 0xff) as u8;
+    let b3 : u8 = ((x >> 8) & 0xff) as u8;
+    let b4 : u8 = (x & 0xff) as u8;
+    return [b1, b2, b3, b4]
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_8601_duration() {
+        assert_eq!(parse_iso_8601_duration(b"P1Y10M43DT22H8M3S").unwrap(), 61250883.);
+        assert_eq!(parse_iso_8601_duration(b"P1Y10M43DT22H8M3S").unwrap(), 61250883.);
+        assert_eq!(parse_iso_8601_duration(b"PT3S").unwrap(), 3.);
+        assert_eq!(parse_iso_8601_duration(b"PT1M3.4S").unwrap(), 63.4);
+
+        assert!(parse_iso_8601_duration(b"").err().is_some());
+        assert!(parse_iso_8601_duration(b"3S").err().is_some());
+        assert!(parse_iso_8601_duration(b"T3S").err().is_some());
+        assert!(parse_iso_8601_duration(b"P3S").err().is_some());
+    }
+
+    #[test]
+    fn test_parse_byte_range() {
+        assert_eq!(parse_byte_range(b"1-2").unwrap(), (1., 2.));
+        assert_eq!(parse_byte_range(b"100-200").unwrap(), (100., 200.));
+
+        assert!(parse_byte_range(b"").err().is_some());
+        assert!(parse_byte_range(b"A").err().is_some());
+        assert!(parse_byte_range(b"15-A").err().is_some());
+    }
+}

package/src/parsers/manifest/dash/wasm-parser/ts/dash-wasm-parser.ts

@@ -14,10 +14,10 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import log from "../../../../../log";
 import assertUnreachable from "../../../../../utils/assert_unreachable";
 import noop from "../../../../../utils/noop";
+import PPromise from "../../../../../utils/promise";
 import parseMpdIr, {
   IIrParserResponse,
   ILoadedXlinkData,
@@ -162,7 +162,7 @@ export default class DashWasmParser {
         memoryBase: 0,
         tableBase: 0,
         memory: new WebAssembly.Memory({ initial: 10 }),
-        table: new WebAssembly.Table({ initial: 2, element: "anyfunc" }),
+        table: new WebAssembly.Table({ initial: 1, element: "anyfunc" }),
         onTagOpen,
         onCustomEvent,
         onAttribute,
@@ -191,11 +191,7 @@ export default class DashWasmParser {
         this._instance = instanceWasm;
 
         // TODO better types?
-        /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-        /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-        this._linearMemory = (this._instance.instance.exports as any).memory;
-        /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-        /* eslint-enable @typescript-eslint/no-unsafe-assignment */
+        this._linearMemory = this._instance.instance.exports.memory as WebAssembly.Memory;
 
         this.status = "initialized";
       }).catch((err : Error) => {
@@ -350,11 +346,7 @@ export default class DashWasmParser {
 
     try {
       // TODO better type this
-      /* eslint-disable @typescript-eslint/no-unsafe-call */
-      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-      (this._instance.instance.exports as any).parse();
-      /* eslint-enable @typescript-eslint/no-unsafe-call */
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+      (this._instance.instance.exports.parse as () => void)();
     } catch (err) {
       this._parsersStack.reset();
       this._warnings = [];
@@ -399,11 +391,7 @@ export default class DashWasmParser {
 
     try {
       // TODO better type this
-      /* eslint-disable @typescript-eslint/no-unsafe-call */
-      /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-      (this._instance.instance.exports as any).parse_xlink();
-      /* eslint-enable @typescript-eslint/no-unsafe-call */
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+      (this._instance.instance.exports.parse as () => void)();
     } catch (err) {
       this._parsersStack.reset();
       this._warnings = [];
@@ -453,12 +441,15 @@ export default class DashWasmParser {
       ) : IDashParserResponse<string> | IDashParserResponse<ArrayBuffer> => {
         const resourceInfos : ILoadedXlinkData[] = [];
         for (let i = 0; i < loadedXlinks.length; i++) {
-          const { responseData: xlinkData,
+          const { responseData: xlinkResp,
                   receivedTime,
                   sendingTime,
                   url } = loadedXlinks[i];
+          if (!xlinkResp.success) {
+            throw xlinkResp.error;
+          }
           const [periodsIr,
-                 periodsIRWarnings] = this._parseXlink(xlinkData);
+                 periodsIRWarnings] = this._parseXlink(xlinkResp.data);
           resourceInfos.push({ url,
                                receivedTime,
                                sendingTime,

package/src/parsers/manifest/dash/wasm-parser/ts/generators/AdaptationSet.ts

@@ -200,6 +200,13 @@ export function generateAdaptationSetChildrenParser(
                                  generateSegmentTemplateAttrParser(stObj, linearMemory));
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
+
     }
   };
 }
@@ -313,6 +320,12 @@ export function generateAdaptationSetAttrParser(
       case AttributeName.MaxSAPPeriod:
         adaptationAttrs.maximumSAPPeriod = dataView.getFloat64(ptr, true);
         break;
+      case AttributeName.AvailabilityTimeOffset:
+        adaptationAttrs.availabilityTimeOffset = dataView.getFloat64(ptr, true);
+        break;
+      case AttributeName.AvailabilityTimeComplete:
+        adaptationAttrs.availabilityTimeComplete = dataView.getUint8(0) === 0;
+        break;
 
       // TODO
       // case AttributeName.StartsWithSap:

package/src/parsers/manifest/dash/wasm-parser/ts/generators/BaseURL.ts

@@ -37,10 +37,17 @@ export function generateBaseUrlAttrParser(
         baseUrlAttrs.value = parseString(textDecoder, linearMemory.buffer, ptr, len);
         break;
 
-      case AttributeName.AvailabilityTimeOffset:
+      case AttributeName.AvailabilityTimeOffset: {
         dataView = new DataView(linearMemory.buffer);
         baseUrlAttrs.attributes.availabilityTimeOffset = dataView.getFloat64(ptr, true);
         break;
+      }
+
+      case AttributeName.AvailabilityTimeComplete: {
+        baseUrlAttrs.attributes.availabilityTimeComplete =
+          new DataView(linearMemory.buffer).getUint8(0) === 0;
+        break;
+      }
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/EventStream.ts

@@ -53,6 +53,12 @@ export function generateEventStreamChildrenParser(
         parsersStack.pushParsers(nodeId, noop, attrParser);
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }
@@ -81,6 +87,25 @@ export function generateEventStreamAttrParser(
       case AttributeName.TimeScale:
         esAttrs.timescale = dataView.getFloat64(ptr, true);
         break;
+      case AttributeName.Namespace:
+        const xmlNs = { key: "", value: "" };
+        let offset = ptr;
+        const keySize = dataView.getUint32(offset);
+        offset += 4;
+
+        xmlNs.key = parseString(textDecoder, linearMemory.buffer, offset, keySize);
+        offset += keySize;
+
+        const valSize = dataView.getUint32(offset);
+        offset += 4;
+        xmlNs.value = parseString(textDecoder, linearMemory.buffer, offset, valSize);
+
+        if (esAttrs.namespaces === undefined) {
+          esAttrs.namespaces = [xmlNs];
+        } else {
+          esAttrs.namespaces.push(xmlNs);
+        }
+        break;
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/MPD.ts

@@ -86,6 +86,12 @@ export function generateMPDChildrenParser(
         parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }
@@ -152,6 +158,26 @@ export function generateMPDAttrParser(
         const location = parseString(textDecoder, linearMemory.buffer, ptr, len);
         mpdChildren.locations.push(location);
         break;
+      case AttributeName.Namespace:
+        const xmlNs = { key: "", value: "" };
+        dataView = new DataView(linearMemory.buffer);
+        let offset = ptr;
+        const keySize = dataView.getUint32(offset);
+        offset += 4;
+
+        xmlNs.key = parseString(textDecoder, linearMemory.buffer, offset, keySize);
+        offset += keySize;
+
+        const valSize = dataView.getUint32(offset);
+        offset += 4;
+        xmlNs.value = parseString(textDecoder, linearMemory.buffer, offset, valSize);
+
+        if (mpdAttrs.namespaces === undefined) {
+          mpdAttrs.namespaces = [xmlNs];
+        } else {
+          mpdAttrs.namespaces.push(xmlNs);
+        }
+        break;
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/Period.ts

@@ -103,6 +103,12 @@ export function generatePeriodChildrenParser(
                                  generateSegmentTemplateAttrParser(stObj, linearMemory));
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }
@@ -141,6 +147,34 @@ export function generatePeriodAttrParser(
                                                ptr,
                                                len);
         break;
+      case AttributeName.AvailabilityTimeOffset:
+        periodAttrs.availabilityTimeOffset =
+          new DataView(linearMemory.buffer).getFloat64(ptr, true);
+        break;
+      case AttributeName.AvailabilityTimeComplete:
+        periodAttrs.availabilityTimeComplete =
+          new DataView(linearMemory.buffer).getUint8(0) === 0;
+        break;
+      case AttributeName.Namespace:
+        const xmlNs = { key: "", value: "" };
+        const dataView = new DataView(linearMemory.buffer);
+        let offset = ptr;
+        const keySize = dataView.getUint32(offset);
+        offset += 4;
+
+        xmlNs.key = parseString(textDecoder, linearMemory.buffer, offset, keySize);
+        offset += keySize;
+
+        const valSize = dataView.getUint32(offset);
+        offset += 4;
+        xmlNs.value = parseString(textDecoder, linearMemory.buffer, offset, valSize);
+
+        if (periodAttrs.namespaces === undefined) {
+          periodAttrs.namespaces = [xmlNs];
+        } else {
+          periodAttrs.namespaces.push(xmlNs);
+        }
+        break;
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/Representation.ts

@@ -30,6 +30,7 @@ import {
 } from "../types";
 import { parseString } from "../utils";
 import { generateBaseUrlAttrParser } from "./BaseURL";
+import { generateContentProtectionAttrParser } from "./ContentProtection";
 import { generateSchemeAttrParser } from "./Scheme";
 import { generateSegmentBaseAttrParser } from "./SegmentBase";
 import { generateSegmentListChildrenParser } from "./SegmentList";
@@ -59,6 +60,19 @@ export function generateRepresentationChildrenParser(
         break;
       }
 
+      case TagName.ContentProtection: {
+        const contentProtection = { children: { cencPssh: [] },
+                                    attributes: {} };
+        if (childrenObj.contentProtections === undefined) {
+          childrenObj.contentProtections = [];
+        }
+        childrenObj.contentProtections.push(contentProtection);
+        const contentProtAttrParser =
+          generateContentProtectionAttrParser(contentProtection, linearMemory);
+        parsersStack.pushParsers(nodeId, noop, contentProtAttrParser);
+        break;
+      }
+
       case TagName.InbandEventStream: {
         const inbandEvent = {};
         if (childrenObj.inbandEventStreams === undefined) {
@@ -102,6 +116,12 @@ export function generateRepresentationChildrenParser(
                                  generateSegmentTemplateAttrParser(stObj, linearMemory));
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }
@@ -168,6 +188,12 @@ export function generateRepresentationAttrParser(
         representationAttrs.segmentProfiles =
           parseString(textDecoder, linearMemory.buffer, ptr, len);
         break;
+      case AttributeName.AvailabilityTimeOffset:
+        representationAttrs.availabilityTimeOffset = dataView.getFloat64(ptr, true);
+        break;
+      case AttributeName.AvailabilityTimeComplete:
+        representationAttrs.availabilityTimeComplete = dataView.getUint8(0) === 0;
+        break;
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/SegmentList.ts

@@ -50,6 +50,12 @@ export function generateSegmentListChildrenParser(
         parsersStack.pushParsers(nodeId, noop, attrParser);
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/XLink.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import noop from "../../../../../../utils/noop";
 import { IPeriodIntermediateRepresentation } from "../../../node_parser_types";
 import ParsersStack, {
   IChildrenParser,
@@ -54,6 +55,12 @@ export function generateXLinkChildrenParser(
         parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
         break;
       }
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/generators/root.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import noop from "../../../../../../utils/noop";
 import {
   IMPDIntermediateRepresentation,
 } from "../../../node_parser_types";
@@ -54,6 +55,12 @@ export function generateRootChildrenParser(
                                                       linearMemory);
         parsersStack.pushParsers(nodeId, childrenParser, attributeParser);
         break;
+
+      default:
+        // Allows to make sure we're not mistakenly closing a re-opened
+        // tag.
+        parsersStack.pushParsers(nodeId, noop, noop);
+        break;
     }
   };
 }

package/src/parsers/manifest/dash/wasm-parser/ts/parsers_stack.ts

@@ -70,7 +70,6 @@ export default class ParsersStack {
     this._currentNodeId = nodeId;
     this.attributeParser = attribute;
     this.childrenParser = children;
-    return ;
   }
 
   public reset() : void {

package/src/parsers/manifest/dash/wasm-parser/ts/types.ts

@@ -196,7 +196,7 @@ export const enum AttributeName {
   MaxSegmentDuration = 41, // f64
   MaxSubsegmentDuration = 42, // f64
 
-  // BaseURL + SegmentTemplate
+  // BaseURL + SegmentTemplate + Period + AdaptationSet + Representation
   AvailabilityTimeOffset = 43, // f64
 
   // BaseURL
@@ -250,4 +250,34 @@ export const enum AttributeName {
   /// The first number indicating the starting range (included).
   /// The second indicating the ending range (non-included).
   EventStreamEltRange = 69,
+
+  /// Describes an XML namespace coming from either a `<MPD>` element, a
+  /// `<Period> element or a `<EventStream>` elements, as those are the three
+  /// parent tags of potential `<Event>` elements.
+  ///
+  /// It is reported as the concatenation of four values:
+  ///
+  ///   - In the four first bytes: The length of the namespace's name (the
+  ///     part in the XML attribute just after "xmlns:"), as a big endian
+  ///     unsigned 32 bit integer
+  ///
+  ///   - The namespace's name (the part coming after "xmlns:" in the
+  ///     attribute's name), as an UTF-8 encoded string.
+  ///     The length of this attribute is indicated by the preceding four
+  ///     bytes.
+  ///
+  ///   - As the next four bytes: The length of the namespace's value (the
+  ///     corresponding XML attribute's value), as a big endian
+  ///     unsigned 32 bit integer
+  ///
+  ///   - The namespace's value (the value of the corresponding XML
+  ///     attribute), as an UTF-8 encoded string.
+  ///     The length of this attribute is indicated by the preceding four
+  ///     bytes.
+  ///
+  /// This special Attribute was needed because we need those namespaces to be
+  /// able to communicate `<Event>` property under a JavaScript's Element
+  /// format: the browser's `DOMParser` API needs to know all potential
+  /// namespaces that will appear in it.
+  Namespace = 70,
 }

package/src/parsers/manifest/local/representation_index.ts

@@ -46,6 +46,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
       duration: 0,
       timescale: 1,
       mediaURLs: null,
+      complete: true,
       privateInfos: {
         localManifestInitSegment: { load: this._index.loadInitSegment } },
     };
@@ -83,6 +84,7 @@ export default class LocalRepresentationIndex implements IRepresentationIndex {
           timescale: 1,
           timestampOffset: wantedSegment.timestampOffset,
           mediaURLs: null,
+          complete: true,
           privateInfos: {
             localManifestSegment: { load: this._index.loadSegment,
                                     segment: wantedSegment },

package/src/parsers/manifest/metaplaylist/metaplaylist_parser.ts

@@ -25,6 +25,7 @@ import {
   IParsedAdaptations,
   IParsedManifest,
   IParsedPeriod,
+  IParsedRepresentation,
 } from "../types";
 import MetaRepresentationIndex from "./representation_index";
 
@@ -68,11 +69,11 @@ export interface IMetaPlaylist {
 export default function parseMetaPlaylist(
   data : unknown,
   parserOptions : {
-    url?: string;
+    url?: string | undefined;
     serverSyncInfos?: {
       serverTimestamp: number;
       clientTime: number;
-    };
+    } | undefined;
   }
 ): IParserResponse<IParsedManifest> {
   let parsedData;
@@ -146,9 +147,9 @@ export default function parseMetaPlaylist(
 function createManifest(
   mplData : IMetaPlaylist,
   manifests : Manifest[],
-  parserOptions:  { url?: string;
+  parserOptions:  { url?: string | undefined;
                     serverSyncInfos?: { serverTimestamp: number;
-                                        clientTime: number; }; }
+                                        clientTime: number; } | undefined; }
 ): IParsedManifest {
   const { url, serverSyncInfos } = parserOptions;
   const clockOffset = serverSyncInfos !== undefined ?
@@ -194,7 +195,7 @@ function createManifest(
           for (let iAda = 0; iAda < currentAdaptations.length; iAda++) {
             const currentAdaptation = currentAdaptations[iAda];
 
-            const representations : any[] = [];
+            const representations : IParsedRepresentation[] = [];
             for (let iRep = 0; iRep < currentAdaptation.representations.length; iRep++) {
               const currentRepresentation = currentAdaptation.representations[iRep];
 

package/src/parsers/manifest/smooth/create_parser.ts

@@ -64,8 +64,8 @@ interface IAdaptationParserArguments { root : Element;
                                        timescale : number;
                                        protections : IContentProtectionSmooth[];
                                        isLive : boolean;
-                                       timeShiftBufferDepth? : number;
-                                       manifestReceivedTime? : number; }
+                                       timeShiftBufferDepth? : number | undefined;
+                                       manifestReceivedTime? : number | undefined; }
 
 type IAdaptationType = "audio" |
                        "video" |
@@ -86,15 +86,15 @@ const MIME_TYPES : Partial<Record<string, string>> = {
 };
 
 export interface IHSSParserConfiguration {
-  aggressiveMode? : boolean;
-  suggestedPresentationDelay? : number;
-  referenceDateTime? : number;
-  minRepresentationBitrate? : number;
-  keySystems? : (hex? : Uint8Array) => IKeySystem[];
+  aggressiveMode? : boolean | undefined;
+  suggestedPresentationDelay? : number | undefined;
+  referenceDateTime? : number | undefined;
+  minRepresentationBitrate? : number | undefined;
+  keySystems? : ((hex : Uint8Array | undefined) => IKeySystem[]) | undefined;
   serverSyncInfos? : {
     serverTimestamp: number;
     clientTime: number;
-  };
+  } | undefined;
 }
 
 interface ISmoothParsedQualityLevel {
@@ -104,16 +104,16 @@ interface ISmoothParsedQualityLevel {
   customAttributes : string[];
 
   // optional
-  audiotag? : number;
-  bitsPerSample? : number;
-  channels? : number;
-  codecs? : string;
-  height? : number;
-  id? : string;
-  mimeType? : string;
-  packetSize? : number;
-  samplingRate? : number;
-  width? : number;
+  audiotag? : number | undefined;
+  bitsPerSample? : number | undefined;
+  channels? : number | undefined;
+  codecs? : string | undefined;
+  height? : number | undefined;
+  id? : string | undefined;
+  mimeType? : string | undefined;
+  packetSize? : number | undefined;
+  samplingRate? : number | undefined;
+  width? : number | undefined;
 }
 
 /**
@@ -122,9 +122,11 @@ interface ISmoothParsedQualityLevel {
  */
 function createSmoothStreamingParser(
   parserOptions : IHSSParserConfiguration = {}
-) : (manifest : Document, url? : string, manifestReceivedTime? : number)
-  => IParsedManifest
-{
+) : (
+    manifest : Document,
+    url? : string | undefined,
+    manifestReceivedTime? : number | undefined
+  ) => IParsedManifest {
   const referenceDateTime = parserOptions.referenceDateTime === undefined ?
     Date.UTC(1970, 0, 1, 0, 0, 0, 0) / 1000 :
     parserOptions.referenceDateTime;
@@ -301,7 +303,7 @@ function createSmoothStreamingParser(
     const baseURLAttr = root.getAttribute("Url");
     const baseURL = baseURLAttr === null ? "" :
                                            baseURLAttr;
-    if (__DEV__) {
+    if (__ENVIRONMENT__.CURRENT_ENV === __ENVIRONMENT__.DEV as number) {
       assert(baseURL !== "");
     }