/* Autogenerated with Kurento Idl */
/*
* (C) Copyright 2013-2015 Kurento (https://kurento.openvidu.io/)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
var inherits = require('inherits');
var kurentoClient = require('kurento-client');
var disguise = kurentoClient.disguise;
var checkType = kurentoClient.checkType;
var ChecktypeError = checkType.ChecktypeError;
var Transaction = kurentoClient.TransactionsManager.Transaction;
var MediaObjectCreator = kurentoClient.MediaObjectCreator;
var TransactionsManager = kurentoClient.TransactionsManager;
var transactionOperation = TransactionsManager.transactionOperation;
var MediaObject = require('./abstracts/MediaObject');
function noop(error, result) {
if (error) console.trace(error);
return result
};
/**
* Create a {@link MediaPipeline}
*
* @classdesc
* A pipeline is a container for a collection of {@link MediaElement
* MediaElements} and :rom:cls:`MediaMixers<MediaMixer>`.
* It offers the methods needed to control the creation and connection of
* elements inside a certain pipeline.
*
* @extends module:core/abstracts.MediaObject
*
* @constructor module:core.MediaPipeline
*/
function MediaPipeline(strict){
MediaPipeline.super_.call(this);
var self = this;
// Transactional API
var transactionsManager = new TransactionsManager(this, encodeTransaction);
this.beginTransaction = transactionsManager.beginTransaction.bind(transactionsManager);
this.endTransaction = transactionsManager.endTransaction.bind(transactionsManager);
this.transaction = transactionsManager.transaction.bind(transactionsManager);
// Encode commands
function encodeCreate(transaction, params, callback)
{
if(transaction)
return transactionOperation.call(transaction, 'create', params, callback);
if(transactionsManager.length)
return transactionOperation.call(transactionsManager, 'create', params, callback);
self.emit('_create', undefined, params, callback)
}
function encodeRpc(transaction, method, params, callback)
{
if(transaction)
return transactionOperation.call(transaction, method, params, callback);
if(transactionsManager.length)
return transactionOperation.call(transactionsManager, method, params, callback);
self.emit('_rpc', undefined, method, params, callback)
}
function encodeTransaction(operations, callback)
{
var params =
{
// object: self,
operations: operations
};
if(transactionsManager.length)
return transactionOperation.call(transactionsManager, 'transaction', params, callback);
self.emit('_transaction', params, callback);
}
var describe = this.emit.bind(this, '_describe');
// Creation of objects
var mediaObjectCreator = new MediaObjectCreator(this, encodeCreate, encodeRpc,
encodeTransaction, describe, strict);
/**
* Create a new instance of a {module:core/abstract.MediaObject} attached to
* this {module:core.MediaPipeline}
*
* @param {external:String} type - Type of the
* {module:core/abstract.MediaObject}
* @param {external:String[]} [params]
* @param {module:core.MediaPipeline~createCallback} callback
*
* @return {external:Promise}
*/
this.create = mediaObjectCreator.create.bind(mediaObjectCreator);
/**
* @callback core.MediaPipeline~createCallback
* @param {external:Error} error
* @param {module:core/abstract~MediaElement} result
* The created MediaElement
*/
};
inherits(MediaPipeline, MediaObject);
//
// Public properties
//
/**
* If statistics about pipeline latency are enabled for all mediaElements
*
* @alias module:core.MediaPipeline#getLatencyStats
*
* @param {module:core.MediaPipeline~getLatencyStatsCallback} [callback]
*
* @return {external:Promise}
*/
MediaPipeline.prototype.getLatencyStats = function(callback){
var transaction = (arguments[0] instanceof Transaction)
? Array.prototype.shift.apply(arguments)
: undefined;
var usePromise = false;
if (callback == undefined) {
usePromise = true;
}
if(!arguments.length) callback = undefined;
callback = (callback || noop).bind(this)
return disguise(this._invoke(transaction, 'getLatencyStats', callback), this)
};
/**
* @callback module:core.MediaPipeline~getLatencyStatsCallback
* @param {external:Error} error
* @param {external:Boolean} result
*/
/**
* If statistics about pipeline latency are enabled for all mediaElements
*
* @alias module:core.MediaPipeline#setLatencyStats
*
* @param {external:Boolean} latencyStats
* @param {module:core.MediaPipeline~setLatencyStatsCallback} [callback]
*
* @return {external:Promise}
*/
MediaPipeline.prototype.setLatencyStats = function(latencyStats, callback){
var transaction = (arguments[0] instanceof Transaction)
? Array.prototype.shift.apply(arguments)
: undefined;
//
// checkType('boolean', 'latencyStats', latencyStats, {required: true});
//
var params = {
latencyStats: latencyStats
};
callback = (callback || noop).bind(this)
return disguise(this._invoke(transaction, 'setLatencyStats', params, callback), this)
};
/**
* @callback module:core.MediaPipeline~setLatencyStatsCallback
* @param {external:Error} error
*/
//
// Public methods
//
/**
* Returns a string in dot (graphviz) format that represents the gstreamer
* elements inside the pipeline
*
* @alias module:core.MediaPipeline.getGstreamerDot
*
* @param {module:core/complexTypes.GstreamerDotDetails} [details]
* Details of graph
*
* @param {module:core.MediaPipeline~getGstreamerDotCallback} [callback]
*
* @return {external:Promise}
*/
MediaPipeline.prototype.getGstreamerDot = function(details, callback){
var transaction = (arguments[0] instanceof Transaction)
? Array.prototype.shift.apply(arguments)
: undefined;
callback = arguments[arguments.length-1] instanceof Function
? Array.prototype.pop.call(arguments)
: undefined;
switch(arguments.length){
case 0: details = undefined;
break;
case 1:
break;
default:
var error = new RangeError('Number of params ('+arguments.length+') not in range [0-1]');
error.length = arguments.length;
error.min = 0;
error.max = 1;
throw error;
}
//
// checkType('GstreamerDotDetails', 'details', details);
//
var params = {
details: details
};
callback = (callback || noop).bind(this)
return disguise(this._invoke(transaction, 'getGstreamerDot', params, callback), this)
};
/**
* @callback module:core.MediaPipeline~getGstreamerDotCallback
* @param {external:Error} error
* @param {external:String} result
* The dot graph.
*/
/**
* Connect the source of a media to the sink of the next one
*
* @param {...module:core/abstract~MediaObject} media - A media to be connected
* @callback {module:MediaPipeline~connectCallback} [callback]
*
* @return {external:Promise}
*
* @throws {SyntaxError}
*/
MediaPipeline.prototype.connect = function(media, callback){
// Fix lenght-variable arguments
if(!(media instanceof Array))
{
media = Array.prototype.slice.call(arguments, 0);
callback = (typeof media[media.length - 1] === 'function')
? media.pop()
: undefined;
}
callback = (callback || noop).bind(this)
// Check if we have enought media components
if(media.length < 2)
throw new SyntaxError('Need at least two media elements to connect');
return media[0].connect(media.slice(1), callback)
};
/**
* @callback MediaPipeline~connectCallback
* @param {external:Error} error
*/
/**
* @alias module:core.MediaPipeline.constructorParams
*/
MediaPipeline.constructorParams = {
};
/**
* @alias module:core.MediaPipeline.events
*
* @extends module:core/abstracts.MediaObject.events
*/
MediaPipeline.events = MediaObject.events;
/**
* Checker for {@link module:core.MediaPipeline}
*
* @memberof module:core
*
* @param {external:String} key
* @param {module:core.MediaPipeline} value
*/
function checkMediaPipeline(key, value)
{
if(!(value instanceof MediaPipeline))
throw ChecktypeError(key, MediaPipeline, value);
};
module.exports = MediaPipeline;
MediaPipeline.check = checkMediaPipeline;