@vonage/media-processor 1.0.1 → 1.1.3

package/dist/media-processor.es.js

@@ -1209,7 +1209,7 @@ class EmptyOptional extends Optional {
     return null;
   }
 }
-const version = "1.0.1";
+const version = "1.1.3";
 let _metadata;
 function setMetadata(metadata) {
   _metadata = metadata;
@@ -1222,20 +1222,21 @@ class ReportBuilder {
     const metadata = getMetadata();
     this._report = {
       action: Optional.empty(),
-      applicationId: Optional.ofNullable(metadata !== void 0 ? metadata.appId : null),
+      applicationId: Optional.ofNullable(metadata !== void 0 && metadata != null ? metadata.appId : null),
       timestamp: Date.now(),
       fps: Optional.empty(),
       framesTransformed: Optional.empty(),
       guid: Optional.empty(),
       highestFrameTransformCpu: Optional.empty(),
       message: Optional.empty(),
-      source: Optional.ofNullable(metadata !== void 0 ? metadata.sourceType : null),
+      source: Optional.ofNullable(metadata !== void 0 && metadata != null ? metadata.sourceType : null),
       transformedFps: Optional.empty(),
       transformerType: Optional.empty(),
       variation: Optional.empty(),
       videoHeight: Optional.empty(),
       videoWidth: Optional.empty(),
-      version
+      version,
+      error: Optional.empty()
     };
   }
   action(action) {
@@ -1278,6 +1279,10 @@ class ReportBuilder {
     this._report.videoWidth = Optional.ofNullable(videoWidth);
     return this;
   }
+  error(error) {
+    this._report.error = Optional.ofNullable(error);
+    return this;
+  }
   build() {
     return this._report;
   }
@@ -1291,6 +1296,10 @@ const serializeReport = (report) => {
 class Reporter {
   static report(report) {
     return new Promise((resolve, reject) => {
+      if (report.applicationId.isEmpty() || report.source.isEmpty()) {
+        resolve("success");
+        return;
+      }
       let axiosInstance = axios.create();
       let config = {
         timeout: 1e4,
@@ -1351,9 +1360,392 @@ function v4(options, buf, offset) {
   }
   return stringify(rnds);
 }
+const anyMap = new WeakMap();
+const eventsMap = new WeakMap();
+const producersMap = new WeakMap();
+const anyProducer = Symbol("anyProducer");
+const resolvedPromise = Promise.resolve();
+const listenerAdded = Symbol("listenerAdded");
+const listenerRemoved = Symbol("listenerRemoved");
+let isGlobalDebugEnabled = false;
+function assertEventName(eventName) {
+  if (typeof eventName !== "string" && typeof eventName !== "symbol") {
+    throw new TypeError("eventName must be a string or a symbol");
+  }
+}
+function assertListener(listener) {
+  if (typeof listener !== "function") {
+    throw new TypeError("listener must be a function");
+  }
+}
+function getListeners(instance, eventName) {
+  const events = eventsMap.get(instance);
+  if (!events.has(eventName)) {
+    events.set(eventName, new Set());
+  }
+  return events.get(eventName);
+}
+function getEventProducers(instance, eventName) {
+  const key = typeof eventName === "string" || typeof eventName === "symbol" ? eventName : anyProducer;
+  const producers = producersMap.get(instance);
+  if (!producers.has(key)) {
+    producers.set(key, new Set());
+  }
+  return producers.get(key);
+}
+function enqueueProducers(instance, eventName, eventData) {
+  const producers = producersMap.get(instance);
+  if (producers.has(eventName)) {
+    for (const producer of producers.get(eventName)) {
+      producer.enqueue(eventData);
+    }
+  }
+  if (producers.has(anyProducer)) {
+    const item = Promise.all([eventName, eventData]);
+    for (const producer of producers.get(anyProducer)) {
+      producer.enqueue(item);
+    }
+  }
+}
+function iterator(instance, eventNames) {
+  eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+  let isFinished = false;
+  let flush = () => {
+  };
+  let queue = [];
+  const producer = {
+    enqueue(item) {
+      queue.push(item);
+      flush();
+    },
+    finish() {
+      isFinished = true;
+      flush();
+    }
+  };
+  for (const eventName of eventNames) {
+    getEventProducers(instance, eventName).add(producer);
+  }
+  return {
+    async next() {
+      if (!queue) {
+        return { done: true };
+      }
+      if (queue.length === 0) {
+        if (isFinished) {
+          queue = void 0;
+          return this.next();
+        }
+        await new Promise((resolve) => {
+          flush = resolve;
+        });
+        return this.next();
+      }
+      return {
+        done: false,
+        value: await queue.shift()
+      };
+    },
+    async return(value) {
+      queue = void 0;
+      for (const eventName of eventNames) {
+        getEventProducers(instance, eventName).delete(producer);
+      }
+      flush();
+      return arguments.length > 0 ? { done: true, value: await value } : { done: true };
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+}
+function defaultMethodNamesOrAssert(methodNames) {
+  if (methodNames === void 0) {
+    return allEmitteryMethods;
+  }
+  if (!Array.isArray(methodNames)) {
+    throw new TypeError("`methodNames` must be an array of strings");
+  }
+  for (const methodName of methodNames) {
+    if (!allEmitteryMethods.includes(methodName)) {
+      if (typeof methodName !== "string") {
+        throw new TypeError("`methodNames` element must be a string");
+      }
+      throw new Error(`${methodName} is not Emittery method`);
+    }
+  }
+  return methodNames;
+}
+const isListenerSymbol = (symbol) => symbol === listenerAdded || symbol === listenerRemoved;
+class Emittery {
+  static mixin(emitteryPropertyName, methodNames) {
+    methodNames = defaultMethodNamesOrAssert(methodNames);
+    return (target) => {
+      if (typeof target !== "function") {
+        throw new TypeError("`target` must be function");
+      }
+      for (const methodName of methodNames) {
+        if (target.prototype[methodName] !== void 0) {
+          throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+        }
+      }
+      function getEmitteryProperty() {
+        Object.defineProperty(this, emitteryPropertyName, {
+          enumerable: false,
+          value: new Emittery()
+        });
+        return this[emitteryPropertyName];
+      }
+      Object.defineProperty(target.prototype, emitteryPropertyName, {
+        enumerable: false,
+        get: getEmitteryProperty
+      });
+      const emitteryMethodCaller = (methodName) => function(...args) {
+        return this[emitteryPropertyName][methodName](...args);
+      };
+      for (const methodName of methodNames) {
+        Object.defineProperty(target.prototype, methodName, {
+          enumerable: false,
+          value: emitteryMethodCaller(methodName)
+        });
+      }
+      return target;
+    };
+  }
+  static get isDebugEnabled() {
+    if (typeof process !== "object") {
+      return isGlobalDebugEnabled;
+    }
+    const { env } = process || { env: {} };
+    return env.DEBUG === "emittery" || env.DEBUG === "*" || isGlobalDebugEnabled;
+  }
+  static set isDebugEnabled(newValue) {
+    isGlobalDebugEnabled = newValue;
+  }
+  constructor(options = {}) {
+    anyMap.set(this, new Set());
+    eventsMap.set(this, new Map());
+    producersMap.set(this, new Map());
+    this.debug = options.debug || {};
+    if (this.debug.enabled === void 0) {
+      this.debug.enabled = false;
+    }
+    if (!this.debug.logger) {
+      this.debug.logger = (type, debugName, eventName, eventData) => {
+        eventData = JSON.stringify(eventData);
+        if (typeof eventName === "symbol") {
+          eventName = eventName.toString();
+        }
+        const currentTime = new Date();
+        const logTime = `${currentTime.getHours()}:${currentTime.getMinutes()}:${currentTime.getSeconds()}.${currentTime.getMilliseconds()}`;
+        console.log(`[${logTime}][emittery:${type}][${debugName}] Event Name: ${eventName}
+	data: ${eventData}`);
+      };
+    }
+  }
+  logIfDebugEnabled(type, eventName, eventData) {
+    if (Emittery.isDebugEnabled || this.debug.enabled) {
+      this.debug.logger(type, this.debug.name, eventName, eventData);
+    }
+  }
+  on(eventNames, listener) {
+    assertListener(listener);
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNames) {
+      assertEventName(eventName);
+      getListeners(this, eventName).add(listener);
+      this.logIfDebugEnabled("subscribe", eventName, void 0);
+      if (!isListenerSymbol(eventName)) {
+        this.emit(listenerAdded, { eventName, listener });
+      }
+    }
+    return this.off.bind(this, eventNames, listener);
+  }
+  off(eventNames, listener) {
+    assertListener(listener);
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNames) {
+      assertEventName(eventName);
+      getListeners(this, eventName).delete(listener);
+      this.logIfDebugEnabled("unsubscribe", eventName, void 0);
+      if (!isListenerSymbol(eventName)) {
+        this.emit(listenerRemoved, { eventName, listener });
+      }
+    }
+  }
+  once(eventNames) {
+    return new Promise((resolve) => {
+      const off = this.on(eventNames, (data2) => {
+        off();
+        resolve(data2);
+      });
+    });
+  }
+  events(eventNames) {
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNames) {
+      assertEventName(eventName);
+    }
+    return iterator(this, eventNames);
+  }
+  async emit(eventName, eventData) {
+    assertEventName(eventName);
+    this.logIfDebugEnabled("emit", eventName, eventData);
+    enqueueProducers(this, eventName, eventData);
+    const listeners = getListeners(this, eventName);
+    const anyListeners = anyMap.get(this);
+    const staticListeners = [...listeners];
+    const staticAnyListeners = isListenerSymbol(eventName) ? [] : [...anyListeners];
+    await resolvedPromise;
+    await Promise.all([
+      ...staticListeners.map(async (listener) => {
+        if (listeners.has(listener)) {
+          return listener(eventData);
+        }
+      }),
+      ...staticAnyListeners.map(async (listener) => {
+        if (anyListeners.has(listener)) {
+          return listener(eventName, eventData);
+        }
+      })
+    ]);
+  }
+  async emitSerial(eventName, eventData) {
+    assertEventName(eventName);
+    this.logIfDebugEnabled("emitSerial", eventName, eventData);
+    const listeners = getListeners(this, eventName);
+    const anyListeners = anyMap.get(this);
+    const staticListeners = [...listeners];
+    const staticAnyListeners = [...anyListeners];
+    await resolvedPromise;
+    for (const listener of staticListeners) {
+      if (listeners.has(listener)) {
+        await listener(eventData);
+      }
+    }
+    for (const listener of staticAnyListeners) {
+      if (anyListeners.has(listener)) {
+        await listener(eventName, eventData);
+      }
+    }
+  }
+  onAny(listener) {
+    assertListener(listener);
+    this.logIfDebugEnabled("subscribeAny", void 0, void 0);
+    anyMap.get(this).add(listener);
+    this.emit(listenerAdded, { listener });
+    return this.offAny.bind(this, listener);
+  }
+  anyEvent() {
+    return iterator(this);
+  }
+  offAny(listener) {
+    assertListener(listener);
+    this.logIfDebugEnabled("unsubscribeAny", void 0, void 0);
+    this.emit(listenerRemoved, { listener });
+    anyMap.get(this).delete(listener);
+  }
+  clearListeners(eventNames) {
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    for (const eventName of eventNames) {
+      this.logIfDebugEnabled("clear", eventName, void 0);
+      if (typeof eventName === "string" || typeof eventName === "symbol") {
+        getListeners(this, eventName).clear();
+        const producers = getEventProducers(this, eventName);
+        for (const producer of producers) {
+          producer.finish();
+        }
+        producers.clear();
+      } else {
+        anyMap.get(this).clear();
+        for (const listeners of eventsMap.get(this).values()) {
+          listeners.clear();
+        }
+        for (const producers of producersMap.get(this).values()) {
+          for (const producer of producers) {
+            producer.finish();
+          }
+          producers.clear();
+        }
+      }
+    }
+  }
+  listenerCount(eventNames) {
+    eventNames = Array.isArray(eventNames) ? eventNames : [eventNames];
+    let count = 0;
+    for (const eventName of eventNames) {
+      if (typeof eventName === "string") {
+        count += anyMap.get(this).size + getListeners(this, eventName).size + getEventProducers(this, eventName).size + getEventProducers(this).size;
+        continue;
+      }
+      if (typeof eventName !== "undefined") {
+        assertEventName(eventName);
+      }
+      count += anyMap.get(this).size;
+      for (const value of eventsMap.get(this).values()) {
+        count += value.size;
+      }
+      for (const value of producersMap.get(this).values()) {
+        count += value.size;
+      }
+    }
+    return count;
+  }
+  bindMethods(target, methodNames) {
+    if (typeof target !== "object" || target === null) {
+      throw new TypeError("`target` must be an object");
+    }
+    methodNames = defaultMethodNamesOrAssert(methodNames);
+    for (const methodName of methodNames) {
+      if (target[methodName] !== void 0) {
+        throw new Error(`The property \`${methodName}\` already exists on \`target\``);
+      }
+      Object.defineProperty(target, methodName, {
+        enumerable: false,
+        value: this[methodName].bind(this)
+      });
+    }
+  }
+}
+const allEmitteryMethods = Object.getOwnPropertyNames(Emittery.prototype).filter((v) => v !== "constructor");
+Object.defineProperty(Emittery, "listenerAdded", {
+  value: listenerAdded,
+  writable: false,
+  enumerable: true,
+  configurable: false
+});
+Object.defineProperty(Emittery, "listenerRemoved", {
+  value: listenerRemoved,
+  writable: false,
+  enumerable: true,
+  configurable: false
+});
+var emittery = Emittery;
+function isErrorWithMessage(error) {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+}
+function toErrorWithMessage(maybeError) {
+  if (isErrorWithMessage(maybeError))
+    return maybeError;
+  try {
+    return new Error(JSON.stringify(maybeError));
+  } catch {
+    return new Error(String(maybeError));
+  }
+}
+function getErrorMessage(error) {
+  return toErrorWithMessage(error).message;
+}
+var WarningType;
+(function(WarningType2) {
+  WarningType2["FPS_DROP"] = "fps_drop";
+})(WarningType || (WarningType = {}));
 const TELEMETRY_MEDIA_TRANSFORMER_QOS_REPORT_INTERVAL = 500;
-class InternalTransformer {
-  constructor(transformer) {
+const RATE_DROP_TO_PRECENT = 0.8;
+class InternalTransformer extends emittery {
+  constructor(transformer, index) {
+    super();
+    this.index_ = index;
     this.uuid_ = v4();
     this.framesTransformed_ = 0;
     this.transformer_ = transformer;
@@ -1364,6 +1756,7 @@ class InternalTransformer {
     this.mediaTransformerQosReportStartTimestamp_ = 0;
     this.videoHeight_ = 0;
     this.videoWidth_ = 0;
+    this.trackExpectedRate_ = -1;
     this.transformerType_ = "Custom";
     if ("getTransformerType" in transformer) {
       this.transformerType_ = transformer.getTransformerType();
@@ -1371,13 +1764,18 @@ class InternalTransformer {
     const report = new ReportBuilder().action("MediaTransformer").guid(this.uuid_).transformerType(this.transformerType_).variation("Create").build();
     Reporter.report(report);
   }
+  setTrackExpectedRate(trackExpectedRate) {
+    this.trackExpectedRate_ = trackExpectedRate;
+  }
   async start(controller) {
     if (this.transformer_ && typeof this.transformer_.start === "function") {
       try {
         await this.transformer_.start(controller);
       } catch (e) {
-        const report = new ReportBuilder().action("MediaTransformer").guid(this.uuid_).message(Key.errors["transformer_start"]).transformerType(this.transformerType_).variation("Error").build();
+        const report = new ReportBuilder().action("MediaTransformer").guid(this.uuid_).message(Key.errors["transformer_start"]).transformerType(this.transformerType_).variation("Error").error(getErrorMessage(e)).build();
         Reporter.report(report);
+        const msg = { eventMetaData: { transformerIndex: this.index_ }, error: e, function: "start" };
+        this.emit("error", msg);
       }
     }
   }
@@ -1398,8 +1796,10 @@ class InternalTransformer {
             this.mediaTransformerQosReport();
           }
         } catch (e) {
-          const report = new ReportBuilder().action("MediaTransformer").guid(this.uuid_).message(Key.errors["transformer_transform"]).transformerType(this.transformerType_).variation("Error").build();
+          const report = new ReportBuilder().action("MediaTransformer").guid(this.uuid_).message(Key.errors["transformer_transform"]).transformerType(this.transformerType_).variation("Error").error(getErrorMessage(e)).build();
           Reporter.report(report);
+          const msg = { eventMetaData: { transformerIndex: this.index_ }, error: e, function: "transform" };
+          this.emit("error", msg);
         }
       } else {
         frame.close();
@@ -1414,8 +1814,10 @@ class InternalTransformer {
       try {
         await this.transformer_.flush(controller);
       } catch (e) {
-        const error = new ReportBuilder().action("MediaTransformer").guid(this.uuid_).message(Key.errors["transformer_transform"]).transformerType(this.transformerType_).variation("Error").build();
+        const error = new ReportBuilder().action("MediaTransformer").guid(this.uuid_).message(Key.errors["transformer_flush"]).transformerType(this.transformerType_).variation("Error").error(getErrorMessage(e)).build();
         Reporter.report(error);
+        const msg = { eventMetaData: { transformerIndex: this.index_ }, error: e, function: "flush" };
+        this.emit("error", msg);
       }
     }
     this.mediaTransformerQosReport();
@@ -1430,6 +1832,10 @@ class InternalTransformer {
     let timeElapsed_s = (Date.now() - this.mediaTransformerQosReportStartTimestamp_) / 1e3;
     let fps = this.framesFromSource_ / timeElapsed_s;
     let transformedFps = this.framesTransformed_ / timeElapsed_s;
+    if (this.trackExpectedRate_ != -1 && this.trackExpectedRate_ * RATE_DROP_TO_PRECENT > fps) {
+      const msg = { eventMetaData: { transformerIndex: this.index_ }, warningType: WarningType.FPS_DROP, dropInfo: { requested: this.trackExpectedRate_, current: fps } };
+      this.emit("warn", msg);
+    }
     const qos = new ReportBuilder().action("MediaTransformer").fps(fps).transformedFps(transformedFps).framesTransformed(this.framesTransformed_).guid(this.uuid_).transformerType(this.transformerType_).videoHeight(this.videoHeight_).videoWidth(this.videoWidth_).variation("QoS").build();
     Reporter.report(qos);
     this.mediaTransformerQosReportStartTimestamp_ = 0;
@@ -1437,11 +1843,26 @@ class InternalTransformer {
     this.framesTransformed_ = 0;
   }
 }
-class Pipeline {
+class Pipeline extends emittery {
   constructor(transformers) {
+    super();
     this.transformers_ = [];
-    for (let transformer of transformers) {
-      this.transformers_.push(new InternalTransformer(transformer));
+    this.trackExpectedRate_ = -1;
+    for (let index = 0; index < transformers.length; index++) {
+      let internalTransformer = new InternalTransformer(transformers[index], index);
+      internalTransformer.on("error", (eventData) => {
+        this.emit("error", eventData);
+      });
+      internalTransformer.on("warn", (eventData) => {
+        this.emit("warn", eventData);
+      });
+      this.transformers_.push(internalTransformer);
+    }
+  }
+  setTrackExpectedRate(trackExpectedRate) {
+    this.trackExpectedRate_ = trackExpectedRate;
+    for (let transformer of this.transformers_) {
+      transformer.setTrackExpectedRate(this.trackExpectedRate_);
     }
   }
   async start(readable, writeable) {
@@ -1480,12 +1901,20 @@ class Pipeline {
     }
   }
 }
-class MediaProcessor {
+class MediaProcessor extends emittery {
   constructor() {
+    super();
     this.uuid_ = v4();
+    this.trackExpectedRate_ = -1;
     const report = new ReportBuilder().action("MediaProcessor").guid(this.uuid_).variation("Create").build();
     Reporter.report(report);
   }
+  setTrackExpectedRate(trackExpectedRate) {
+    this.trackExpectedRate_ = trackExpectedRate;
+    if (this.pipeline_) {
+      this.pipeline_.setTrackExpectedRate(this.trackExpectedRate_);
+    }
+  }
   transform(readable, writable) {
     this.readable_ = readable;
     this.writable_ = writable;
@@ -1502,6 +1931,15 @@ class MediaProcessor {
         this.pipeline_.destroy();
       }
       this.pipeline_ = new Pipeline(this.transformers_);
+      this.pipeline_.on("warn", (eventData) => {
+        this.emit("warn", eventData);
+      });
+      this.pipeline_.on("error", (eventData) => {
+        this.emit("error", eventData);
+      });
+      if (this.trackExpectedRate_ != -1) {
+        this.pipeline_.setTrackExpectedRate(this.trackExpectedRate_);
+      }
       this.pipeline_.start(this.readable_, this.writable_).then(() => {
         resolve();
       }).catch((e) => {
@@ -1599,4 +2037,4 @@ class MediaProcessorConnector {
     });
   }
 }
-export { MediaProcessor, MediaProcessorConnector, isSupported, setMetadata };
+export { MediaProcessor, MediaProcessorConnector, getMetadata, isSupported, setMetadata };