text: /* ----------------------------------------------------------------------------
   * This file was automatically generated by SWIG (http://www.swig.org).
   * Version 4.0.0
   *
   * This file is not intended to be easily readable and contains a number of
   * coding conventions designed to improve portability and efficiency. Do not make
   * changes to this file unless you know what you are doing--modify the SWIG
   * interface file instead.
   * ----------------------------------------------------------------------------- */
  
  #ifdef __cplusplus
  /* SwigValueWrapper is described in swig.swg */
  template<typename T> class SwigValueWrapper {
    struct SwigMovePointer {
      T *ptr;
      SwigMovePointer(T *p) : ptr(p) { }
      ~SwigMovePointer() { delete ptr; }
      SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    } pointer;
    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
    SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  public:
    SwigValueWrapper() : pointer(0) { }
    SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
    operator T&() const { return *pointer.ptr; }
    T *operator&() { return pointer.ptr; }
  };
  
  template <typename T> T SwigValueInit() {
    return T();
  }
  #endif
  
  /* -----------------------------------------------------------------------------
   *  This section contains generic SWIG labels for method/variable
   *  declarations/attributes, and other compiler dependent labels.
   * ----------------------------------------------------------------------------- */
  
  /* template workaround for compilers that cannot correctly implement the C++ standard */
  #ifndef SWIGTEMPLATEDISAMBIGUATOR
  # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  #  define SWIGTEMPLATEDISAMBIGUATOR template
  # elif defined(__HP_aCC)
  /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  #  define SWIGTEMPLATEDISAMBIGUATOR template
  # else
  #  define SWIGTEMPLATEDISAMBIGUATOR
  # endif
  #endif
  
  /* inline attribute */
  #ifndef SWIGINLINE
  # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  #   define SWIGINLINE inline
  # else
  #   define SWIGINLINE
  # endif
  #endif
  
  /* attribute recognised by some compilers to avoid 'unused' warnings */
  #ifndef SWIGUNUSED
  # if defined(__GNUC__)
  #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  #     define SWIGUNUSED __attribute__ ((__unused__))
  #   else
  #     define SWIGUNUSED
  #   endif
  # elif defined(__ICC)
  #   define SWIGUNUSED __attribute__ ((__unused__))
  # else
  #   define SWIGUNUSED
  # endif
  #endif
  
  #ifndef SWIG_MSC_UNSUPPRESS_4505
  # if defined(_MSC_VER)
  #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  # endif
  #endif
  
  #ifndef SWIGUNUSEDPARM
  # ifdef __cplusplus
  #   define SWIGUNUSEDPARM(p)
  # else
  #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  # endif
  #endif
  
  /* internal SWIG method */
  #ifndef SWIGINTERN
  # define SWIGINTERN static SWIGUNUSED
  #endif
  
  /* internal inline SWIG method */
  #ifndef SWIGINTERNINLINE
  # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  #endif
  
  /* exporting methods */
  #if defined(__GNUC__)
  #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  #    ifndef GCC_HASCLASSVISIBILITY
  #      define GCC_HASCLASSVISIBILITY
  #    endif
  #  endif
  #endif
  
  #ifndef SWIGEXPORT
  # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  #   if defined(STATIC_LINKED)
  #     define SWIGEXPORT
  #   else
  #     define SWIGEXPORT __declspec(dllexport)
  #   endif
  # else
  #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
  #     define SWIGEXPORT __attribute__ ((visibility("default")))
  #   else
  #     define SWIGEXPORT
  #   endif
  # endif
  #endif
  
  /* calling conventions for Windows */
  #ifndef SWIGSTDCALL
  # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  #   define SWIGSTDCALL __stdcall
  # else
  #   define SWIGSTDCALL
  # endif
  #endif
  
  /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
  #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
  # define _CRT_SECURE_NO_DEPRECATE
  #endif
  
  /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
  #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
  # define _SCL_SECURE_NO_DEPRECATE
  #endif
  
  /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
  #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
  # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
  #endif
  
  /* Intel's compiler complains if a variable which was never initialised is
   * cast to void, which is a common idiom which we use to indicate that we
   * are aware a variable isn't used.  So we just silence that warning.
   * See: https://github.com/swig/swig/issues/192 for more discussion.
   */
  #ifdef __INTEL_COMPILER
  # pragma warning disable 592
  #endif
  
  
  
  #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) 
  
  #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else 
  
  
  
  #ifndef SWIG_V8_VERSION
  #define SWIG_V8_VERSION 0x031110
  #endif
  
  
  #include <node.h>
  
  
  #include <v8.h>
  
  #include <errno.h>
  #include <limits.h>
  #include <stdlib.h>
  
  /* -----------------------------------------------------------------------------
   * swigrun.swg
   *
   * This file contains generic C API SWIG runtime support for pointer
   * type checking.
   * ----------------------------------------------------------------------------- */
  
  /* This should only be incremented when either the layout of swig_type_info changes,
     or for whatever reason, the runtime changes incompatibly */
  #define SWIG_RUNTIME_VERSION "4"
  
  /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
  #ifdef SWIG_TYPE_TABLE
  # define SWIG_QUOTE_STRING(x) #x
  # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
  # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
  #else
  # define SWIG_TYPE_TABLE_NAME
  #endif
  
  /*
    You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
    creating a static or dynamic library from the SWIG runtime code.
    In 99.9% of the cases, SWIG just needs to declare them as 'static'.
  
    But only do this if strictly necessary, ie, if you have problems
    with your compiler or suchlike.
  */
  
  #ifndef SWIGRUNTIME
  # define SWIGRUNTIME SWIGINTERN
  #endif
  
  #ifndef SWIGRUNTIMEINLINE
  # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
  #endif
  
  /*  Generic buffer size */
  #ifndef SWIG_BUFFER_SIZE
  # define SWIG_BUFFER_SIZE 1024
  #endif
  
  /* Flags for pointer conversions */
  #define SWIG_POINTER_DISOWN        0x1
  #define SWIG_CAST_NEW_MEMORY       0x2
  #define SWIG_POINTER_NO_NULL       0x4
  
  /* Flags for new pointer objects */
  #define SWIG_POINTER_OWN           0x1
  
  
  /*
     Flags/methods for returning states.
  
     The SWIG conversion methods, as ConvertPtr, return an integer
     that tells if the conversion was successful or not. And if not,
     an error code can be returned (see swigerrors.swg for the codes).
  
     Use the following macros/flags to set or process the returning
     states.
  
     In old versions of SWIG, code such as the following was usually written:
  
       if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
         // success code
       } else {
         //fail code
       }
  
     Now you can be more explicit:
  
      int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
      if (SWIG_IsOK(res)) {
        // success code
      } else {
        // fail code
      }
  
     which is the same really, but now you can also do
  
      Type *ptr;
      int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
      if (SWIG_IsOK(res)) {
        // success code
        if (SWIG_IsNewObj(res) {
          ...
  	delete *ptr;
        } else {
          ...
        }
      } else {
        // fail code
      }
  
     I.e., now SWIG_ConvertPtr can return new objects and you can
     identify the case and take care of the deallocation. Of course that
     also requires SWIG_ConvertPtr to return new result values, such as
  
        int SWIG_ConvertPtr(obj, ptr,...) {
          if (<obj is ok>) {
            if (<need new object>) {
              *ptr = <ptr to new allocated object>;
              return SWIG_NEWOBJ;
            } else {
              *ptr = <ptr to old object>;
              return SWIG_OLDOBJ;
            }
          } else {
            return SWIG_BADOBJ;
          }
        }
  
     Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
     more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
     SWIG errors code.
  
     Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
     allows to return the 'cast rank', for example, if you have this
  
         int food(double)
         int fooi(int);
  
     and you call
  
        food(1)   // cast rank '1'  (1 -> 1.0)
        fooi(1)   // cast rank '0'
  
     just use the SWIG_AddCast()/SWIG_CheckState()
  */
  
  #define SWIG_OK                    (0)
  #define SWIG_ERROR                 (-1)
  #define SWIG_IsOK(r)               (r >= 0)
  #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
  
  /* The CastRankLimit says how many bits are used for the cast rank */
  #define SWIG_CASTRANKLIMIT         (1 << 8)
  /* The NewMask denotes the object was created (using new/malloc) */
  #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
  /* The TmpMask is for in/out typemaps that use temporal objects */
  #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
  /* Simple returning values */
  #define SWIG_BADOBJ                (SWIG_ERROR)
  #define SWIG_OLDOBJ                (SWIG_OK)
  #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
  #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
  /* Check, add and del mask methods */
  #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
  #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
  #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
  #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
  #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
  #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
  
  /* Cast-Rank Mode */
  #if defined(SWIG_CASTRANK_MODE)
  #  ifndef SWIG_TypeRank
  #    define SWIG_TypeRank             unsigned long
  #  endif
  #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
  #    define SWIG_MAXCASTRANK          (2)
  #  endif
  #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
  #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
  SWIGINTERNINLINE int SWIG_AddCast(int r) {
    return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
  }
  SWIGINTERNINLINE int SWIG_CheckState(int r) {
    return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
  }
  #else /* no cast-rank mode */
  #  define SWIG_AddCast(r) (r)
  #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
  #endif
  
  
  #include <string.h>
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  typedef void *(*swig_converter_func)(void *, int *);
  typedef struct swig_type_info *(*swig_dycast_func)(void **);
  
  /* Structure to store information on one type */
  typedef struct swig_type_info {
    const char             *name;			/* mangled name of this type */
    const char             *str;			/* human readable name of this type */
    swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
    struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
    void                   *clientdata;		/* language specific type data */
    int                    owndata;		/* flag if the structure owns the clientdata */
  } swig_type_info;
  
  /* Structure to store a type and conversion function used for casting */
  typedef struct swig_cast_info {
    swig_type_info         *type;			/* pointer to type that is equivalent to this type */
    swig_converter_func     converter;		/* function to cast the void pointers */
    struct swig_cast_info  *next;			/* pointer to next cast in linked list */
    struct swig_cast_info  *prev;			/* pointer to the previous cast */
  } swig_cast_info;
  
  /* Structure used to store module information
   * Each module generates one structure like this, and the runtime collects
   * all of these structures and stores them in a circularly linked list.*/
  typedef struct swig_module_info {
    swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
    size_t                 size;		        /* Number of types in this module */
    struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
    swig_type_info         **type_initial;	/* Array of initially generated type structures */
    swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
    void                    *clientdata;		/* Language specific module data */
  } swig_module_info;
  
  /*
    Compare two type names skipping the space characters, therefore
    "char*" == "char *" and "Class<int>" == "Class<int >", etc.
  
    Return 0 when the two name types are equivalent, as in
    strncmp, but skipping ' '.
  */
  SWIGRUNTIME int
  SWIG_TypeNameComp(const char *f1, const char *l1,
  		  const char *f2, const char *l2) {
    for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
      while ((*f1 == ' ') && (f1 != l1)) ++f1;
      while ((*f2 == ' ') && (f2 != l2)) ++f2;
      if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
    }
    return (int)((l1 - f1) - (l2 - f2));
  }
  
  /*
    Check type equivalence in a name list like <name1>|<name2>|...
    Return 0 if equal, -1 if nb < tb, 1 if nb > tb
  */
  SWIGRUNTIME int
  SWIG_TypeCmp(const char *nb, const char *tb) {
    int equiv = 1;
    const char* te = tb + strlen(tb);
    const char* ne = nb;
    while (equiv != 0 && *ne) {
      for (nb = ne; *ne; ++ne) {
        if (*ne == '|') break;
      }
      equiv = SWIG_TypeNameComp(nb, ne, tb, te);
      if (*ne) ++ne;
    }
    return equiv;
  }
  
  /*
    Check type equivalence in a name list like <name1>|<name2>|...
    Return 0 if not equal, 1 if equal
  */
  SWIGRUNTIME int
  SWIG_TypeEquiv(const char *nb, const char *tb) {
    return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
  }
  
  /*
    Check the typename
  */
  SWIGRUNTIME swig_cast_info *
  SWIG_TypeCheck(const char *c, swig_type_info *ty) {
    if (ty) {
      swig_cast_info *iter = ty->cast;
      while (iter) {
        if (strcmp(iter->type->name, c) == 0) {
          if (iter == ty->cast)
            return iter;
          /* Move iter to the top of the linked list */
          iter->prev->next = iter->next;
          if (iter->next)
            iter->next->prev = iter->prev;
          iter->next = ty->cast;
          iter->prev = 0;
          if (ty->cast) ty->cast->prev = iter;
          ty->cast = iter;
          return iter;
        }
        iter = iter->next;
      }
    }
    return 0;
  }
  
  /*
    Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
  */
  SWIGRUNTIME swig_cast_info *
  SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
    if (ty) {
      swig_cast_info *iter = ty->cast;
      while (iter) {
        if (iter->type == from) {
          if (iter == ty->cast)
            return iter;
          /* Move iter to the top of the linked list */
          iter->prev->next = iter->next;
          if (iter->next)
            iter->next->prev = iter->prev;
          iter->next = ty->cast;
          iter->prev = 0;
          if (ty->cast) ty->cast->prev = iter;
          ty->cast = iter;
          return iter;
        }
        iter = iter->next;
      }
    }
    return 0;
  }
  
  /*
    Cast a pointer up an inheritance hierarchy
  */
  SWIGRUNTIMEINLINE void *
  SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
    return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
  }
  
  /*
     Dynamic pointer casting. Down an inheritance hierarchy
  */
  SWIGRUNTIME swig_type_info *
  SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
    swig_type_info *lastty = ty;
    if (!ty || !ty->dcast) return ty;
    while (ty && (ty->dcast)) {
      ty = (*ty->dcast)(ptr);
      if (ty) lastty = ty;
    }
    return lastty;
  }
  
  /*
    Return the name associated with this type
  */
  SWIGRUNTIMEINLINE const char *
  SWIG_TypeName(const swig_type_info *ty) {
    return ty->name;
  }
  
  /*
    Return the pretty name associated with this type,
    that is an unmangled type name in a form presentable to the user.
  */
  SWIGRUNTIME const char *
  SWIG_TypePrettyName(const swig_type_info *type) {
    /* The "str" field contains the equivalent pretty names of the
       type, separated by vertical-bar characters.  We choose
       to print the last name, as it is often (?) the most
       specific. */
    if (!type) return NULL;
    if (type->str != NULL) {
      const char *last_name = type->str;
      const char *s;
      for (s = type->str; *s; s++)
        if (*s == '|') last_name = s+1;
      return last_name;
    }
    else
      return type->name;
  }
  
  /*
     Set the clientdata field for a type
  */
  SWIGRUNTIME void
  SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
    swig_cast_info *cast = ti->cast;
    /* if (ti->clientdata == clientdata) return; */
    ti->clientdata = clientdata;
  
    while (cast) {
      if (!cast->converter) {
        swig_type_info *tc = cast->type;
        if (!tc->clientdata) {
  	SWIG_TypeClientData(tc, clientdata);
        }
      }
      cast = cast->next;
    }
  }
  SWIGRUNTIME void
  SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
    SWIG_TypeClientData(ti, clientdata);
    ti->owndata = 1;
  }
  
  /*
    Search for a swig_type_info structure only by mangled name
    Search is a O(log #types)
  
    We start searching at module start, and finish searching when start == end.
    Note: if start == end at the beginning of the function, we go all the way around
    the circular list.
  */
  SWIGRUNTIME swig_type_info *
  SWIG_MangledTypeQueryModule(swig_module_info *start,
                              swig_module_info *end,
  		            const char *name) {
    swig_module_info *iter = start;
    do {
      if (iter->size) {
        size_t l = 0;
        size_t r = iter->size - 1;
        do {
  	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
  	size_t i = (l + r) >> 1;
  	const char *iname = iter->types[i]->name;
  	if (iname) {
  	  int compare = strcmp(name, iname);
  	  if (compare == 0) {
  	    return iter->types[i];
  	  } else if (compare < 0) {
  	    if (i) {
  	      r = i - 1;
  	    } else {
  	      break;
  	    }
  	  } else if (compare > 0) {
  	    l = i + 1;
  	  }
  	} else {
  	  break; /* should never happen */
  	}
        } while (l <= r);
      }
      iter = iter->next;
    } while (iter != end);
    return 0;
  }
  
  /*
    Search for a swig_type_info structure for either a mangled name or a human readable name.
    It first searches the mangled names of the types, which is a O(log #types)
    If a type is not found it then searches the human readable names, which is O(#types).
  
    We start searching at module start, and finish searching when start == end.
    Note: if start == end at the beginning of the function, we go all the way around
    the circular list.
  */
  SWIGRUNTIME swig_type_info *
  SWIG_TypeQueryModule(swig_module_info *start,
                       swig_module_info *end,
  		     const char *name) {
    /* STEP 1: Search the name field using binary search */
    swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
    if (ret) {
      return ret;
    } else {
      /* STEP 2: If the type hasn't been found, do a complete search
         of the str field (the human readable name) */
      swig_module_info *iter = start;
      do {
        size_t i = 0;
        for (; i < iter->size; ++i) {
  	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
  	  return iter->types[i];
        }
        iter = iter->next;
      } while (iter != end);
    }
  
    /* neither found a match */
    return 0;
  }
  
  /*
     Pack binary data into a string
  */
  SWIGRUNTIME char *
  SWIG_PackData(char *c, void *ptr, size_t sz) {
    static const char hex[17] = "0123456789abcdef";
    const unsigned char *u = (unsigned char *) ptr;
    const unsigned char *eu =  u + sz;
    for (; u != eu; ++u) {
      unsigned char uu = *u;
      *(c++) = hex[(uu & 0xf0) >> 4];
      *(c++) = hex[uu & 0xf];
    }
    return c;
  }
  
  /*
     Unpack binary data from a string
  */
  SWIGRUNTIME const char *
  SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
    unsigned char *u = (unsigned char *) ptr;
    const unsigned char *eu = u + sz;
    for (; u != eu; ++u) {
      char d = *(c++);
      unsigned char uu;
      if ((d >= '0') && (d <= '9'))
        uu = (unsigned char)((d - '0') << 4);
      else if ((d >= 'a') && (d <= 'f'))
        uu = (unsigned char)((d - ('a'-10)) << 4);
      else
        return (char *) 0;
      d = *(c++);
      if ((d >= '0') && (d <= '9'))
        uu |= (unsigned char)(d - '0');
      else if ((d >= 'a') && (d <= 'f'))
        uu |= (unsigned char)(d - ('a'-10));
      else
        return (char *) 0;
      *u = uu;
    }
    return c;
  }
  
  /*
     Pack 'void *' into a string buffer.
  */
  SWIGRUNTIME char *
  SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
    char *r = buff;
    if ((2*sizeof(void *) + 2) > bsz) return 0;
    *(r++) = '_';
    r = SWIG_PackData(r,&ptr,sizeof(void *));
    if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
    strcpy(r,name);
    return buff;
  }
  
  SWIGRUNTIME const char *
  SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
    if (*c != '_') {
      if (strcmp(c,"NULL") == 0) {
        *ptr = (void *) 0;
        return name;
      } else {
        return 0;
      }
    }
    return SWIG_UnpackData(++c,ptr,sizeof(void *));
  }
  
  SWIGRUNTIME char *
  SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
    char *r = buff;
    size_t lname = (name ? strlen(name) : 0);
    if ((2*sz + 2 + lname) > bsz) return 0;
    *(r++) = '_';
    r = SWIG_PackData(r,ptr,sz);
    if (lname) {
      strncpy(r,name,lname+1);
    } else {
      *r = 0;
    }
    return buff;
  }
  
  SWIGRUNTIME const char *
  SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
    if (*c != '_') {
      if (strcmp(c,"NULL") == 0) {
        memset(ptr,0,sz);
        return name;
      } else {
        return 0;
      }
    }
    return SWIG_UnpackData(++c,ptr,sz);
  }
  
  #ifdef __cplusplus
  }
  #endif
  
  /*  Errors in SWIG */
  #define  SWIG_UnknownError    	   -1
  #define  SWIG_IOError        	   -2
  #define  SWIG_RuntimeError   	   -3
  #define  SWIG_IndexError     	   -4
  #define  SWIG_TypeError      	   -5
  #define  SWIG_DivisionByZero 	   -6
  #define  SWIG_OverflowError  	   -7
  #define  SWIG_SyntaxError    	   -8
  #define  SWIG_ValueError     	   -9
  #define  SWIG_SystemError    	   -10
  #define  SWIG_AttributeError 	   -11
  #define  SWIG_MemoryError    	   -12
  #define  SWIG_NullReferenceError   -13
  
  
  
  /* ---------------------------------------------------------------------------
   * These typedefs and defines are used to deal with v8 API changes
   *
   * ---------------------------------------------------------------------------*/
  
  // First v8 version that uses "SetWeak" and not "MakeWeak"
  
  #define SWIGV8_SETWEAK_VERSION 0x032224
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031803)
  #define SWIGV8_STRING_NEW2(cstr, len) v8::String::New(cstr, len)
  #else
  #define SWIGV8_STRING_NEW2(cstr, len) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), cstr, v8::String::kNormalString, len)
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
  typedef v8::Handle<v8::Value> SwigV8ReturnValue;
  typedef v8::Arguments SwigV8Arguments;
  typedef v8::AccessorInfo SwigV8PropertyCallbackInfo;
  #define SWIGV8_RETURN(val) return scope.Close(val)
  #define SWIGV8_RETURN_INFO(val, info) return scope.Close(val)
  #else
  typedef void SwigV8ReturnValue;
  typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
  typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
  #define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
  #define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032117)
  #define SWIGV8_HANDLESCOPE() v8::HandleScope scope
  #define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope
  #define SWIGV8_ESCAPE(val) return scope.Close(val)
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032224)
  #define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
  #define SWIGV8_HANDLESCOPE_ESC() v8::HandleScope scope(v8::Isolate::GetCurrent());
  #define SWIGV8_ESCAPE(val) return scope.Close(val)
  #else
  #define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
  #define SWIGV8_HANDLESCOPE_ESC() v8::EscapableHandleScope scope(v8::Isolate::GetCurrent());
  #define SWIGV8_ESCAPE(val) return scope.Escape(val)
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032224)
  #define SWIGV8_ADJUST_MEMORY(size) v8::V8::AdjustAmountOfExternalAllocatedMemory(size)
  #define SWIGV8_CURRENT_CONTEXT() v8::Context::GetCurrent()
  #define SWIGV8_THROW_EXCEPTION(err) v8::ThrowException(err)
  #define SWIGV8_STRING_NEW(str) v8::String::New(str)
  #define SWIGV8_SYMBOL_NEW(sym) v8::String::NewSymbol(sym)
  #else
  #define SWIGV8_ADJUST_MEMORY(size) v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(size)
  #define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext()
  #define SWIGV8_THROW_EXCEPTION(err) v8::Isolate::GetCurrent()->ThrowException(err)
  #define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str)
  #define SWIGV8_SYMBOL_NEW(sym) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), sym)
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032318)
  #define SWIGV8_ARRAY_NEW() v8::Array::New()
  #define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(bool)
  #define SWIGV8_EXTERNAL_NEW(val) v8::External::New(val)
  #define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(func)
  #define SWIGV8_FUNCTEMPLATE_NEW_VOID() v8::FunctionTemplate::New()
  #define SWIGV8_INT32_NEW(num) v8::Int32::New(num)
  #define SWIGV8_INTEGER_NEW(num) v8::Integer::New(num)
  #define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(num)
  #define SWIGV8_NUMBER_NEW(num) v8::Number::New(num)
  #define SWIGV8_OBJECT_NEW() v8::Object::New()
  #define SWIGV8_UNDEFINED() v8::Undefined()
  #define SWIGV8_NULL() v8::Null()
  #else
  #define SWIGV8_ARRAY_NEW() v8::Array::New(v8::Isolate::GetCurrent())
  #define SWIGV8_BOOLEAN_NEW(bool) v8::Boolean::New(v8::Isolate::GetCurrent(), bool)
  #define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
  #define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func)
  #define SWIGV8_FUNCTEMPLATE_NEW_VOID() v8::FunctionTemplate::New(v8::Isolate::GetCurrent())
  #define SWIGV8_INT32_NEW(num) v8::Int32::New(v8::Isolate::GetCurrent(), num)
  #define SWIGV8_INTEGER_NEW(num) v8::Integer::New(v8::Isolate::GetCurrent(), num)
  #define SWIGV8_INTEGER_NEW_UNS(num) v8::Integer::NewFromUnsigned(v8::Isolate::GetCurrent(), num)
  #define SWIGV8_NUMBER_NEW(num) v8::Number::New(v8::Isolate::GetCurrent(), num)
  #define SWIGV8_OBJECT_NEW() v8::Object::New(v8::Isolate::GetCurrent())
  #define SWIGV8_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())
  #define SWIGV8_NULL() v8::Null(v8::Isolate::GetCurrent())
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  #define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(class);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
  #define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ = v8::Persistent<v8::FunctionTemplate>::New(v8::Isolate::GetCurrent(), class);
  #else
  #define SWIGV8_SET_CLASS_TEMPL(class_templ, class) class_templ.Reset(v8::Isolate::GetCurrent(), class);
  #endif
  
  /* ---------------------------------------------------------------------------
   * Error handling
   *
   * ---------------------------------------------------------------------------*/
  
  #define SWIG_Error(code, msg)     SWIGV8_ErrorHandler.error(code, msg)
  #define SWIG_exception(code, msg) do { SWIGV8_ErrorHandler.error(code, msg); SWIG_fail; } while (0)
  #define SWIG_fail                 goto fail
  #define SWIGV8_OVERLOAD false
  
  SWIGINTERN void SWIG_V8_Raise(const char *msg) {
    SWIGV8_THROW_EXCEPTION(v8::Exception::Error(SWIGV8_STRING_NEW(msg)));
  }
  
  /*
    Note: There are two contexts for handling errors.
    A static V8ErrorHandler is used in not overloaded methods.
    For overloaded methods the throwing type checking mechanism is used
    during dispatching. As V8 exceptions can not be reset properly
    the trick is to use a dynamic ErrorHandler with same local name as the global
    one.
  
    - See definition of SWIG_Error above.
    - See code templates 'JS_function_dispatcher', 'JS_functionwrapper_overload',
      and 'JS_function_dispatch_case' in javascriptcode.swg
  
  */
  class V8ErrorHandler {
  public:
    virtual ~V8ErrorHandler() {}
    virtual void error(int code, const char *msg) {
      SWIG_V8_Raise(msg);
    }
  };
  // this is used in usually
  SWIGRUNTIME V8ErrorHandler SWIGV8_ErrorHandler;
  
  // instances of this are used in overloaded functions
  class OverloadErrorHandler: public V8ErrorHandler {
  public:
    virtual void error(int code, const char *msg) {
      err = v8::Exception::Error(SWIGV8_STRING_NEW(msg));
      if(code != SWIG_TypeError) {
          SWIGV8_THROW_EXCEPTION(err);
      }
    }
    v8::Handle<v8::Value> err;
  };
  
  /* ---------------------------------------------------------------------------
   * Basic Proxy object
   *
   * ---------------------------------------------------------------------------*/
  
  // Note: to trigger the v8 gc more often one can tell v8 about the memory consumption
  // TODO: we could add a v8 specific parameter to control this value
  #define SWIGV8_AVG_OBJ_SIZE 1000
  
  class SWIGV8_Proxy {
  public:
    SWIGV8_Proxy(): swigCMemOwn(false), swigCObject(0), info(0) {
      SWIGV8_ADJUST_MEMORY(SWIGV8_AVG_OBJ_SIZE);
    };
  
    ~SWIGV8_Proxy() {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
      handle.ClearWeak();
      handle.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
      handle.ClearWeak(v8::Isolate::GetCurrent());
      handle.Dispose(v8::Isolate::GetCurrent());
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      handle.ClearWeak();
      handle.Dispose();
  #else    
      handle.ClearWeak();
      handle.Reset();
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      handle.Clear();
  #endif
  
      SWIGV8_ADJUST_MEMORY(-SWIGV8_AVG_OBJ_SIZE);
    }
  
    bool swigCMemOwn;
    void *swigCObject;
    swig_type_info *info;
    v8::Persistent<v8::Object> handle;
  };
  
  class SWIGV8_ClientData {
  public:
    v8::Persistent<v8::FunctionTemplate> class_templ;
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
    void (*dtor) (v8::Persistent< v8::Value> object, void *parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Value> object, void *parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
    void (*dtor) (v8::Isolate *isolate, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy);
  #elif (V8_MAJOR_VERSION-0) < 5
    void (*dtor) (const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data);
  #else
    void (*dtor) (const v8::WeakCallbackInfo<SWIGV8_Proxy> &data);
  #endif
  };
  
  SWIGRUNTIME v8::Persistent<v8::FunctionTemplate> SWIGV8_SWIGTYPE_Proxy_class_templ;
  
  SWIGRUNTIME int SWIG_V8_ConvertInstancePtr(v8::Handle<v8::Object> objRef, void **ptr, swig_type_info *info, int flags) {
    SWIGV8_HANDLESCOPE();
  
    if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
    v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
    SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
  #else
    SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(objRef->GetAlignedPointerFromInternalField(0));
  #endif
  
    if(cdata == NULL) {
      return SWIG_ERROR;
    }
    if(cdata->info != info) {
      swig_cast_info *tc = SWIG_TypeCheckStruct(cdata->info, info);
      if (!tc && cdata->info->name) {
        tc = SWIG_TypeCheck(cdata->info->name, info);
      }
      bool type_valid = tc != 0;
      if(!type_valid) {
        return SWIG_TypeError;
      }
      int newmemory = 0;
      *ptr = SWIG_TypeCast(tc, cdata->swigCObject, &newmemory);
    } else {
      *ptr = cdata->swigCObject;
    }
    if(flags & SWIG_POINTER_DISOWN) {
      cdata->swigCMemOwn = false;
    }
    return SWIG_OK;
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(v8::Persistent< v8::Value > object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
  SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Value > object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
  SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(v8::Isolate *, v8::Persistent< v8::Object > *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
  SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
    SWIGV8_Proxy *proxy = data.GetParameter();
  #else
  SWIGRUNTIME void SWIGV8_Proxy_DefaultDtor(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
    SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
  
    delete proxy;
  }
  
  SWIGRUNTIME int SWIG_V8_GetInstancePtr(v8::Handle<v8::Value> valRef, void **ptr) {
    if(!valRef->IsObject()) {
      return SWIG_TypeError;
    }
    v8::Handle<v8::Object> objRef = valRef->ToObject();
  
    if(objRef->InternalFieldCount() < 1) return SWIG_ERROR;
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
    v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
    SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(v8::External::Unwrap(cdataRef));
  #else
    SWIGV8_Proxy *cdata = static_cast<SWIGV8_Proxy *>(objRef->GetAlignedPointerFromInternalField(0));
  #endif
  
    if(cdata == NULL) {
      return SWIG_ERROR;
    }
  
    *ptr = cdata->swigCObject;
  
    return SWIG_OK;
  }
  
  SWIGRUNTIME void SWIGV8_SetPrivateData(v8::Handle<v8::Object> obj, void *ptr, swig_type_info *info, int flags) {
    SWIGV8_Proxy *cdata = new SWIGV8_Proxy();
    cdata->swigCObject = ptr;
    cdata->swigCMemOwn = (flags & SWIG_POINTER_OWN) ? 1 : 0;
    cdata->info = info;
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
    obj->SetPointerInInternalField(0, cdata);
  #else
    obj->SetAlignedPointerInInternalField(0, cdata);
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
    cdata->handle = v8::Persistent<v8::Object>::New(obj);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
  #else
    cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
    // clientdata must be set for owned data as we need to register the dtor
    if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
      cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
    } else {
      cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
    }
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031918)
    if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
      cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
    } else {
      cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, SWIGV8_Proxy_DefaultDtor);
    }
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
    if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
      cdata->handle.MakeWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
    } else {
      cdata->handle.MakeWeak(cdata, SWIGV8_Proxy_DefaultDtor);
    }
  #elif (V8_MAJOR_VERSION-0) < 5
    if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
      cdata->handle.SetWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor);
    } else {
      cdata->handle.SetWeak(cdata, SWIGV8_Proxy_DefaultDtor);
    }
  #else
    if(cdata->swigCMemOwn && (SWIGV8_ClientData*)info->clientdata) {
      cdata->handle.SetWeak(cdata, ((SWIGV8_ClientData*)info->clientdata)->dtor, v8::WeakCallbackType::kParameter);
    } else {
      cdata->handle.SetWeak(cdata, SWIGV8_Proxy_DefaultDtor, v8::WeakCallbackType::kParameter);
    }
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
    cdata->handle.MarkIndependent();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
    cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
  #else
    cdata->handle.MarkIndependent();
  #endif
  
  }
  
  SWIGRUNTIME int SWIG_V8_ConvertPtr(v8::Handle<v8::Value> valRef, void **ptr, swig_type_info *info, int flags) {
    SWIGV8_HANDLESCOPE();
    
    /* special case: JavaScript null => C NULL pointer */
    if(valRef->IsNull()) {
      *ptr=0;
      return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK;
    }
    if(!valRef->IsObject()) {
      return SWIG_TypeError;
    }
    v8::Handle<v8::Object> objRef = valRef->ToObject();
    return SWIG_V8_ConvertInstancePtr(objRef, ptr, info, flags);
  }
  
  SWIGRUNTIME v8::Handle<v8::Value> SWIG_V8_NewPointerObj(void *ptr, swig_type_info *info, int flags) {
    SWIGV8_HANDLESCOPE_ESC();
    
    v8::Handle<v8::FunctionTemplate> class_templ;
  
    if (ptr == NULL) {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      SWIGV8_ESCAPE(SWIGV8_NULL());
  #else    
      v8::Local<v8::Primitive> result = SWIGV8_NULL();
      SWIGV8_ESCAPE(result);
  #endif
    }
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    if(info->clientdata != 0) {
      class_templ = ((SWIGV8_ClientData*) info->clientdata)->class_templ;
    } else {
      class_templ = SWIGV8_SWIGTYPE_Proxy_class_templ;
    }
  #else
    v8::Isolate *isolate = v8::Isolate::GetCurrent();
  
    if(info->clientdata != 0) {
      class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, ((SWIGV8_ClientData*) info->clientdata)->class_templ);
    } else {
      class_templ = v8::Local<v8::FunctionTemplate>::New(isolate, SWIGV8_SWIGTYPE_Proxy_class_templ);
    }
  #endif
  
  //  v8::Handle<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
    v8::Local<v8::Object> result = class_templ->InstanceTemplate()->NewInstance();
    SWIGV8_SetPrivateData(result, ptr, info, flags);
  
    SWIGV8_ESCAPE(result);
  }
  
  #define SWIG_ConvertPtr(obj, ptr, info, flags)    SWIG_V8_ConvertPtr(obj, ptr, info, flags)
  #define SWIG_NewPointerObj(ptr, info, flags)      SWIG_V8_NewPointerObj(ptr, info, flags)
  
  #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_V8_ConvertInstancePtr(obj, pptr, type, flags)
  #define SWIG_NewInstanceObj(thisvalue, type, flags)     SWIG_V8_NewPointerObj(thisvalue, type, flags)
  
  #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_V8_ConvertPtr(obj, pptr, type, 0)
  #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_V8_NewPointerObj(ptr, type, 0)
  
  #define SWIG_GetInstancePtr(obj, ptr)    SWIG_V8_GetInstancePtr(obj, ptr)
  
  SWIGRUNTIME SwigV8ReturnValue _SWIGV8_wrap_equals(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    void *arg1 = (void *) 0 ;
    void *arg2 = (void *) 0 ;
    bool result;
    int res1;
    int res2;
  
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for equals.");
  
    res1 = SWIG_GetInstancePtr(args.Holder(), &arg1);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ERROR, "Could not get pointer from 'this' object for equals.");
    }
    res2 = SWIG_GetInstancePtr(args[0], &arg2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "equals" "', argument " "1"" of type '" "void *""'");
    }
  
    result = (bool)(arg1 == arg2);
    jsresult =  SWIGV8_BOOLEAN_NEW(result);
  
    SWIGV8_RETURN(jsresult);
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  SWIGRUNTIME SwigV8ReturnValue _wrap_getCPtr(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    void *arg1 = (void *) 0 ;
    long result;
    int res1;
  
    res1 = SWIG_GetInstancePtr(args.Holder(), &arg1);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getCPtr" "', argument " "1"" of type '" "void *""'");
    }
  
    result = (long)arg1;
    jsresult = SWIGV8_NUMBER_NEW(result);
  
    SWIGV8_RETURN(jsresult);
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  /* ---------------------------------------------------------------------------
   * PackedData object
   *
   * ---------------------------------------------------------------------------*/
  
  class SwigV8PackedData {
  public:
    SwigV8PackedData(void *data, size_t size, swig_type_info *type): data(data), size(size), type(type) {};
  
    ~SwigV8PackedData() {
    };
  
    void *data;
    size_t size;
    swig_type_info *type;
  
    v8::Persistent<v8::Object> handle;
  };
  
  SWIGRUNTIMEINLINE
  int SwigV8Packed_Check(v8::Handle<v8::Value> valRef) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> objRef = valRef->ToObject();
    if(objRef->InternalFieldCount() < 1) return false;
  #if (V8_MAJOR_VERSION-0) < 5
    v8::Handle<v8::Value> flag = objRef->GetHiddenValue(SWIGV8_STRING_NEW("__swig__packed_data__"));
  #else
    v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("__swig__packed_data__"));
    v8::Local<v8::Value> flag;
    if (!objRef->GetPrivate(SWIGV8_CURRENT_CONTEXT(), privateKey).ToLocal(&flag))
      return false;
  #endif
    return (flag->IsBoolean() && flag->BooleanValue());
  }
  
  SWIGRUNTIME
  swig_type_info *SwigV8Packed_UnpackData(v8::Handle<v8::Value> valRef, void *ptr, size_t size) {
    if (SwigV8Packed_Check(valRef)) {
      SWIGV8_HANDLESCOPE();
      
      SwigV8PackedData *sobj;
  
      v8::Handle<v8::Object> objRef = valRef->ToObject();
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
      v8::Handle<v8::Value> cdataRef = objRef->GetInternalField(0);
      sobj = static_cast<SwigV8PackedData*>(v8::External::Unwrap(cdataRef));
  #else
      sobj = static_cast<SwigV8PackedData*>(objRef->GetAlignedPointerFromInternalField(0));
  #endif
      if (sobj == NULL || sobj->size != size) return 0;
      memcpy(ptr, sobj->data, size);
      return sobj->type;
    } else {
      return 0;
    }
  }
  
  SWIGRUNTIME
  int SWIGV8_ConvertPacked(v8::Handle<v8::Value> valRef, void *ptr, size_t sz, swig_type_info *ty) {
    swig_type_info *to = SwigV8Packed_UnpackData(valRef, ptr, sz);
    if (!to) return SWIG_ERROR;
    if (ty) {
      if (to != ty) {
        /* check type cast? */
        swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
        if (!tc) return SWIG_ERROR;
      }
    }
    return SWIG_OK;
  }
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  SWIGRUNTIME void _wrap_SwigV8PackedData_delete(v8::Persistent< v8::Value > object, void *parameter) {
    SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
  SWIGRUNTIME void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
    SwigV8PackedData *cdata = static_cast<SwigV8PackedData *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
  SWIGRUNTIME void _wrap_SwigV8PackedData_delete(v8::Isolate *isolate, v8::Persistent<v8::Object> *object, SwigV8PackedData *cdata) {
  #elif (V8_MAJOR_VERSION-0) < 5
  SWIGRUNTIME void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackData<v8::Object, SwigV8PackedData> &data) {
    v8::Local<v8::Object> object = data.GetValue();
    SwigV8PackedData *cdata = data.GetParameter();
  #else
  SWIGRUNTIME void _wrap_SwigV8PackedData_delete(const v8::WeakCallbackInfo<SwigV8PackedData> &data) {
    SwigV8PackedData *cdata = data.GetParameter();
  #endif
  
    delete cdata;
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
    object.Clear();
    object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    object.Clear();
    object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
    object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
    object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
    object.Clear();
  #endif
  }
  
  SWIGRUNTIME
  v8::Handle<v8::Value> SWIGV8_NewPackedObj(void *data, size_t size, swig_type_info *type) {
    SWIGV8_HANDLESCOPE_ESC();
  
    SwigV8PackedData *cdata = new SwigV8PackedData(data, size, type);
  //  v8::Handle<v8::Object> obj = SWIGV8_OBJECT_NEW();
    v8::Local<v8::Object> obj = SWIGV8_OBJECT_NEW();
  
  #if (V8_MAJOR_VERSION-0) < 5
    obj->SetHiddenValue(SWIGV8_STRING_NEW("__swig__packed_data__"), SWIGV8_BOOLEAN_NEW(true));
  #else
    v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("__swig__packed_data__"));
    obj->SetPrivate(SWIGV8_CURRENT_CONTEXT(), privateKey, SWIGV8_BOOLEAN_NEW(true));
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031511)
    obj->SetPointerInInternalField(0, cdata);
  #else
    obj->SetAlignedPointerInInternalField(0, cdata);
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
    cdata->handle = v8::Persistent<v8::Object>::New(obj);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    cdata->handle = v8::Persistent<v8::Object>::New(v8::Isolate::GetCurrent(), obj);
  #else
    cdata->handle.Reset(v8::Isolate::GetCurrent(), obj);
  #endif
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
    cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031918)
    cdata->handle.MakeWeak(v8::Isolate::GetCurrent(), cdata, _wrap_SwigV8PackedData_delete);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
    cdata->handle.MakeWeak(cdata, _wrap_SwigV8PackedData_delete);
  #elif (V8_MAJOR_VERSION-0) < 5
    cdata->handle.SetWeak(cdata, _wrap_SwigV8PackedData_delete);
  //  v8::V8::SetWeak(&cdata->handle, cdata, _wrap_SwigV8PackedData_delete);
  #else
    cdata->handle.SetWeak(cdata, _wrap_SwigV8PackedData_delete, v8::WeakCallbackType::kParameter);
  #endif
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
    cdata->handle.MarkIndependent();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
    cdata->handle.MarkIndependent(v8::Isolate::GetCurrent());
  #else
    cdata->handle.MarkIndependent();
  #endif
  
    SWIGV8_ESCAPE(obj);
  }
  
  #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIGV8_ConvertPacked(obj, ptr, sz, ty)
  #define SWIG_NewMemberObj(ptr, sz, type)                SWIGV8_NewPackedObj(ptr, sz, type)
  
  
  /* ---------------------------------------------------------------------------
   * Support for IN/OUTPUT typemaps (see Lib/typemaps/inoutlist.swg)
   *
   * ---------------------------------------------------------------------------*/
  
  SWIGRUNTIME
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
  v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Handle<v8::Value> result, v8::Handle<v8::Value> obj) {
  #else
  v8::Handle<v8::Value> SWIGV8_AppendOutput(v8::Local<v8::Value> result, v8::Handle<v8::Value> obj) {
  #endif
    SWIGV8_HANDLESCOPE_ESC();
    
    if (result->IsUndefined()) {
      result = SWIGV8_ARRAY_NEW();
    }
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(result);
  #else  
    v8::Local<v8::Array> arr = v8::Local<v8::Array>::Cast(result);
  #endif
    arr->Set(arr->Length(), obj);
  
    SWIGV8_ESCAPE(arr);
  }
  
  
  
  // Note: since 3.19 there are new CallBack types, since 03.21.9 the old ones have been removed
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
  typedef v8::InvocationCallback  SwigV8FunctionCallback;
  typedef v8::AccessorGetter      SwigV8AccessorGetterCallback;
  typedef v8::AccessorSetter      SwigV8AccessorSetterCallback;
  typedef v8::AccessorInfo        SwigV8PropertyCallbackInfoVoid;
  #elif (V8_MAJOR_VERSION-0) < 5
  typedef v8::FunctionCallback            SwigV8FunctionCallback;
  typedef v8::AccessorGetterCallback      SwigV8AccessorGetterCallback;
  typedef v8::AccessorSetterCallback      SwigV8AccessorSetterCallback;
  typedef v8::PropertyCallbackInfo<void>  SwigV8PropertyCallbackInfoVoid;
  #else
  typedef v8::FunctionCallback            SwigV8FunctionCallback;
  typedef v8::AccessorNameGetterCallback  SwigV8AccessorGetterCallback;
  typedef v8::AccessorNameSetterCallback  SwigV8AccessorSetterCallback;
  typedef v8::PropertyCallbackInfo<void>  SwigV8PropertyCallbackInfoVoid;
  #endif
  
  /**
   * Creates a class template for a class with specified initialization function.
   */
  SWIGRUNTIME v8::Handle<v8::FunctionTemplate> SWIGV8_CreateClassTemplate(const char* symbol) {
      SWIGV8_HANDLESCOPE_ESC();
      
      v8::Local<v8::FunctionTemplate> class_templ = SWIGV8_FUNCTEMPLATE_NEW_VOID();
      class_templ->SetClassName(SWIGV8_SYMBOL_NEW(symbol));
  
      v8::Handle<v8::ObjectTemplate> inst_templ = class_templ->InstanceTemplate();
      inst_templ->SetInternalFieldCount(1);
  
      v8::Handle<v8::ObjectTemplate> equals_templ = class_templ->PrototypeTemplate();
      equals_templ->Set(SWIGV8_SYMBOL_NEW("equals"), SWIGV8_FUNCTEMPLATE_NEW(_SWIGV8_wrap_equals));
  
      v8::Handle<v8::ObjectTemplate> cptr_templ = class_templ->PrototypeTemplate();
      cptr_templ->Set(SWIGV8_SYMBOL_NEW("getCPtr"), SWIGV8_FUNCTEMPLATE_NEW(_wrap_getCPtr));
  
      SWIGV8_ESCAPE(class_templ);
  }
  
  /**
   * Registers a class method with given name for a given class template.
   */
  SWIGRUNTIME void SWIGV8_AddMemberFunction(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
    SwigV8FunctionCallback _func) {
      v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->PrototypeTemplate();
      proto_templ->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func));
  }
  
  /**
   * Registers a class property with given name for a given class template.
   */
  SWIGRUNTIME void SWIGV8_AddMemberVariable(v8::Handle<v8::FunctionTemplate> class_templ, const char* symbol,
    SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
    v8::Handle<v8::ObjectTemplate> proto_templ = class_templ->InstanceTemplate();
    proto_templ->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter);
  }
  
  /**
   * Registers a class method with given name for a given object.
   */
  SWIGRUNTIME void SWIGV8_AddStaticFunction(v8::Handle<v8::Object> obj, const char* symbol,
    const SwigV8FunctionCallback& _func) {
    obj->Set(SWIGV8_SYMBOL_NEW(symbol), SWIGV8_FUNCTEMPLATE_NEW(_func)->GetFunction());
  }
  
  /**
   * Registers a class method with given name for a given object.
   */
  SWIGRUNTIME void SWIGV8_AddStaticVariable(v8::Handle<v8::Object> obj, const char* symbol,
    SwigV8AccessorGetterCallback getter, SwigV8AccessorSetterCallback setter) {
  #if (V8_MAJOR_VERSION-0) < 5
    obj->SetAccessor(SWIGV8_SYMBOL_NEW(symbol), getter, setter);
  #else
    obj->SetAccessor(SWIGV8_CURRENT_CONTEXT(), SWIGV8_SYMBOL_NEW(symbol), getter, setter);
  #endif
  }
  
  #if (V8_MAJOR_VERSION-0) < 5
  SWIGRUNTIME void JS_veto_set_variable(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid& info)
  #else
  SWIGRUNTIME void JS_veto_set_variable(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid& info)
  #endif
  {
      char buffer[256];
      char msg[512];
      int res;
  
  #if (V8_MAJOR_VERSION-0) < 5
      property->WriteUtf8(buffer, 256);
      res = sprintf(msg, "Tried to write read-only variable: %s.", buffer);
  #else
      v8::Local<v8::String> sproperty;
      if (property->ToString(SWIGV8_CURRENT_CONTEXT()).ToLocal(&sproperty)) {
        sproperty->WriteUtf8(buffer, 256);
        res = sprintf(msg, "Tried to write read-only variable: %s.", buffer);
      }
      else {
        res = -1;
      }
  #endif
  
      if(res<0) {
        SWIG_exception(SWIG_ERROR, "Tried to write read-only variable.");
      } else {
        SWIG_exception(SWIG_ERROR, msg);
      }
  fail: ;
  }
  
  
  
  /* -------- TYPES TABLE (BEGIN) -------- */
  
  #define SWIGTYPE_p_ActiveSpeakerDetectorFacade swig_types[0]
  #define SWIGTYPE_p_DTLSICETransport swig_types[1]
  #define SWIGTYPE_p_DTLSICETransportListener swig_types[2]
  #define SWIGTYPE_p_ICERemoteCandidate swig_types[3]
  #define SWIGTYPE_p_LayerInfo swig_types[4]
  #define SWIGTYPE_p_LayerSource swig_types[5]
  #define SWIGTYPE_p_LayerSources swig_types[6]
  #define SWIGTYPE_p_MP4RecorderFacade swig_types[7]
  #define SWIGTYPE_p_MediaFrameListener swig_types[8]
  #define SWIGTYPE_p_MediaServer swig_types[9]
  #define SWIGTYPE_p_PCAPTransportEmulator swig_types[10]
  #define SWIGTYPE_p_PlayerFacade swig_types[11]
  #define SWIGTYPE_p_Properties swig_types[12]
  #define SWIGTYPE_p_PropertiesFacade swig_types[13]
  #define SWIGTYPE_p_RTPBundleTransport swig_types[14]
  #define SWIGTYPE_p_RTPBundleTransportConnection swig_types[15]
  #define SWIGTYPE_p_RTPIncomingMediaStream swig_types[16]
  #define SWIGTYPE_p_RTPIncomingMediaStreamDepacketizer swig_types[17]
  #define SWIGTYPE_p_RTPIncomingMediaStreamListener swig_types[18]
  #define SWIGTYPE_p_RTPIncomingMediaStreamMultiplexer swig_types[19]
  #define SWIGTYPE_p_RTPIncomingSource swig_types[20]
  #define SWIGTYPE_p_RTPIncomingSourceGroup swig_types[21]
  #define SWIGTYPE_p_RTPOutgoingSource swig_types[22]
  #define SWIGTYPE_p_RTPOutgoingSourceGroup swig_types[23]
  #define SWIGTYPE_p_RTPPacket__shared swig_types[24]
  #define SWIGTYPE_p_RTPReceiver swig_types[25]
  #define SWIGTYPE_p_RTPReceiverFacade swig_types[26]
  #define SWIGTYPE_p_RTPSender swig_types[27]
  #define SWIGTYPE_p_RTPSenderFacade swig_types[28]
  #define SWIGTYPE_p_RTPSessionFacade swig_types[29]
  #define SWIGTYPE_p_RTPSource swig_types[30]
  #define SWIGTYPE_p_RTPStreamTransponderFacade swig_types[31]
  #define SWIGTYPE_p_RemoteRateEstimatorListener swig_types[32]
  #define SWIGTYPE_p_SenderSideEstimatorListener swig_types[33]
  #define SWIGTYPE_p_TimeService swig_types[34]
  #define SWIGTYPE_p_UDPDumper swig_types[35]
  #define SWIGTYPE_p_UDPReader swig_types[36]
  #define SWIGTYPE_p_char swig_types[37]
  #define SWIGTYPE_p_int swig_types[38]
  #define SWIGTYPE_p_long_long swig_types[39]
  #define SWIGTYPE_p_short swig_types[40]
  #define SWIGTYPE_p_signed_char swig_types[41]
  #define SWIGTYPE_p_std__string swig_types[42]
  #define SWIGTYPE_p_unsigned_char swig_types[43]
  #define SWIGTYPE_p_unsigned_int swig_types[44]
  #define SWIGTYPE_p_unsigned_long_long swig_types[45]
  #define SWIGTYPE_p_unsigned_short swig_types[46]
  #define SWIGTYPE_p_v8__HandleT_v8__Object_t swig_types[47]
  static swig_type_info *swig_types[49];
  static swig_module_info swig_module = {swig_types, 48, 0, 0, 0, 0};
  #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
  #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
  
  /* -------- TYPES TABLE (END) -------- */
  
  
  
  #define SWIGVERSION 0x040000 
  #define SWIG_VERSION SWIGVERSION
  
  
  #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a)) 
  #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a)) 
  
  
  #include <stdexcept>
  
  
  #include <assert.h>
  
  
  	
  #include <string>
  #include <list>
  #include <functional>
  #include <nan.h>
  #include "../media-server/include/config.h"	
  #include "../media-server/include/dtls.h"
  #include "../media-server/include/OpenSSL.h"
  #include "../media-server/include/media.h"
  #include "../media-server/include/rtp.h"
  #include "../media-server/include/rtpsession.h"
  #include "../media-server/include/DTLSICETransport.h"	
  #include "../media-server/include/RTPBundleTransport.h"
  #include "../media-server/include/PCAPTransportEmulator.h"	
  #include "../media-server/include/mp4recorder.h"
  #include "../media-server/include/mp4streamer.h"
  #include "../media-server/src/vp9/VP9LayerSelector.h"
  #include "../media-server/include/rtp/RTPStreamTransponder.h"
  #include "../media-server/include/rtp/RTPIncomingMediaStreamDepacketizer.h"
  #include "../media-server/include/ActiveSpeakerDetector.h"
  	
  using RTPBundleTransportConnection = RTPBundleTransport::Connection;
  using MediaFrameListener = MediaFrame::Listener;
  
  
  template<typename T>
  struct CopyablePersistentTraits {
  public:
  	typedef Nan::Persistent<T, CopyablePersistentTraits<T> > CopyablePersistent;
  	static const bool kResetInDestructor = true;
  	template<typename S, typename M>
  	static inline void Copy(const Nan::Persistent<S, M> &source, CopyablePersistent *dest) {}
  	template<typename S, typename M>
  	static inline void Copy(const v8::Persistent<S, M>&, v8::Persistent<S, CopyablePersistentTraits<S> >*){}
  };
  
  template<typename T>
  class NonCopyablePersistentTraits { 
  public:
    typedef Nan::Persistent<T, NonCopyablePersistentTraits<T> > NonCopyablePersistent;
    static const bool kResetInDestructor = true;
  
    template<typename S, typename M>
    static void Copy(const Nan::Persistent<S, M> &source, NonCopyablePersistent *dest);
  
    template<typename O> static void Uncompilable();
  };
  
  template<typename T >
  using Persistent = Nan::Persistent<T,NonCopyablePersistentTraits<T>>;
  
  
  bool MakeCallback(const std::shared_ptr<Persistent<v8::Object>>& persistent, const char* name, int argc = 0, v8::Local<v8::Value>* argv = nullptr)
  {
  	Nan::HandleScope scope;
  	//Ensure we have an object
  	if (!persistent)
  		return false;
  	//Get a local reference
  	v8::Local<v8::Object> local = Nan::New(*persistent);
  	//Check it is not empty
  	if (local.IsEmpty())
  		return false;
  	//Get event name
  	auto method = Nan::New(name).ToLocalChecked();
  	//Check it has it
  	if (!local->Has(method))
  		return false;
  	//Create callback function from object
  	v8::Local<v8::Function> callback = v8::Local<v8::Function>::Cast(local->Get(method));
  	//If it is callable
  	if (!callback->IsCallable())
  		return false;
  	//Call object method with arguments
  	Nan::MakeCallback(local, callback, argc, argv);
  	
  	//Done 
  	return true;
  }
  		
  			
  class PropertiesFacade : private Properties
  {
  public:
  	void SetPropertyInt(const char* key,int intval)
  	{
  		Properties::SetProperty(key,intval);
  	}
  	void SetPropertyStr(const char* key,const char* val)
  	{
  		Properties::SetProperty(key,val);
  	}
  	void SetPropertyBool(const char* key,bool boolval)
  	{
  		Properties::SetProperty(key,boolval);
  	}
  };
  
  
  
  class MediaServer
  {
  public:
  	typedef std::list<v8::Local<v8::Value>> Arguments;
  public:
  		
  	~MediaServer()
  	{
  		Terminate();
  	}
  	
  	/*
  	 * Async
  	 *  Enqueus a function to the async queue and signals main thread to execute it
  	 */
  	static void Async(std::function<void()> func) 
  	{
  		//Lock
  		mutex.Lock();
  		//Check if not terminatd
  		if (uv_is_active((uv_handle_t *)&async))
  		{
  			//Enqueue
  			queue.push_back(func);
  			//Signal main thread
  			uv_async_send(&async);
  		}
  		//Unlock
  		mutex.Unlock();
  	}
  
  	static void Initialize()
  	{
  		Debug("-MediaServer::Initialize\n");
  		//Initialize ssl
  		OpenSSL::ClassInit();
  		
  		//Start DTLS
  		DTLSConnection::Initialize();
  		
  		//Init async handler
  		uv_async_init(uv_default_loop(), &async, async_cb_handler);
  	}
  	
  	static void Terminate()
  	{
  		Debug("-MediaServer::Terminate\n");
  		//Lock
  		mutex.Lock();
  		//empty queue
  		queue.clear();
  		//Close handle
  		uv_close((uv_handle_t *)&async, NULL);
  		//Unlock
  		mutex.Unlock();
  	}
  	
  	static void EnableLog(bool flag)
  	{
  		//Enable log
  		Logger::EnableLog(flag);
  	}
  	
  	static void EnableDebug(bool flag)
  	{
  		//Enable debug
  		Logger::EnableDebug(flag);
  	}
  	
  	static void EnableUltraDebug(bool flag)
  	{
  		//Enable debug
  		Logger::EnableUltraDebug(flag);
  	}
  	
  	static bool SetPortRange(int minPort, int maxPort)
  	{
  		return RTPTransport::SetPortRange(minPort,maxPort);
  	}
  	
  	static bool SetCertificate(const char* cert,const char* key)
  	{
  		//Stop TLS
  		DTLSConnection::Terminate();
  		//Set new certificates
  		DTLSConnection::SetCertificate(cert,key);
  		//Start DTLS
  		return DTLSConnection::Initialize();
  	}
  	
  	static std::string GetFingerprint()
  	{
  		return DTLSConnection::GetCertificateFingerPrint(DTLSConnection::Hash::SHA256);
  	}
  
  	static void async_cb_handler(uv_async_t *handle)
  	{
  		//Lock
  		mutex.Lock();
  		//Get all
  		while(!queue.empty())
  		{
  			//Get from queue
  			auto func = queue.front();
  			//Remove from queue
  			queue.pop_front();
  			//Unlock
  			mutex.Unlock();
  			//Execute async function
  			func();
  			//Lock
  			mutex.Lock();
  		}
  		//Unlock
  		mutex.Unlock();
  	}
  private:
  	//http://stackoverflow.com/questions/31207454/v8-multithreaded-function
  	static uv_async_t  async;
  	static Mutex mutex;
  	static std::list<std::function<void()>> queue;
  };
  
  //Static initializaion
  uv_async_t MediaServer::async;
  Mutex MediaServer::mutex;
  std::list<std::function<void()>>  MediaServer::queue;
  
  class RTPSessionFacade : 	
  	public RTPSender,
  	public RTPReceiver,
  	public RTPSession
  {
  public:
  	RTPSessionFacade(MediaFrame::Type media) : RTPSession(media,NULL)
  	{
  		//Delegate to group
  		delegate = true;
  		//Start group dispatch
  		GetIncomingSourceGroup()->Start();
  	}
  	virtual ~RTPSessionFacade() = default;
  	//TODO: Make async
  	virtual int Enqueue(const RTPPacket::shared& packet)  { return SendPacket(packet); }
  	virtual int Enqueue(const RTPPacket::shared& packet,std::function<RTPPacket::shared(const RTPPacket::shared&)> modifier) { return SendPacket(modifier(packet)); }
  	virtual int SendPLI(DWORD ssrc)				 { return RequestFPU();}
  	
  	int Init(const Properties &properties)
  	{
  		RTPMap rtp;
  		RTPMap apt;
  		
  		//Get codecs
  		std::vector<Properties> codecs;
  		properties.GetChildrenArray("codecs",codecs);
  
  		//For each codec
  		for (auto it = codecs.begin(); it!=codecs.end(); ++it)
  		{
  			
  			BYTE codec = (BYTE)-1;
  			//Depending on the type
  			switch (GetMediaType())
  			{
  				case MediaFrame::Audio:
  					codec = (BYTE)AudioCodec::GetCodecForName(it->GetProperty("codec"));
  					break;
  				case MediaFrame::Video:
  					codec = (BYTE)VideoCodec::GetCodecForName(it->GetProperty("codec"));
  					break;
  				default:
  					//Skip
  					continue;
  			}
  			//If not found
  			if (codec == (BYTE)-1)
  				//Skip
  				continue;
  			//Get codec type
  			BYTE type = it->GetProperty("pt",0);
  			//ADD it
  			rtp[type] = codec;
  		}
  	
  		//Set local 
  		RTPSession::SetSendingRTPMap(rtp,apt);
  		RTPSession::SetReceivingRTPMap(rtp,apt);
  		
  		//Set properties
  		RTPSession::SetProperties(properties.GetChildren("properties"));
  		
  		//Call parent
  		return RTPSession::Init();
  	}
  };
  
  class MP4RecorderFacade :
  	public MP4Recorder,
  	public MP4Recorder::Listener
  {
  public:
  	MP4RecorderFacade(v8::Handle<v8::Object> object) :
  		MP4Recorder(this)
  	{
  		persistent = std::make_shared<Persistent<v8::Object>>(object);
  	}
  
  	void onFirstFrame(QWORD time) override
  	{
  		//Run function on main node thread
  		MediaServer::Async([=,cloned=persistent](){
  			Nan::HandleScope scope;
  			int i = 0;
  			v8::Local<v8::Value> argv[1];
  			//Create local args
  			argv[i++] = Nan::New<v8::Uint32>((uint32_t)time);
  			//Call object method with arguments
  			MakeCallback(cloned, "onstarted", i, argv);
  		});
  	}
  	void onClosed() override 
  	{
  		//Run function on main node thread
  		MediaServer::Async([=,cloned=persistent](){
  			Nan::HandleScope scope;
  			int i = 0;
  			v8::Local<v8::Value> argv[0];
  			//Call object method with arguments
  			MakeCallback(cloned, "onclosed", i, argv);
  		});
  	}
  private:
  	std::shared_ptr<Persistent<v8::Object>> persistent;
  };
  
  class PlayerFacade :
  	public MP4Streamer,
  	public MP4Streamer::Listener
  {
  public:
  	PlayerFacade(v8::Handle<v8::Object> object) :
  		MP4Streamer(this),
  		audio(MediaFrame::Audio,loop),
  		video(MediaFrame::Video,loop)
  	{
  		persistent = std::make_shared<Persistent<v8::Object>>(object);
  		Reset();
  		//Start dispatching
  		audio.Start();
  		video.Start();
  	}
  		
  	virtual void onRTPPacket(RTPPacket &packet)
  	{
  		//Clone packet
  		auto cloned = packet.Clone();
  		//Copy payload
  		cloned->AdquireMediaData();
  		//Check media type
  		switch(cloned->GetMediaType())
  		{
  			case MediaFrame::Video:
  				//Update stats
  				video.media.Update(getTimeMS(),cloned->GetSeqNum(),cloned->GetRTPHeader().GetSize()+cloned->GetMediaLength());
  				//Set ssrc of video
  				cloned->SetSSRC(video.media.ssrc);
  				//Multiplex
  				video.AddPacket(cloned,0);
  				break;
  			case MediaFrame::Audio:
  				//Update stats
  				audio.media.Update(getTimeMS(),cloned->GetSeqNum(),cloned->GetRTPHeader().GetSize()+cloned->GetMediaLength());
  				//Set ssrc of audio
  				cloned->SetSSRC(audio.media.ssrc);
  				//Multiplex
  				audio.AddPacket(cloned,0);
  				break;
  			default:
  				///Ignore
  				return;
  		}
  	}
  
  	virtual void onTextFrame(TextFrame &frame) {}
  	virtual void onEnd() 
  	{
  		//Run function on main node thread
  		MediaServer::Async([=,cloned=persistent](){
  			//Call object method with arguments
  			MakeCallback(cloned, "onended");
  		});
  	}
  	
  	void Reset() 
  	{
  		audio.media.Reset();
  		video.media.Reset();
  		audio.media.ssrc = rand();
  		video.media.ssrc = rand();
  	}
  	
  	virtual void onMediaFrame(const MediaFrame &frame)  {}
  	virtual void onMediaFrame(DWORD ssrc, const MediaFrame &frame) {}
  
  	RTPIncomingMediaStream* GetAudioSource() { return &audio; }
  	RTPIncomingMediaStream* GetVideoSource() { return &video; }
  	
  private:
  	std::shared_ptr<Persistent<v8::Object>> persistent;	
  	//TODO: Update to multitrack
  	RTPIncomingSourceGroup audio;
  	RTPIncomingSourceGroup video;
  };
  
  class RTPSenderFacade
  {
  public:	
  	RTPSenderFacade(DTLSICETransport* transport)
  	{
  		sender = transport;
  	}
  
  	RTPSenderFacade(RTPSessionFacade* session)
  	{
  		sender = session;
  	}
  	
  	RTPSender* get() { return sender;}
  private:
  	RTPSender* sender;
  };
  
  class RTPReceiverFacade
  {
  public:	
  	RTPReceiverFacade(DTLSICETransport* transport)
  	{
  		receiver = transport;
  	}
  
  	RTPReceiverFacade(RTPSessionFacade* session)
  	{
  		receiver = session;
  	}
  	
  	RTPReceiverFacade(PCAPTransportEmulator *transport)
  	{
  		receiver = transport;
  	}
  	
  	int SendPLI(DWORD ssrc)
  	{
  		return receiver ? receiver->SendPLI(ssrc) : 0;
  	}
  	
  	RTPReceiver* get() { return receiver;}
  private:
  	RTPReceiver* receiver;
  };
  
  
  RTPSenderFacade* TransportToSender(DTLSICETransport* transport)
  {
  	return new RTPSenderFacade(transport);
  }
  RTPReceiverFacade* TransportToReceiver(DTLSICETransport* transport)
  {
  	return new RTPReceiverFacade(transport);
  }
  
  RTPReceiverFacade* PCAPTransportEmulatorToReceiver(PCAPTransportEmulator* transport)
  {
  	return new RTPReceiverFacade(transport);
  }
  
  RTPSenderFacade* SessionToSender(RTPSessionFacade* session)
  {
  	return new RTPSenderFacade(session);	
  }
  RTPReceiverFacade* SessionToReceiver(RTPSessionFacade* session)
  {
  	return new RTPReceiverFacade(session);
  }
  
  class RTPStreamTransponderFacade : 
  	public RTPStreamTransponder
  {
  public:
  	RTPStreamTransponderFacade(RTPOutgoingSourceGroup* outgoing,RTPSenderFacade* sender, v8::Handle<v8::Object> object) :
  		RTPStreamTransponder(outgoing, sender ? sender->get() : NULL)
  	{
  		persistent = std::make_shared<Persistent<v8::Object>>(object);
  	}
  
  	virtual ~RTPStreamTransponderFacade() = default;
  
  	bool SetIncoming(RTPIncomingMediaStream* incoming, RTPReceiverFacade* receiver)
  	{
  		return RTPStreamTransponder::SetIncoming(incoming, receiver ? receiver->get() : NULL);
  	}
  	
  	bool SetIncoming(RTPIncomingMediaStream* incoming, RTPReceiver* receiver)
  	{
  		return RTPStreamTransponder::SetIncoming(incoming, receiver);
  	}
  	
  	virtual void onREMB(RTPOutgoingSourceGroup* group,DWORD ssrc, DWORD bitrate) override
  	{
  		//Check we have not send an update too recently (1s)
  		if (getTimeDiff(last)/1000<period)
  			//Do nothing
  			return;
  		
  		//Update it
  		last = getTime();
  		
  		//Run function on main node thread
  		MediaServer::Async([=,cloned=persistent](){
  			Nan::HandleScope scope;
  			int i = 0;
  			v8::Local<v8::Value> argv[1];
  			//Create local args
  			argv[i++] = Nan::New<v8::Uint32>(bitrate);
  			//Call object method with arguments
  			MakeCallback(cloned, "onremb", i, argv);
  		});
  	}
  	
  	void SetMinPeriod(DWORD period) { this->period = period; }
  	
  private:
  	DWORD period	= 1000;
  	QWORD last	= 0;
  	std::shared_ptr<Persistent<v8::Object>> persistent;	
  };
  
  class DTLSICETransportListener :
  	public DTLSICETransport::Listener
  {
  public:
  	DTLSICETransportListener(v8::Handle<v8::Object> object)
  	{
  		persistent = std::make_shared<Persistent<v8::Object>>(object);
  	}
  		
  	virtual ~DTLSICETransportListener() = default;
  	
  	virtual void onRemoteICECandidateActivated(const std::string& ip, uint16_t port, uint32_t priority) override
  	{
  		//Run function on main node thread
  		MediaServer::Async([=,cloned=persistent](){
  			Nan::HandleScope scope;
  			int i = 0;
  			v8::Local<v8::Value> argv[3];
  			//Create local args
  			argv[i++] = Nan::New(ip).ToLocalChecked();
  			argv[i++] = Nan::New<v8::Uint32>(port);
  			argv[i++] = Nan::New<v8::Uint32>(priority);
  			//Call object method with arguments
  			MakeCallback(cloned, "onremoteicecandidate", i, argv);
  		});
  	}
  	
  	virtual void onDTLSStateChanged(const DTLSICETransport::DTLSState state) override 
  	{
  		//Run function on main node thread
  		MediaServer::Async([=,cloned=persistent](){
  			Nan::HandleScope scope;
  			int i = 0;
  			v8::Local<v8::Value> argv[1];
  			
  			switch(state)
  			{
  				case DTLSICETransport::DTLSState::New:
  					//Create local args
  					argv[i++] = Nan::New("new").ToLocalChecked();
  					break;
  				case DTLSICETransport::DTLSState::Connecting:
  					//Create local args
  					argv[i++] = Nan::New("connecting").ToLocalChecked();
  					break;
  				case DTLSICETransport::DTLSState::Connected:
  					//Create local args
  					argv[i++] = Nan::New("connected").ToLocalChecked();
  					break;
  				case DTLSICETransport::DTLSState::Closed:
  					//Create local args
  					argv[i++] = Nan::New("closed").ToLocalChecked();
  					break;
  				case DTLSICETransport::DTLSState::Failed:
  					//Create local args
  					argv[i++] = Nan::New("failed").ToLocalChecked();
  					break;
  			}
  			//Call method
  			MakeCallback(cloned,"ondtlsstate",i,argv);
  		});
  	}
  	
  	virtual void onICETimeout() override 
  	{
  		//Run function on main node thread
  		MediaServer::Async([=,cloned=persistent](){
  			Nan::HandleScope scope;
  			//Call object method with arguments
  			MakeCallback(cloned, "onicetimeout");
  		});
  	}
  
  private:
  	std::shared_ptr<Persistent<v8::Object>> persistent;
  };
  
  class SenderSideEstimatorListener : 
  	public RemoteRateEstimator::Listener
  {
  public:
  	SenderSideEstimatorListener(v8::Handle<v8::Object> object)
  	{
  		persistent = std::make_shared<Persistent<v8::Object>>(object);
  	}
  	
  	virtual void onTargetBitrateRequested(DWORD bitrate) override 
  	{
  		//Run function on main node thread
  		MediaServer::Async([=,cloned=persistent](){
  			Nan::HandleScope scope;
  			int i = 0;
  			v8::Local<v8::Value> argv[1];
  			//Create local args
  			argv[i++] = Nan::New<v8::Uint32>(bitrate);
  			//Call object method with arguments
  			MakeCallback(cloned, "ontargetbitrate", i, argv);
  		
  		});
  	}
  private:
  	std::shared_ptr<Persistent<v8::Object>> persistent;
  };
  
  //Empty implementation of event source
  EvenSource::EvenSource()
  {
  }
  
  EvenSource::EvenSource(const char* str)
  {
  }
  
  EvenSource::EvenSource(const std::wstring &str)
  {
  }
  
  EvenSource::~EvenSource()
  {
  }
  
  void EvenSource::SendEvent(const char* type,const char* msg,...)
  {
  }
  
  class LayerSources : public std::vector<LayerSource*>
  {
  public:
  	size_t size() const		{ return std::vector<LayerSource*>::size(); }
  	LayerSource* get(size_t i)	{ return  std::vector<LayerSource*>::at(i); }
  };
  
  class ActiveSpeakerDetectorFacade :
  	public ActiveSpeakerDetector,
  	public ActiveSpeakerDetector::Listener,
  	public RTPIncomingMediaStream::Listener
  {
  public:	
  	ActiveSpeakerDetectorFacade(v8::Handle<v8::Object> object) :
  		ActiveSpeakerDetector(this)
  	{
  		persistent = std::make_shared<Persistent<v8::Object>>(object);
  	};
  		
  	virtual void onActiveSpeakerChanded(uint32_t id) override
  	{
  		UltraDebug("-ActiveSpeakerDetectorFacade::onActiveSpeakerChanded() [id:%d]\n",id);
  		//Run function on main node thread
  		MediaServer::Async([=,cloned=persistent](){
  			Nan::HandleScope scope;
  			int i = 0;
  			v8::Local<v8::Value> argv[1];
  			//Create local args
  			argv[i++] = Nan::New<v8::Uint32>(id);
  			//Call object method with arguments
  			MakeCallback(cloned, "onactivespeakerchanged", i, argv);
  		});
  	}
  	
  	void AddIncomingSourceGroup(RTPIncomingMediaStream* incoming, uint32_t id)
  	{
  		Debug("-ActiveSpeakerDetectorFacade::AddIncomingSourceGroup() [incoming:%p,id:%d]\n",incoming,id);
  		
  		if (incoming)
  		{
  			ScopedLock lock(mutex);
  			//Insert new 
  			auto [it,inserted] = sources.try_emplace(incoming,id);
  			//If already present
  			if (!inserted)
  				//do nothing
  				return;
  			//Add us as rtp listeners
  			incoming->AddListener(this);
  			//initialize to silence
  			ActiveSpeakerDetector::Accumulate(id, false, 127, getTimeMS());
  		}
  	}
  	
  	void RemoveIncomingSourceGroup(RTPIncomingMediaStream* incoming)
  	{
  		Debug("-ActiveSpeakerDetectorFacade::RemoveIncomingSourceGroup() [incoming:%p]\n",incoming);
  		
  		if (incoming)
  		{	
  			ScopedLock lock(mutex);
  			//Get map
  			auto it = sources.find(incoming);
  			//check it was present
  			if (it==sources.end())
  				//Do nothing, probably called onEnded before
  				return;
  			//Remove listener
  			incoming->RemoveListener(this);
  			//RElease id
  			ActiveSpeakerDetector::Release(it->second);
  			//Erase
  			sources.erase(it);
  		}
  	}
  	
  	virtual void onRTP(RTPIncomingMediaStream* incoming,const RTPPacket::shared& packet) override
  	{
  		if (packet->HasAudioLevel())
  		{
  			ScopedLock lock(mutex);
  			//Get map
  			auto it = sources.find(incoming);
  			//check it was present
  			if (it==sources.end())
  				//Do nothing
  				return;
  			//Accumulate on id
  			ActiveSpeakerDetector::Accumulate(it->second, packet->GetVAD(),packet->GetLevel(), getTimeMS());
  		}
  	}
  	
  	virtual void onBye(RTPIncomingMediaStream* group) 
  	{
  	}
  	
  	virtual void onEnded(RTPIncomingMediaStream* incoming) override
  	{
  		Debug("-ActiveSpeakerDetectorFacade::onEnded() [incoming:%p]\n",incoming);
  		
  		if (incoming)
  		{	
  			ScopedLock lock(mutex);
  			//Get map
  			auto it = sources.find(incoming);
  			//check it was present
  			if (it==sources.end())
  				//Do nothing
  				return;
  			//Release id
  			ActiveSpeakerDetector::Release(it->second);
  			//Erase
  			sources.erase(it);
  		}
  	}
  private:
  	Mutex mutex;
  	std::map<RTPIncomingMediaStream*,uint32_t> sources;
  	std::shared_ptr<Persistent<v8::Object>> persistent;
  };
  
  
  
  #include <stdint.h>		// Use the C99 official header
  
  
  #include <string>
  
  
  #include <typeinfo>
  #include <stdexcept>
  
  
  #include <vector>
  #include <stdexcept>
  
  
  using MediaFrameType = MediaFrame::Type;
  
  
  #include <limits.h>
  #if !defined(SWIG_NO_LLONG_MAX)
  # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
  #   define LLONG_MAX __LONG_LONG_MAX__
  #   define LLONG_MIN (-LLONG_MAX - 1LL)
  #   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
  # endif
  #endif
  
  
  SWIGINTERN
  int SWIG_AsVal_double (v8::Handle<v8::Value> obj, double *val)
  {
    if(!obj->IsNumber()) {
      return SWIG_TypeError;
    }
    if(val) *val = obj->NumberValue();
  
    return SWIG_OK;
  }
  
  
  #include <float.h>
  
  
  #include <math.h>
  
  
  SWIGINTERNINLINE int
  SWIG_CanCastAsInteger(double *d, double min, double max) {
    double x = *d;
    if ((min <= x && x <= max)) {
     double fx = floor(x);
     double cx = ceil(x);
     double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
     if ((errno == EDOM) || (errno == ERANGE)) {
       errno = 0;
     } else {
       double summ, reps, diff;
       if (rd < x) {
         diff = x - rd;
       } else if (rd > x) {
         diff = rd - x;
       } else {
         return 1;
       }
       summ = rd + x;
       reps = diff/summ;
       if (reps < 8*DBL_EPSILON) {
         *d = rd;
         return 1;
       }
     }
    }
    return 0;
  }
  
  
  SWIGINTERN
  int SWIG_AsVal_unsigned_SS_long (v8::Handle<v8::Value> obj, unsigned long *val)
  {
    if(!obj->IsNumber()) {
      return SWIG_TypeError;
    }
  
    long longVal = (long) obj->NumberValue();
  
    if(longVal < 0) {
        return SWIG_OverflowError;
    }
  
    if(val) *val = longVal;
  
    return SWIG_OK;
  }
  
  
  SWIGINTERN int
  SWIG_AsVal_unsigned_SS_char (v8::Handle<v8::Value> obj, unsigned char *val)
  {
    unsigned long v;
    int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
    if (SWIG_IsOK(res)) {
      if ((v > UCHAR_MAX)) {
        return SWIG_OverflowError;
      } else {
        if (val) *val = static_cast< unsigned char >(v);
      }
    }  
    return res;
  }
  
  
  SWIGINTERNINLINE
  v8::Handle<v8::Value> SWIG_From_long  (long value)
  {
    return SWIGV8_NUMBER_NEW(value);
  }
  
  
  SWIGINTERNINLINE
  v8::Handle<v8::Value> SWIG_From_unsigned_SS_long  (unsigned long value)
  {
    return SWIGV8_INTEGER_NEW_UNS(value);
  }
  
  
  SWIGINTERNINLINE v8::Handle<v8::Value>
  SWIG_From_unsigned_SS_char  (unsigned char value)
  {    
    return SWIG_From_unsigned_SS_long  (value);
  }
  
  
  SWIGINTERN int
  SWIG_AsVal_unsigned_SS_int (v8::Handle<v8::Value> obj, unsigned int *val)
  {
    unsigned long v;
    int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
    if (SWIG_IsOK(res)) {
      if ((v > UINT_MAX)) {
        return SWIG_OverflowError;
      } else {
        if (val) *val = static_cast< unsigned int >(v);
      }
    }  
    return res;
  }
  
  
  SWIGINTERNINLINE v8::Handle<v8::Value>
  SWIG_From_unsigned_SS_int  (unsigned int value)
  {    
    return SWIG_From_unsigned_SS_long  (value);
  }
  
  
  #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
  #  define SWIG_LONG_LONG_AVAILABLE
  #endif
  
  
  #ifdef SWIG_LONG_LONG_AVAILABLE
  SWIGINTERNINLINE
  v8::Handle<v8::Value> SWIG_From_long_SS_long  (long long value)
  {
    return SWIGV8_NUMBER_NEW(value);
  }
  #endif
  
  
  #ifdef SWIG_LONG_LONG_AVAILABLE
  SWIGINTERNINLINE
  v8::Handle<v8::Value> SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
  {
      return SWIGV8_INTEGER_NEW_UNS(value);
  }
  #endif
  
  
  SWIGINTERNINLINE v8::Handle<v8::Value>
  SWIG_From_size_t  (size_t value)
  {    
  #ifdef SWIG_LONG_LONG_AVAILABLE
    if (sizeof(size_t) <= sizeof(unsigned long)) {
  #endif
      return SWIG_From_unsigned_SS_long  (static_cast< unsigned long >(value));
  #ifdef SWIG_LONG_LONG_AVAILABLE
    } else {
      /* assume sizeof(size_t) <= sizeof(unsigned long long) */
      return SWIG_From_unsigned_SS_long_SS_long  (static_cast< unsigned long long >(value));
    }
  #endif
  }
  
  
  #ifdef SWIG_LONG_LONG_AVAILABLE
  SWIGINTERN
  int SWIG_AsVal_unsigned_SS_long_SS_long (v8::Handle<v8::Value> obj, unsigned long long *val)
  {
    if(!obj->IsNumber()) {
      return SWIG_TypeError;
    }
  
    long long longVal = (long long) obj->NumberValue();
  
    if(longVal < 0) {
        return SWIG_OverflowError;
    }
  
    if(val) *val = longVal;
  
    return SWIG_OK;
  }
  #endif
  
  
  SWIGINTERNINLINE int
  SWIG_AsVal_size_t (v8::Handle<v8::Value> obj, size_t *val)
  {
    int res = SWIG_TypeError;
  #ifdef SWIG_LONG_LONG_AVAILABLE
    if (sizeof(size_t) <= sizeof(unsigned long)) {
  #endif
      unsigned long v;
      res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
      if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
  #ifdef SWIG_LONG_LONG_AVAILABLE
    } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
      unsigned long long v;
      res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
      if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
    }
  #endif
    return res;
  }
  
  
  SWIGINTERN
  int SWIG_AsVal_long (v8::Handle<v8::Value> obj, long* val)
  {
    if (!obj->IsNumber()) {
      return SWIG_TypeError;
    }
    if(val) *val = (long) obj->IntegerValue();
  
    return SWIG_OK;
  }
  
  
  #ifdef SWIG_LONG_LONG_AVAILABLE
  SWIGINTERN
  int SWIG_AsVal_long_SS_long (v8::Handle<v8::Value> obj, long long* val)
  {
    if (!obj->IsNumber()) {
      return SWIG_TypeError;
    }
    if(val) *val = (long long) obj->IntegerValue();
  
    return SWIG_OK;
  }
  #endif
  
  
  SWIGINTERN
  v8::Handle<v8::Value> SWIG_From_double   (double val)
  {
    return SWIGV8_NUMBER_NEW(val);
  }
  
  SWIGINTERN LayerSources RTPIncomingSource_layers(RTPIncomingSource *self){
  			LayerSources layers;
  			for(auto it = self->layers.begin(); it != self->layers.end(); ++it )
  				layers.push_back(&(it->second));
  			return layers;
  		}
  
  SWIGINTERN
  int SWIG_AsVal_int (v8::Handle<v8::Value> valRef, int* val)
  {
    if (!valRef->IsNumber()) {
      return SWIG_TypeError;
    }
    if(val) *val = valRef->IntegerValue();
  
    return SWIG_OK;
  }
  
  
  SWIGINTERNINLINE
  v8::Handle<v8::Value> SWIG_From_int  (int value)
  {
    return SWIGV8_INT32_NEW(value);
  }
  
  
  using RTPIncomingMediaStreamListener = RTPIncomingMediaStream::Listener;
  
  
  SWIGINTERN swig_type_info*
  SWIG_pchar_descriptor(void)
  {
    static int init = 0;
    static swig_type_info* info = 0;
    if (!init) {
      info = SWIG_TypeQuery("_p_char");
      init = 1;
    }
    return info;
  }
  
  
  SWIGINTERN int
  SWIG_AsCharPtrAndSize(v8::Handle<v8::Value> valRef, char** cptr, size_t* psize, int *alloc)
  {
    if(valRef->IsString()) {
      v8::Handle<v8::String> js_str = valRef->ToString();
  
      size_t len = js_str->Utf8Length() + 1;
      char* cstr = new char[len];
      js_str->WriteUtf8(cstr, len);
      
      if(alloc) *alloc = SWIG_NEWOBJ;
      if(psize) *psize = len;
      if(cptr) *cptr = cstr;
      
      return SWIG_OK;
    } else {
      if(valRef->IsObject()) {
        v8::Handle<v8::Object> obj = valRef->ToObject();
        // try if the object is a wrapped char[]
        swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
        if (pchar_descriptor) {
          void* vptr = 0;
          if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
            if (cptr) *cptr = (char *) vptr;
            if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
            if (alloc) *alloc = SWIG_OLDOBJ;
            return SWIG_OK;
          }
        }
        return SWIG_TypeError;
      } else {
        return SWIG_TypeError;
      }
    }
  }
  
  
  SWIGINTERN int
  SWIG_AsPtr_std_string (v8::Handle<v8::Value> obj, std::string **val) 
  {
    char* buf = 0 ; size_t size = 0; int alloc = SWIG_OLDOBJ;
    if (SWIG_IsOK((SWIG_AsCharPtrAndSize(obj, &buf, &size, &alloc)))) {
      if (buf) {
        if (val) *val = new std::string(buf, size - 1);
        if (alloc == SWIG_NEWOBJ) delete[] buf;
        return SWIG_NEWOBJ;
      } else {
        if (val) *val = 0;
        return SWIG_OLDOBJ;
      }
    } else {
      static int init = 0;
      static swig_type_info* descriptor = 0;
      if (!init) {
        descriptor = SWIG_TypeQuery("std::string" " *");
        init = 1;
      }
      if (descriptor) {
        std::string *vptr;
        int res = SWIG_ConvertPtr(obj, (void**)&vptr, descriptor, 0);
        if (SWIG_IsOK(res) && val) *val = vptr;
        return res;
      }
    }
    return SWIG_ERROR;
  }
  
  
  SWIGINTERNINLINE v8::Handle<v8::Value>
  SWIG_FromCharPtrAndSize(const char* carray, size_t size)
  {
    if (carray) {
      if (size > INT_MAX) {
        // TODO: handle extra long strings
        return SWIGV8_UNDEFINED();
      } else {
        v8::Handle<v8::String> js_str = SWIGV8_STRING_NEW2(carray, size);
        return js_str;
      }
    } else {
      return SWIGV8_UNDEFINED();
    }
  }
  
  
  SWIGINTERNINLINE v8::Handle<v8::Value>
  SWIG_From_std_string  (const std::string& s)
  {
    return SWIG_FromCharPtrAndSize(s.data(), s.size());
  }
  
  
  
  
  
  SWIGINTERN
  int SWIG_AsVal_bool (v8::Handle<v8::Value> obj, bool *val)
  {
    if(!obj->IsBoolean()) {
      return SWIG_ERROR;
    }
  
    if (val) *val = obj->BooleanValue();
    return SWIG_OK;
  }
  
  
  SWIGINTERNINLINE
  v8::Handle<v8::Value>
  SWIG_From_bool  (bool value)
  {
    return SWIGV8_BOOLEAN_NEW(value);
  }
  
  
  SWIGINTERN int
  SWIG_AsVal_unsigned_SS_short (v8::Handle<v8::Value> obj, unsigned short *val)
  {
    unsigned long v;
    int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
    if (SWIG_IsOK(res)) {
      if ((v > USHRT_MAX)) {
        return SWIG_OverflowError;
      } else {
        if (val) *val = static_cast< unsigned short >(v);
      }
    }  
    return res;
  }
  
  
  using RemoteRateEstimatorListener = RemoteRateEstimator::Listener;
  
  
  SWIGINTERNINLINE v8::Handle<v8::Value> 
  SWIG_FromCharPtr(const char *cptr)
  { 
    return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
  }
  
  
  #define SWIGV8_INIT medooze_initialize
  
  
  SWIGV8_ClientData _exports_LayerInfo_clientData;
  SWIGV8_ClientData _exports_LayerSource_clientData;
  SWIGV8_ClientData _exports_LayerSources_clientData;
  SWIGV8_ClientData _exports_RTPSource_clientData;
  SWIGV8_ClientData _exports_RTPIncomingSource_clientData;
  SWIGV8_ClientData _exports_RTPOutgoingSource_clientData;
  SWIGV8_ClientData _exports_TimeService_clientData;
  SWIGV8_ClientData _exports_RTPOutgoingSourceGroup_clientData;
  SWIGV8_ClientData _exports_RTPSender_clientData;
  SWIGV8_ClientData _exports_RTPReceiver_clientData;
  SWIGV8_ClientData _exports_RTPIncomingMediaStreamListener_clientData;
  SWIGV8_ClientData _exports_RTPIncomingMediaStream_clientData;
  SWIGV8_ClientData _exports_RTPIncomingSourceGroup_clientData;
  SWIGV8_ClientData _exports_RTPIncomingMediaStreamMultiplexer_clientData;
  SWIGV8_ClientData _exports_PropertiesFacade_clientData;
  SWIGV8_ClientData _exports_MediaServer_clientData;
  SWIGV8_ClientData _exports_RTPBundleTransportConnection_clientData;
  SWIGV8_ClientData _exports_RTPBundleTransport_clientData;
  SWIGV8_ClientData _exports_UDPReader_clientData;
  SWIGV8_ClientData _exports_PCAPTransportEmulator_clientData;
  SWIGV8_ClientData _exports_DTLSICETransportListener_clientData;
  SWIGV8_ClientData _exports_RemoteRateEstimatorListener_clientData;
  SWIGV8_ClientData _exports_DTLSICETransport_clientData;
  SWIGV8_ClientData _exports_RTPSessionFacade_clientData;
  SWIGV8_ClientData _exports_RTPSenderFacade_clientData;
  SWIGV8_ClientData _exports_RTPReceiverFacade_clientData;
  SWIGV8_ClientData _exports_RTPStreamTransponderFacade_clientData;
  SWIGV8_ClientData _exports_MediaFrameListener_clientData;
  SWIGV8_ClientData _exports_RTPIncomingMediaStreamDepacketizer_clientData;
  SWIGV8_ClientData _exports_MP4RecorderFacade_clientData;
  SWIGV8_ClientData _exports_PlayerFacade_clientData;
  SWIGV8_ClientData _exports_SenderSideEstimatorListener_clientData;
  SWIGV8_ClientData _exports_ActiveSpeakerDetectorFacade_clientData;
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_LayerInfo_MaxLayerId_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_LayerInfo_MaxLayerId_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      uint8_t arg1 ;
      unsigned char val1 ;
      int ecode1 = 0 ;
      
      ecode1 = SWIG_AsVal_unsigned_SS_char(value, &val1);
      if (!SWIG_IsOK(ecode1)) {
        SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "LayerInfo_MaxLayerId_set" "', argument " "1"" of type '" "uint8_t""'");
      } 
      arg1 = static_cast< uint8_t >(val1);
      LayerInfo::MaxLayerId = arg1;
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_LayerInfo_MaxLayerId_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_LayerInfo_MaxLayerId_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      uint8_t result;
      
      result = (uint8_t)LayerInfo::MaxLayerId;
      jsresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_LayerInfo_temporalLayerId_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_LayerInfo_temporalLayerId_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      LayerInfo *arg1 = (LayerInfo *) 0 ;
      uint8_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned char val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerInfo, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerInfo_temporalLayerId_set" "', argument " "1"" of type '" "LayerInfo *""'"); 
      }
      arg1 = reinterpret_cast< LayerInfo * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_char(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerInfo_temporalLayerId_set" "', argument " "2"" of type '" "uint8_t""'");
      } 
      arg2 = static_cast< uint8_t >(val2);
      if (arg1) (arg1)->temporalLayerId = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_LayerInfo_temporalLayerId_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_LayerInfo_temporalLayerId_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      LayerInfo *arg1 = (LayerInfo *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint8_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerInfo, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerInfo_temporalLayerId_get" "', argument " "1"" of type '" "LayerInfo *""'"); 
      }
      arg1 = reinterpret_cast< LayerInfo * >(argp1);
      result = (uint8_t) ((arg1)->temporalLayerId);
      jsresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_LayerInfo_spatialLayerId_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_LayerInfo_spatialLayerId_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      LayerInfo *arg1 = (LayerInfo *) 0 ;
      uint8_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned char val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerInfo, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerInfo_spatialLayerId_set" "', argument " "1"" of type '" "LayerInfo *""'"); 
      }
      arg1 = reinterpret_cast< LayerInfo * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_char(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerInfo_spatialLayerId_set" "', argument " "2"" of type '" "uint8_t""'");
      } 
      arg2 = static_cast< uint8_t >(val2);
      if (arg1) (arg1)->spatialLayerId = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_LayerInfo_spatialLayerId_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_LayerInfo_spatialLayerId_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      LayerInfo *arg1 = (LayerInfo *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint8_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerInfo, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerInfo_spatialLayerId_get" "', argument " "1"" of type '" "LayerInfo *""'"); 
      }
      arg1 = reinterpret_cast< LayerInfo * >(argp1);
      result = (uint8_t) ((arg1)->spatialLayerId);
      jsresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  static SwigV8ReturnValue _wrap_new_LayerInfo(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    LayerInfo *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_LayerInfo.");
    result = (LayerInfo *)new LayerInfo();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_LayerInfo, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_LayerInfo(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_LayerInfo(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_LayerInfo(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_LayerInfo(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_LayerInfo(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              LayerInfo * arg1 = (LayerInfo *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_LayerSource_numPackets_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_LayerSource_numPackets_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      LayerSource *arg1 = (LayerSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerSource_numPackets_set" "', argument " "1"" of type '" "LayerSource *""'"); 
      }
      arg1 = reinterpret_cast< LayerSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerSource_numPackets_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->numPackets = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_LayerSource_numPackets_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_LayerSource_numPackets_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      LayerSource *arg1 = (LayerSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerSource_numPackets_get" "', argument " "1"" of type '" "LayerSource *""'"); 
      }
      arg1 = reinterpret_cast< LayerSource * >(argp1);
      result = (uint32_t) ((arg1)->numPackets);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_LayerSource_totalBytes_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_LayerSource_totalBytes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      LayerSource *arg1 = (LayerSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerSource_totalBytes_set" "', argument " "1"" of type '" "LayerSource *""'"); 
      }
      arg1 = reinterpret_cast< LayerSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerSource_totalBytes_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->totalBytes = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_LayerSource_totalBytes_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_LayerSource_totalBytes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      LayerSource *arg1 = (LayerSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerSource_totalBytes_get" "', argument " "1"" of type '" "LayerSource *""'"); 
      }
      arg1 = reinterpret_cast< LayerSource * >(argp1);
      result = (uint32_t) ((arg1)->totalBytes);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_LayerSource_bitrate_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_LayerSource_bitrate_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      LayerSource *arg1 = (LayerSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerSource_bitrate_set" "', argument " "1"" of type '" "LayerSource *""'"); 
      }
      arg1 = reinterpret_cast< LayerSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerSource_bitrate_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->bitrate = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_LayerSource_bitrate_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_LayerSource_bitrate_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      LayerSource *arg1 = (LayerSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_LayerSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerSource_bitrate_get" "', argument " "1"" of type '" "LayerSource *""'"); 
      }
      arg1 = reinterpret_cast< LayerSource * >(argp1);
      result = (uint32_t) ((arg1)->bitrate);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  static SwigV8ReturnValue _wrap_new_LayerSource(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    LayerSource *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_LayerSource.");
    result = (LayerSource *)new LayerSource();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_LayerSource, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_LayerSource(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_LayerSource(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_LayerSource(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_LayerSource(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_LayerSource(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              LayerSource * arg1 = (LayerSource *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_LayerSources_size(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    LayerSources *arg1 = (LayerSources *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    size_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_LayerSources_size.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_LayerSources, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerSources_size" "', argument " "1"" of type '" "LayerSources const *""'"); 
    }
    arg1 = reinterpret_cast< LayerSources * >(argp1);
    result = ((LayerSources const *)arg1)->size();
    jsresult = SWIG_From_size_t(static_cast< size_t >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_LayerSources_get(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    LayerSources *arg1 = (LayerSources *) 0 ;
    size_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    size_t val2 ;
    int ecode2 = 0 ;
    LayerSource *result = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_LayerSources_get.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_LayerSources, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerSources_get" "', argument " "1"" of type '" "LayerSources *""'"); 
    }
    arg1 = reinterpret_cast< LayerSources * >(argp1);
    ecode2 = SWIG_AsVal_size_t(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerSources_get" "', argument " "2"" of type '" "size_t""'");
    } 
    arg2 = static_cast< size_t >(val2);
    result = (LayerSource *)(arg1)->get(arg2);
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_LayerSource, 0 |  0 );
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_LayerSources(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    LayerSources *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_LayerSources.");
    result = (LayerSources *)new LayerSources();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_LayerSources, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_LayerSources(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_LayerSources(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_LayerSources(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_LayerSources(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_LayerSources(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              LayerSources * arg1 = (LayerSources *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_ssrc_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_ssrc_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_ssrc_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_ssrc_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->ssrc = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_ssrc_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_ssrc_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_ssrc_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->ssrc);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_extSeqNum_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_extSeqNum_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_extSeqNum_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_extSeqNum_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->extSeqNum = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_extSeqNum_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_extSeqNum_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_extSeqNum_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->extSeqNum);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_cycles_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_cycles_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_cycles_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_cycles_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->cycles = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_cycles_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_cycles_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_cycles_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->cycles);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_jitter_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_jitter_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_jitter_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_jitter_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->jitter = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_jitter_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_jitter_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_jitter_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->jitter);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_numPackets_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_numPackets_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_numPackets_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_numPackets_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->numPackets = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_numPackets_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_numPackets_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_numPackets_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->numPackets);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_numPacketsDelta_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_numPacketsDelta_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_numPacketsDelta_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_numPacketsDelta_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->numPacketsDelta = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_numPacketsDelta_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_numPacketsDelta_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_numPacketsDelta_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->numPacketsDelta);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_numRTCPPackets_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_numRTCPPackets_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_numRTCPPackets_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_numRTCPPackets_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->numRTCPPackets = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_numRTCPPackets_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_numRTCPPackets_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_numRTCPPackets_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->numRTCPPackets);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_totalBytes_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_totalBytes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_totalBytes_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_totalBytes_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->totalBytes = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_totalBytes_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_totalBytes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_totalBytes_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->totalBytes);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_totalRTCPBytes_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_totalRTCPBytes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_totalRTCPBytes_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_totalRTCPBytes_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->totalRTCPBytes = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_totalRTCPBytes_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_totalRTCPBytes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_totalRTCPBytes_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->totalRTCPBytes);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_bitrate_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_bitrate_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_bitrate_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_bitrate_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->bitrate = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_bitrate_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_bitrate_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_bitrate_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->bitrate);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPSource_clockrate_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPSource_clockrate_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPSource *arg1 = (RTPSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_clockrate_set" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSource_clockrate_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->clockrate = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPSource_clockrate_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPSource_clockrate_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPSource *arg1 = (RTPSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSource_clockrate_get" "', argument " "1"" of type '" "RTPSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPSource * >(argp1);
      result = (uint32_t) ((arg1)->clockrate);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  static SwigV8ReturnValue _wrap_new_RTPSource(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    RTPSource *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPSource.");
    result = (RTPSource *)new RTPSource();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPSource, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPSource(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPSource(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPSource(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPSource(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPSource(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPSource * arg1 = (RTPSource *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_numFrames_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_numFrames_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_numFrames_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_numFrames_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->numFrames = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_numFrames_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_numFrames_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_numFrames_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->numFrames);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_numFramesDelta_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_numFramesDelta_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_numFramesDelta_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_numFramesDelta_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->numFramesDelta = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_numFramesDelta_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_numFramesDelta_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_numFramesDelta_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->numFramesDelta);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_lostPackets_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_lostPackets_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lostPackets_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_lostPackets_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->lostPackets = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_lostPackets_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_lostPackets_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lostPackets_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->lostPackets);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_lostPacketsDelta_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_lostPacketsDelta_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lostPacketsDelta_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_lostPacketsDelta_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->lostPacketsDelta = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_lostPacketsDelta_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_lostPacketsDelta_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lostPacketsDelta_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->lostPacketsDelta);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_dropPackets_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_dropPackets_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_dropPackets_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_dropPackets_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->dropPackets = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_dropPackets_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_dropPackets_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_dropPackets_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->dropPackets);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_totalPacketsSinceLastSR_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_totalPacketsSinceLastSR_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_totalPacketsSinceLastSR_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_totalPacketsSinceLastSR_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->totalPacketsSinceLastSR = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_totalPacketsSinceLastSR_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_totalPacketsSinceLastSR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_totalPacketsSinceLastSR_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->totalPacketsSinceLastSR);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_totalBytesSinceLastSR_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_totalBytesSinceLastSR_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_totalBytesSinceLastSR_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_totalBytesSinceLastSR_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->totalBytesSinceLastSR = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_totalBytesSinceLastSR_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_totalBytesSinceLastSR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_totalBytesSinceLastSR_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->totalBytesSinceLastSR);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_minExtSeqNumSinceLastSR_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_minExtSeqNumSinceLastSR_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_minExtSeqNumSinceLastSR_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_minExtSeqNumSinceLastSR_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->minExtSeqNumSinceLastSR = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_minExtSeqNumSinceLastSR_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_minExtSeqNumSinceLastSR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_minExtSeqNumSinceLastSR_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->minExtSeqNumSinceLastSR);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_lostPacketsSinceLastSR_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_lostPacketsSinceLastSR_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lostPacketsSinceLastSR_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_lostPacketsSinceLastSR_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->lostPacketsSinceLastSR = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_lostPacketsSinceLastSR_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_lostPacketsSinceLastSR_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lostPacketsSinceLastSR_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->lostPacketsSinceLastSR);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_lastReceivedSenderNTPTimestamp_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_lastReceivedSenderNTPTimestamp_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint64_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned long long val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lastReceivedSenderNTPTimestamp_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_lastReceivedSenderNTPTimestamp_set" "', argument " "2"" of type '" "uint64_t""'");
      } 
      arg2 = static_cast< uint64_t >(val2);
      if (arg1) (arg1)->lastReceivedSenderNTPTimestamp = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_lastReceivedSenderNTPTimestamp_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_lastReceivedSenderNTPTimestamp_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint64_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lastReceivedSenderNTPTimestamp_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint64_t) ((arg1)->lastReceivedSenderNTPTimestamp);
      jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_lastReceivedSenderReport_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_lastReceivedSenderReport_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint64_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned long long val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lastReceivedSenderReport_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_lastReceivedSenderReport_set" "', argument " "2"" of type '" "uint64_t""'");
      } 
      arg2 = static_cast< uint64_t >(val2);
      if (arg1) (arg1)->lastReceivedSenderReport = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_lastReceivedSenderReport_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_lastReceivedSenderReport_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint64_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lastReceivedSenderReport_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint64_t) ((arg1)->lastReceivedSenderReport);
      jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_lastReport_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_lastReport_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint64_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned long long val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lastReport_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_lastReport_set" "', argument " "2"" of type '" "uint64_t""'");
      } 
      arg2 = static_cast< uint64_t >(val2);
      if (arg1) (arg1)->lastReport = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_lastReport_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_lastReport_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint64_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_lastReport_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint64_t) ((arg1)->lastReport);
      jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_totalPLIs_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_totalPLIs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_totalPLIs_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_totalPLIs_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->totalPLIs = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_totalPLIs_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_totalPLIs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_totalPLIs_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->totalPLIs);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_totalNACKs_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_totalNACKs_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_totalNACKs_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_totalNACKs_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->totalNACKs = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_totalNACKs_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_totalNACKs_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_totalNACKs_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (uint32_t) ((arg1)->totalNACKs);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_skew_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_skew_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      int64_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      long long val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_skew_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_long_SS_long(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_skew_set" "', argument " "2"" of type '" "int64_t""'");
      } 
      arg2 = static_cast< int64_t >(val2);
      if (arg1) (arg1)->skew = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_skew_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_skew_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      int64_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_skew_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (int64_t) ((arg1)->skew);
      jsresult = SWIG_From_long_SS_long(static_cast< long long >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSource_drift_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSource_drift_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      double arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      double val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_drift_set" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      ecode2 = SWIG_AsVal_double(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSource_drift_set" "', argument " "2"" of type '" "double""'");
      } 
      arg2 = static_cast< double >(val2);
      if (arg1) (arg1)->drift = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSource_drift_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSource_drift_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      double result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_drift_get" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
      result = (double) ((arg1)->drift);
      jsresult = SWIG_From_double(static_cast< double >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  static SwigV8ReturnValue _wrap_RTPIncomingSource_layers(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPIncomingSource *arg1 = (RTPIncomingSource *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    LayerSources result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPIncomingSource_layers.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSource_layers" "', argument " "1"" of type '" "RTPIncomingSource *""'"); 
    }
    arg1 = reinterpret_cast< RTPIncomingSource * >(argp1);
    result = RTPIncomingSource_layers(arg1);
    jsresult = SWIG_NewPointerObj((new LayerSources(static_cast< const LayerSources& >(result))), SWIGTYPE_p_LayerSources, SWIG_POINTER_OWN |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPIncomingSource(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    RTPIncomingSource *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPIncomingSource.");
    result = (RTPIncomingSource *)new RTPIncomingSource();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPIncomingSource, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPIncomingSource(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPIncomingSource(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPIncomingSource(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPIncomingSource(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPIncomingSource(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPIncomingSource * arg1 = (RTPIncomingSource *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_time_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_time_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_time_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_time_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->time = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_time_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_time_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_time_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->time);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_lastTime_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_lastTime_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_lastTime_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_lastTime_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->lastTime = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_lastTime_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_lastTime_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_lastTime_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->lastTime);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_numPackets_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_numPackets_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_numPackets_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_numPackets_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->numPackets = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_numPackets_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_numPackets_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_numPackets_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->numPackets);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_numRTCPPackets_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_numRTCPPackets_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_numRTCPPackets_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_numRTCPPackets_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->numRTCPPackets = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_numRTCPPackets_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_numRTCPPackets_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_numRTCPPackets_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->numRTCPPackets);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_totalBytes_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_totalBytes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_totalBytes_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_totalBytes_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->totalBytes = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_totalBytes_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_totalBytes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_totalBytes_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->totalBytes);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_totalRTCPBytes_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_totalRTCPBytes_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_totalRTCPBytes_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_totalRTCPBytes_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->totalRTCPBytes = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_totalRTCPBytes_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_totalRTCPBytes_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_totalRTCPBytes_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->totalRTCPBytes);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_lastSenderReport_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_lastSenderReport_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint64_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned long long val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_lastSenderReport_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_lastSenderReport_set" "', argument " "2"" of type '" "uint64_t""'");
      } 
      arg2 = static_cast< uint64_t >(val2);
      if (arg1) (arg1)->lastSenderReport = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_lastSenderReport_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_lastSenderReport_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint64_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_lastSenderReport_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint64_t) ((arg1)->lastSenderReport);
      jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_lastSenderReportNTP_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_lastSenderReportNTP_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint64_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned long long val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_lastSenderReportNTP_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_lastSenderReportNTP_set" "', argument " "2"" of type '" "uint64_t""'");
      } 
      arg2 = static_cast< uint64_t >(val2);
      if (arg1) (arg1)->lastSenderReportNTP = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_lastSenderReportNTP_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_lastSenderReportNTP_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint64_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_lastSenderReportNTP_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint64_t) ((arg1)->lastSenderReportNTP);
      jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_remb_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_remb_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_remb_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_remb_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->remb = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_remb_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_remb_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_remb_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->remb);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_reportCount_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_reportCount_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportCount_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_reportCount_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->reportCount = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportCount_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportCount_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportCount_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->reportCount);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_reportCountDelta_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_reportCountDelta_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportCountDelta_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_reportCountDelta_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->reportCountDelta = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportCountDelta_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportCountDelta_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportCountDelta_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->reportCountDelta);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_reportedLostCount_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_reportedLostCount_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportedLostCount_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_reportedLostCount_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->reportedLostCount = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportedLostCount_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportedLostCount_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportedLostCount_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->reportedLostCount);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_reportedLostCountDelta_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_reportedLostCountDelta_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportedLostCountDelta_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_reportedLostCountDelta_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->reportedLostCountDelta = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportedLostCountDelta_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportedLostCountDelta_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportedLostCountDelta_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->reportedLostCountDelta);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_reportedFractionLost_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_reportedFractionLost_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint8_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned char val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportedFractionLost_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_char(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_reportedFractionLost_set" "', argument " "2"" of type '" "uint8_t""'");
      } 
      arg2 = static_cast< uint8_t >(val2);
      if (arg1) (arg1)->reportedFractionLost = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportedFractionLost_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportedFractionLost_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint8_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportedFractionLost_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint8_t) ((arg1)->reportedFractionLost);
      jsresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_reportedJitter_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_reportedJitter_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportedJitter_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_reportedJitter_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->reportedJitter = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportedJitter_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_reportedJitter_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_reportedJitter_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->reportedJitter);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSource_rtt_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSource_rtt_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_rtt_set" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSource_rtt_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->rtt = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSource_rtt_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSource_rtt_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSource *arg1 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSource_rtt_get" "', argument " "1"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSource * >(argp1);
      result = (uint32_t) ((arg1)->rtt);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  static SwigV8ReturnValue _wrap_new_RTPOutgoingSource(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    RTPOutgoingSource *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPOutgoingSource.");
    result = (RTPOutgoingSource *)new RTPOutgoingSource();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPOutgoingSource, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPOutgoingSource(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPOutgoingSource(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPOutgoingSource(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPOutgoingSource(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPOutgoingSource(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPOutgoingSource * arg1 = (RTPOutgoingSource *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_TimeService(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_TimeService(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_TimeService(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_TimeService(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_TimeService(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              TimeService * arg1 = (TimeService *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_veto_TimeService(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class TimeService can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPOutgoingSourceGroup__SWIG_0(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    MediaFrameType arg1 ;
    int val1 ;
    int ecode1 = 0 ;
    RTPOutgoingSourceGroup *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPOutgoingSourceGroup__SWIG_0.");
    ecode1 = SWIG_AsVal_int(args[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RTPOutgoingSourceGroup" "', argument " "1"" of type '" "MediaFrameType""'");
    } 
    arg1 = static_cast< MediaFrameType >(val1);
    result = (RTPOutgoingSourceGroup *)new RTPOutgoingSourceGroup(arg1);
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPOutgoingSourceGroup, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPOutgoingSourceGroup__SWIG_1(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    std::string *arg1 = 0 ;
    MediaFrameType arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int val2 ;
    int ecode2 = 0 ;
    RTPOutgoingSourceGroup *result;
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPOutgoingSourceGroup__SWIG_1.");
    res1 = SWIG_ConvertPtr(args[0], &argp1, SWIGTYPE_p_std__string,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RTPOutgoingSourceGroup" "', argument " "1"" of type '" "std::string &""'"); 
    }
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RTPOutgoingSourceGroup" "', argument " "1"" of type '" "std::string &""'"); 
    }
    arg1 = reinterpret_cast< std::string * >(argp1);
    ecode2 = SWIG_AsVal_int(args[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RTPOutgoingSourceGroup" "', argument " "2"" of type '" "MediaFrameType""'");
    } 
    arg2 = static_cast< MediaFrameType >(val2);
    result = (RTPOutgoingSourceGroup *)new RTPOutgoingSourceGroup(*arg1,arg2);
    
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPOutgoingSourceGroup, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPOutgoingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    OverloadErrorHandler errorHandler;
    v8::Handle<v8::Value> self;
    
    // switch all cases by means of series of if-returns.
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      self = _wrap_new_RTPOutgoingSourceGroup__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(self);
      }
  #else
      _wrap_new_RTPOutgoingSourceGroup__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    if(args.Length() == 2) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      self = _wrap_new_RTPOutgoingSourceGroup__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(self);
      }
  #else
      _wrap_new_RTPOutgoingSourceGroup__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    // default:
    SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for construction of _exports_RTPOutgoingSourceGroup");
    
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSourceGroup_type_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSourceGroup_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
      MediaFrameType arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSourceGroup_type_set" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
      ecode2 = SWIG_AsVal_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPOutgoingSourceGroup_type_set" "', argument " "2"" of type '" "MediaFrameType""'");
      } 
      arg2 = static_cast< MediaFrameType >(val2);
      if (arg1) (arg1)->type = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSourceGroup_type_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSourceGroup_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      MediaFrameType result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSourceGroup_type_get" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
      result = (MediaFrameType) ((arg1)->type);
      jsresult = SWIG_From_int(static_cast< int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSourceGroup_media_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSourceGroup_media_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
      RTPOutgoingSource *arg2 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      void *argp2 = 0 ;
      int res2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSourceGroup_media_set" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
      res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPOutgoingSourceGroup_media_set" "', argument " "2"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg2 = reinterpret_cast< RTPOutgoingSource * >(argp2);
      if (arg1) (arg1)->media = *arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSourceGroup_media_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSourceGroup_media_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      RTPOutgoingSource *result = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSourceGroup_media_get" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
      result = (RTPOutgoingSource *)& ((arg1)->media);
      jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSourceGroup_fec_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSourceGroup_fec_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
      RTPOutgoingSource *arg2 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      void *argp2 = 0 ;
      int res2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSourceGroup_fec_set" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
      res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPOutgoingSourceGroup_fec_set" "', argument " "2"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg2 = reinterpret_cast< RTPOutgoingSource * >(argp2);
      if (arg1) (arg1)->fec = *arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSourceGroup_fec_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSourceGroup_fec_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      RTPOutgoingSource *result = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSourceGroup_fec_get" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
      result = (RTPOutgoingSource *)& ((arg1)->fec);
      jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPOutgoingSourceGroup_rtx_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPOutgoingSourceGroup_rtx_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
      RTPOutgoingSource *arg2 = (RTPOutgoingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      void *argp2 = 0 ;
      int res2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSourceGroup_rtx_set" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
      res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPOutgoingSourceGroup_rtx_set" "', argument " "2"" of type '" "RTPOutgoingSource *""'"); 
      }
      arg2 = reinterpret_cast< RTPOutgoingSource * >(argp2);
      if (arg1) (arg1)->rtx = *arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPOutgoingSourceGroup_rtx_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPOutgoingSourceGroup_rtx_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      RTPOutgoingSource *result = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSourceGroup_rtx_get" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
      result = (RTPOutgoingSource *)& ((arg1)->rtx);
      jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPOutgoingSource, 0 |  0 );
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  static SwigV8ReturnValue _wrap_RTPOutgoingSourceGroup_Update(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPOutgoingSourceGroup_Update.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPOutgoingSourceGroup_Update" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
    }
    arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
    (arg1)->Update();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPOutgoingSourceGroup(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPOutgoingSourceGroup(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPOutgoingSourceGroup(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPOutgoingSourceGroup(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPOutgoingSourceGroup(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPOutgoingSourceGroup * arg1 = (RTPOutgoingSourceGroup *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_veto_RTPSender(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class RTPSender can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_veto_RTPReceiver(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class RTPReceiver can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPIncomingMediaStreamListener(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPIncomingMediaStreamListener(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPIncomingMediaStreamListener(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPIncomingMediaStreamListener(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPIncomingMediaStreamListener(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPIncomingMediaStreamListener * arg1 = (RTPIncomingMediaStreamListener *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_veto_RTPIncomingMediaStreamListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class RTPIncomingMediaStreamListener can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_veto_RTPIncomingMediaStream(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class RTPIncomingMediaStream can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPIncomingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    MediaFrameType arg1 ;
    TimeService *arg2 = 0 ;
    int val1 ;
    int ecode1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    RTPIncomingSourceGroup *result;
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPIncomingSourceGroup.");
    ecode1 = SWIG_AsVal_int(args[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RTPIncomingSourceGroup" "', argument " "1"" of type '" "MediaFrameType""'");
    } 
    arg1 = static_cast< MediaFrameType >(val1);
    res2 = SWIG_ConvertPtr(args[1], &argp2, SWIGTYPE_p_TimeService,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RTPIncomingSourceGroup" "', argument " "2"" of type '" "TimeService &""'"); 
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RTPIncomingSourceGroup" "', argument " "2"" of type '" "TimeService &""'"); 
    }
    arg2 = reinterpret_cast< TimeService * >(argp2);
    result = (RTPIncomingSourceGroup *)new RTPIncomingSourceGroup(arg1,*arg2);
    
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPIncomingSourceGroup, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_rid_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_rid_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      std::string *arg2 = 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      int res2 = SWIG_OLDOBJ ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_rid_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      {
        std::string *ptr = (std::string *)0;
        res2 = SWIG_AsPtr_std_string(value, &ptr);
        if (!SWIG_IsOK(res2)) {
          SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPIncomingSourceGroup_rid_set" "', argument " "2"" of type '" "std::string const &""'"); 
        }
        if (!ptr) {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTPIncomingSourceGroup_rid_set" "', argument " "2"" of type '" "std::string const &""'"); 
        }
        arg2 = ptr;
      }
      if (arg1) (arg1)->rid = *arg2;
      
      if (SWIG_IsNewObj(res2)) delete arg2;
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_rid_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_rid_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      std::string *result = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_rid_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (std::string *) & ((arg1)->rid);
      jsresult = SWIG_From_std_string(static_cast< std::string >(*result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_mid_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_mid_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      std::string *arg2 = 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      int res2 = SWIG_OLDOBJ ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_mid_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      {
        std::string *ptr = (std::string *)0;
        res2 = SWIG_AsPtr_std_string(value, &ptr);
        if (!SWIG_IsOK(res2)) {
          SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPIncomingSourceGroup_mid_set" "', argument " "2"" of type '" "std::string const &""'"); 
        }
        if (!ptr) {
          SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTPIncomingSourceGroup_mid_set" "', argument " "2"" of type '" "std::string const &""'"); 
        }
        arg2 = ptr;
      }
      if (arg1) (arg1)->mid = *arg2;
      
      if (SWIG_IsNewObj(res2)) delete arg2;
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_mid_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_mid_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      std::string *result = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_mid_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (std::string *) & ((arg1)->mid);
      jsresult = SWIG_From_std_string(static_cast< std::string >(*result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_rtt_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_rtt_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_rtt_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSourceGroup_rtt_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->rtt = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_rtt_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_rtt_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_rtt_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (uint32_t) ((arg1)->rtt);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_type_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_type_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      MediaFrameType arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_type_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      ecode2 = SWIG_AsVal_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSourceGroup_type_set" "', argument " "2"" of type '" "MediaFrameType""'");
      } 
      arg2 = static_cast< MediaFrameType >(val2);
      if (arg1) (arg1)->type = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_type_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_type_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      MediaFrameType result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_type_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (MediaFrameType) ((arg1)->type);
      jsresult = SWIG_From_int(static_cast< int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_media_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_media_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      RTPIncomingSource *arg2 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      void *argp2 = 0 ;
      int res2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_media_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPIncomingSourceGroup_media_set" "', argument " "2"" of type '" "RTPIncomingSource *""'"); 
      }
      arg2 = reinterpret_cast< RTPIncomingSource * >(argp2);
      if (arg1) (arg1)->media = *arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_media_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_media_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      RTPIncomingSource *result = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_media_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (RTPIncomingSource *)& ((arg1)->media);
      jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_fec_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_fec_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      RTPIncomingSource *arg2 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      void *argp2 = 0 ;
      int res2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_fec_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPIncomingSourceGroup_fec_set" "', argument " "2"" of type '" "RTPIncomingSource *""'"); 
      }
      arg2 = reinterpret_cast< RTPIncomingSource * >(argp2);
      if (arg1) (arg1)->fec = *arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_fec_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_fec_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      RTPIncomingSource *result = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_fec_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (RTPIncomingSource *)& ((arg1)->fec);
      jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_rtx_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_rtx_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      RTPIncomingSource *arg2 = (RTPIncomingSource *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      void *argp2 = 0 ;
      int res2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_rtx_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPIncomingSourceGroup_rtx_set" "', argument " "2"" of type '" "RTPIncomingSource *""'"); 
      }
      arg2 = reinterpret_cast< RTPIncomingSource * >(argp2);
      if (arg1) (arg1)->rtx = *arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_rtx_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_rtx_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      RTPIncomingSource *result = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_rtx_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (RTPIncomingSource *)& ((arg1)->rtx);
      jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPIncomingSource, 0 |  0 );
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_lost_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_lost_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_lost_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSourceGroup_lost_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->lost = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_lost_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_lost_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_lost_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (uint32_t) ((arg1)->lost);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_minWaitedTime_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_minWaitedTime_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_minWaitedTime_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSourceGroup_minWaitedTime_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->minWaitedTime = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_minWaitedTime_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_minWaitedTime_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_minWaitedTime_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (uint32_t) ((arg1)->minWaitedTime);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_maxWaitedTime_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_maxWaitedTime_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      uint32_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      unsigned int val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_maxWaitedTime_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      ecode2 = SWIG_AsVal_unsigned_SS_int(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSourceGroup_maxWaitedTime_set" "', argument " "2"" of type '" "uint32_t""'");
      } 
      arg2 = static_cast< uint32_t >(val2);
      if (arg1) (arg1)->maxWaitedTime = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_maxWaitedTime_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_maxWaitedTime_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      uint32_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_maxWaitedTime_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (uint32_t) ((arg1)->maxWaitedTime);
      jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPIncomingSourceGroup_avgWaitedTime_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPIncomingSourceGroup_avgWaitedTime_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      double arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      double val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_avgWaitedTime_set" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      ecode2 = SWIG_AsVal_double(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPIncomingSourceGroup_avgWaitedTime_set" "', argument " "2"" of type '" "double""'");
      } 
      arg2 = static_cast< double >(val2);
      if (arg1) (arg1)->avgWaitedTime = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_avgWaitedTime_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_avgWaitedTime_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      double result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_avgWaitedTime_get" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
      }
      arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
      result = (double) ((arg1)->avgWaitedTime);
      jsresult = SWIG_From_double(static_cast< double >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_AddListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
    RTPIncomingMediaStreamListener *arg2 = (RTPIncomingMediaStreamListener *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPIncomingSourceGroup_AddListener.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_AddListener" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
    }
    arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingMediaStreamListener, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPIncomingSourceGroup_AddListener" "', argument " "2"" of type '" "RTPIncomingMediaStreamListener *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingMediaStreamListener * >(argp2);
    (arg1)->AddListener(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_RemoveListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
    RTPIncomingMediaStreamListener *arg2 = (RTPIncomingMediaStreamListener *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPIncomingSourceGroup_RemoveListener.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_RemoveListener" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
    }
    arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingMediaStreamListener, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPIncomingSourceGroup_RemoveListener" "', argument " "2"" of type '" "RTPIncomingMediaStreamListener *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingMediaStreamListener * >(argp2);
    (arg1)->RemoveListener(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPIncomingSourceGroup_Update(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPIncomingSourceGroup *arg1 = (RTPIncomingSourceGroup *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPIncomingSourceGroup_Update.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingSourceGroup_Update" "', argument " "1"" of type '" "RTPIncomingSourceGroup *""'"); 
    }
    arg1 = reinterpret_cast< RTPIncomingSourceGroup * >(argp1);
    (arg1)->Update();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPIncomingSourceGroup(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPIncomingSourceGroup(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPIncomingSourceGroup(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPIncomingSourceGroup(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPIncomingSourceGroup(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPIncomingSourceGroup * arg1 = (RTPIncomingSourceGroup *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_RTPIncomingMediaStreamMultiplexer(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    uint32_t arg1 ;
    TimeService *arg2 = 0 ;
    unsigned int val1 ;
    int ecode1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    RTPIncomingMediaStreamMultiplexer *result;
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPIncomingMediaStreamMultiplexer.");
    ecode1 = SWIG_AsVal_unsigned_SS_int(args[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RTPIncomingMediaStreamMultiplexer" "', argument " "1"" of type '" "uint32_t""'");
    } 
    arg1 = static_cast< uint32_t >(val1);
    res2 = SWIG_ConvertPtr(args[1], &argp2, SWIGTYPE_p_TimeService,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RTPIncomingMediaStreamMultiplexer" "', argument " "2"" of type '" "TimeService &""'"); 
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_RTPIncomingMediaStreamMultiplexer" "', argument " "2"" of type '" "TimeService &""'"); 
    }
    arg2 = reinterpret_cast< TimeService * >(argp2);
    result = (RTPIncomingMediaStreamMultiplexer *)new RTPIncomingMediaStreamMultiplexer(arg1,*arg2);
    
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPIncomingMediaStreamMultiplexer, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPIncomingMediaStreamMultiplexer_Stop(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPIncomingMediaStreamMultiplexer *arg1 = (RTPIncomingMediaStreamMultiplexer *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPIncomingMediaStreamMultiplexer_Stop.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPIncomingMediaStreamMultiplexer, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingMediaStreamMultiplexer_Stop" "', argument " "1"" of type '" "RTPIncomingMediaStreamMultiplexer *""'"); 
    }
    arg1 = reinterpret_cast< RTPIncomingMediaStreamMultiplexer * >(argp1);
    (arg1)->Stop();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPIncomingMediaStreamMultiplexer(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPIncomingMediaStreamMultiplexer(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPIncomingMediaStreamMultiplexer(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPIncomingMediaStreamMultiplexer(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPIncomingMediaStreamMultiplexer(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPIncomingMediaStreamMultiplexer * arg1 = (RTPIncomingMediaStreamMultiplexer *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_PropertiesFacade_SetPropertyInt(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PropertiesFacade *arg1 = (PropertiesFacade *) 0 ;
    char *arg2 = (char *) 0 ;
    int arg3 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    int val3 ;
    int ecode3 = 0 ;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PropertiesFacade_SetPropertyInt.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PropertiesFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertiesFacade_SetPropertyInt" "', argument " "1"" of type '" "PropertiesFacade *""'"); 
    }
    arg1 = reinterpret_cast< PropertiesFacade * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertiesFacade_SetPropertyInt" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    ecode3 = SWIG_AsVal_int(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertiesFacade_SetPropertyInt" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
    (arg1)->SetPropertyInt((char const *)arg2,arg3);
    jsresult = SWIGV8_UNDEFINED();
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PropertiesFacade_SetPropertyStr(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PropertiesFacade *arg1 = (PropertiesFacade *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    int res3 ;
    char *buf3 = 0 ;
    int alloc3 = 0 ;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PropertiesFacade_SetPropertyStr.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PropertiesFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertiesFacade_SetPropertyStr" "', argument " "1"" of type '" "PropertiesFacade *""'"); 
    }
    arg1 = reinterpret_cast< PropertiesFacade * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertiesFacade_SetPropertyStr" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    res3 = SWIG_AsCharPtrAndSize(args[1], &buf3, NULL, &alloc3);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PropertiesFacade_SetPropertyStr" "', argument " "3"" of type '" "char const *""'");
    }
    arg3 = reinterpret_cast< char * >(buf3);
    (arg1)->SetPropertyStr((char const *)arg2,(char const *)arg3);
    jsresult = SWIGV8_UNDEFINED();
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PropertiesFacade_SetPropertyBool(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PropertiesFacade *arg1 = (PropertiesFacade *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PropertiesFacade_SetPropertyBool.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PropertiesFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PropertiesFacade_SetPropertyBool" "', argument " "1"" of type '" "PropertiesFacade *""'"); 
    }
    arg1 = reinterpret_cast< PropertiesFacade * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PropertiesFacade_SetPropertyBool" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PropertiesFacade_SetPropertyBool" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    (arg1)->SetPropertyBool((char const *)arg2,arg3);
    jsresult = SWIGV8_UNDEFINED();
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_PropertiesFacade(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    PropertiesFacade *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_PropertiesFacade.");
    result = (PropertiesFacade *)new PropertiesFacade();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_PropertiesFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_PropertiesFacade(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_PropertiesFacade(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_PropertiesFacade(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_PropertiesFacade(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_PropertiesFacade(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              PropertiesFacade * arg1 = (PropertiesFacade *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_MediaServer_Initialize(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MediaServer_Initialize.");
    
    MediaServer::Initialize();
    jsresult = SWIGV8_UNDEFINED();
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MediaServer_Terminate(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MediaServer_Terminate.");
    
    MediaServer::Terminate();
    jsresult = SWIGV8_UNDEFINED();
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MediaServer_EnableLog(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    bool arg1 ;
    bool val1 ;
    int ecode1 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MediaServer_EnableLog.");
    
    ecode1 = SWIG_AsVal_bool(args[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MediaServer_EnableLog" "', argument " "1"" of type '" "bool""'");
    } 
    arg1 = static_cast< bool >(val1);
    MediaServer::EnableLog(arg1);
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MediaServer_EnableDebug(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    bool arg1 ;
    bool val1 ;
    int ecode1 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MediaServer_EnableDebug.");
    
    ecode1 = SWIG_AsVal_bool(args[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MediaServer_EnableDebug" "', argument " "1"" of type '" "bool""'");
    } 
    arg1 = static_cast< bool >(val1);
    MediaServer::EnableDebug(arg1);
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MediaServer_EnableUltraDebug(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    bool arg1 ;
    bool val1 ;
    int ecode1 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MediaServer_EnableUltraDebug.");
    
    ecode1 = SWIG_AsVal_bool(args[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MediaServer_EnableUltraDebug" "', argument " "1"" of type '" "bool""'");
    } 
    arg1 = static_cast< bool >(val1);
    MediaServer::EnableUltraDebug(arg1);
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MediaServer_SetCertificate(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    char *arg1 = (char *) 0 ;
    char *arg2 = (char *) 0 ;
    int res1 ;
    char *buf1 = 0 ;
    int alloc1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    bool result;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MediaServer_SetCertificate.");
    
    res1 = SWIG_AsCharPtrAndSize(args[0], &buf1, NULL, &alloc1);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MediaServer_SetCertificate" "', argument " "1"" of type '" "char const *""'");
    }
    arg1 = reinterpret_cast< char * >(buf1);
    res2 = SWIG_AsCharPtrAndSize(args[1], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MediaServer_SetCertificate" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    result = (bool)MediaServer::SetCertificate((char const *)arg1,(char const *)arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MediaServer_GetFingerprint(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    std::string result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MediaServer_GetFingerprint.");
    
    result = MediaServer::GetFingerprint();
    jsresult = SWIG_From_std_string(static_cast< std::string >(result));
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MediaServer_SetPortRange(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    int arg1 ;
    int arg2 ;
    int val1 ;
    int ecode1 = 0 ;
    int val2 ;
    int ecode2 = 0 ;
    bool result;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MediaServer_SetPortRange.");
    
    ecode1 = SWIG_AsVal_int(args[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MediaServer_SetPortRange" "', argument " "1"" of type '" "int""'");
    } 
    arg1 = static_cast< int >(val1);
    ecode2 = SWIG_AsVal_int(args[1], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MediaServer_SetPortRange" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
    result = (bool)MediaServer::SetPortRange(arg1,arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_MediaServer(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    MediaServer *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_MediaServer.");
    result = (MediaServer *)new MediaServer();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_MediaServer, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_MediaServer(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_MediaServer(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_MediaServer(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_MediaServer(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_MediaServer(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              MediaServer * arg1 = (MediaServer *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPBundleTransportConnection_transport_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPBundleTransportConnection_transport_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      DTLSICETransport *arg2 = (DTLSICETransport *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      void *argp2 = 0 ;
      int res2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_transport_set" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      res2 = SWIG_ConvertPtr(value, &argp2,SWIGTYPE_p_DTLSICETransport, SWIG_POINTER_DISOWN |  0 );
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPBundleTransportConnection_transport_set" "', argument " "2"" of type '" "DTLSICETransport *""'"); 
      }
      arg2 = reinterpret_cast< DTLSICETransport * >(argp2);
      if (arg1) (arg1)->transport = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_transport_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_transport_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      DTLSICETransport *result = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_transport_get" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      result = (DTLSICETransport *) ((arg1)->transport);
      jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DTLSICETransport, 0 |  0 );
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPBundleTransportConnection_disableSTUNKeepAlive_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPBundleTransportConnection_disableSTUNKeepAlive_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      bool arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      bool val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_disableSTUNKeepAlive_set" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      ecode2 = SWIG_AsVal_bool(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPBundleTransportConnection_disableSTUNKeepAlive_set" "', argument " "2"" of type '" "bool""'");
      } 
      arg2 = static_cast< bool >(val2);
      if (arg1) (arg1)->disableSTUNKeepAlive = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_disableSTUNKeepAlive_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_disableSTUNKeepAlive_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      bool result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_disableSTUNKeepAlive_get" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      result = (bool) ((arg1)->disableSTUNKeepAlive);
      jsresult = SWIG_From_bool(static_cast< bool >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPBundleTransportConnection_iceRequestsSent_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPBundleTransportConnection_iceRequestsSent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      size_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      size_t val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_iceRequestsSent_set" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      ecode2 = SWIG_AsVal_size_t(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPBundleTransportConnection_iceRequestsSent_set" "', argument " "2"" of type '" "size_t""'");
      } 
      arg2 = static_cast< size_t >(val2);
      if (arg1) (arg1)->iceRequestsSent = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_iceRequestsSent_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_iceRequestsSent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      size_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_iceRequestsSent_get" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      result =  ((arg1)->iceRequestsSent);
      jsresult = SWIG_From_size_t(static_cast< size_t >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPBundleTransportConnection_iceRequestsReceived_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPBundleTransportConnection_iceRequestsReceived_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      size_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      size_t val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_iceRequestsReceived_set" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      ecode2 = SWIG_AsVal_size_t(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPBundleTransportConnection_iceRequestsReceived_set" "', argument " "2"" of type '" "size_t""'");
      } 
      arg2 = static_cast< size_t >(val2);
      if (arg1) (arg1)->iceRequestsReceived = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_iceRequestsReceived_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_iceRequestsReceived_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      size_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_iceRequestsReceived_get" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      result =  ((arg1)->iceRequestsReceived);
      jsresult = SWIG_From_size_t(static_cast< size_t >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPBundleTransportConnection_iceResponsesSent_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPBundleTransportConnection_iceResponsesSent_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      size_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      size_t val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_iceResponsesSent_set" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      ecode2 = SWIG_AsVal_size_t(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPBundleTransportConnection_iceResponsesSent_set" "', argument " "2"" of type '" "size_t""'");
      } 
      arg2 = static_cast< size_t >(val2);
      if (arg1) (arg1)->iceResponsesSent = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_iceResponsesSent_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_iceResponsesSent_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      size_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_iceResponsesSent_get" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      result =  ((arg1)->iceResponsesSent);
      jsresult = SWIG_From_size_t(static_cast< size_t >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static void _wrap_RTPBundleTransportConnection_iceResponsesReceived_set(v8::Local<v8::String> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #else
    static void _wrap_RTPBundleTransportConnection_iceResponsesReceived_set(v8::Local<v8::Name> property, v8::Local<v8::Value> value, const SwigV8PropertyCallbackInfoVoid &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      size_t arg2 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      size_t val2 ;
      int ecode2 = 0 ;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_iceResponsesReceived_set" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      ecode2 = SWIG_AsVal_size_t(value, &val2);
      if (!SWIG_IsOK(ecode2)) {
        SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPBundleTransportConnection_iceResponsesReceived_set" "', argument " "2"" of type '" "size_t""'");
      } 
      arg2 = static_cast< size_t >(val2);
      if (arg1) (arg1)->iceResponsesReceived = arg2;
      
      
      
      goto fail;
    fail:
      return;
    }
  
  
  #if (V8_MAJOR_VERSION-0) < 5
  static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_iceResponsesReceived_get(v8::Local<v8::String> property, const SwigV8PropertyCallbackInfo &info) {
  #else
    static SwigV8ReturnValue _wrap_RTPBundleTransportConnection_iceResponsesReceived_get(v8::Local<v8::Name> property, const SwigV8PropertyCallbackInfo &info) {
  #endif
      SWIGV8_HANDLESCOPE();
      
      v8::Handle<v8::Value> jsresult;
      RTPBundleTransportConnection *arg1 = (RTPBundleTransportConnection *) 0 ;
      void *argp1 = 0 ;
      int res1 = 0 ;
      size_t result;
      
      res1 = SWIG_ConvertPtr(info.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
      if (!SWIG_IsOK(res1)) {
        SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransportConnection_iceResponsesReceived_get" "', argument " "1"" of type '" "RTPBundleTransportConnection *""'"); 
      }
      arg1 = reinterpret_cast< RTPBundleTransportConnection * >(argp1);
      result =  ((arg1)->iceResponsesReceived);
      jsresult = SWIG_From_size_t(static_cast< size_t >(result));
      
      
      SWIGV8_RETURN_INFO(jsresult, info);
      
      goto fail;
    fail:
      SWIGV8_RETURN_INFO(SWIGV8_UNDEFINED(), info);
    }
  
  
  static SwigV8ReturnValue _wrap_new_veto_RTPBundleTransportConnection(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class RTPBundleTransportConnection can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPBundleTransport(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    RTPBundleTransport *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPBundleTransport.");
    result = (RTPBundleTransport *)new RTPBundleTransport();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPBundleTransport, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_Init__SWIG_0(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_Init" "', argument " "1"" of type '" "RTPBundleTransport *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    result = (int)(arg1)->Init();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_Init__SWIG_1(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    int arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int val2 ;
    int ecode2 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_Init" "', argument " "1"" of type '" "RTPBundleTransport *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    ecode2 = SWIG_AsVal_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPBundleTransport_Init" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
    result = (int)(arg1)->Init(arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport__wrap_RTPBundleTransport_Init(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    OverloadErrorHandler errorHandler;
    
    
    if(args.Length() == 0) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_RTPBundleTransport_Init__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_RTPBundleTransport_Init__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_RTPBundleTransport_Init__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_RTPBundleTransport_Init__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for function Init.");
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_AddICETransport(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    std::string *arg2 = 0 ;
    Properties *arg3 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 = SWIG_OLDOBJ ;
    void *argp3 ;
    int res3 = 0 ;
    RTPBundleTransportConnection *result = 0 ;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPBundleTransport_AddICETransport.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_AddICETransport" "', argument " "1"" of type '" "RTPBundleTransport *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    {
      std::string *ptr = (std::string *)0;
      res2 = SWIG_AsPtr_std_string(args[0], &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPBundleTransport_AddICETransport" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTPBundleTransport_AddICETransport" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      arg2 = ptr;
    }
    res3 = SWIG_ConvertPtr(args[1], &argp3, SWIGTYPE_p_Properties,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RTPBundleTransport_AddICETransport" "', argument " "3"" of type '" "Properties const &""'"); 
    }
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTPBundleTransport_AddICETransport" "', argument " "3"" of type '" "Properties const &""'"); 
    }
    arg3 = reinterpret_cast< Properties * >(argp3);
    result = (RTPBundleTransportConnection *)(arg1)->AddICETransport((std::string const &)*arg2,(Properties const &)*arg3);
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPBundleTransportConnection, 0 |  0 );
    
    if (SWIG_IsNewObj(res2)) delete arg2;
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_RemoveICETransport(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    std::string *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 = SWIG_OLDOBJ ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPBundleTransport_RemoveICETransport.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_RemoveICETransport" "', argument " "1"" of type '" "RTPBundleTransport *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    {
      std::string *ptr = (std::string *)0;
      res2 = SWIG_AsPtr_std_string(args[0], &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPBundleTransport_RemoveICETransport" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTPBundleTransport_RemoveICETransport" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      arg2 = ptr;
    }
    result = (int)(arg1)->RemoveICETransport((std::string const &)*arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (SWIG_IsNewObj(res2)) delete arg2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_End(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPBundleTransport_End.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_End" "', argument " "1"" of type '" "RTPBundleTransport *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    result = (int)(arg1)->End();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_GetLocalPort(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPBundleTransport_GetLocalPort.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_GetLocalPort" "', argument " "1"" of type '" "RTPBundleTransport const *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    result = (int)((RTPBundleTransport const *)arg1)->GetLocalPort();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_AddRemoteCandidate(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    std::string *arg2 = 0 ;
    char *arg3 = (char *) 0 ;
    uint16_t arg4 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 = SWIG_OLDOBJ ;
    int res3 ;
    char *buf3 = 0 ;
    int alloc3 = 0 ;
    unsigned short val4 ;
    int ecode4 = 0 ;
    int result;
    
    if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPBundleTransport_AddRemoteCandidate.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_AddRemoteCandidate" "', argument " "1"" of type '" "RTPBundleTransport *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    {
      std::string *ptr = (std::string *)0;
      res2 = SWIG_AsPtr_std_string(args[0], &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPBundleTransport_AddRemoteCandidate" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTPBundleTransport_AddRemoteCandidate" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      arg2 = ptr;
    }
    res3 = SWIG_AsCharPtrAndSize(args[1], &buf3, NULL, &alloc3);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RTPBundleTransport_AddRemoteCandidate" "', argument " "3"" of type '" "char const *""'");
    }
    arg3 = reinterpret_cast< char * >(buf3);
    ecode4 = SWIG_AsVal_unsigned_SS_short(args[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RTPBundleTransport_AddRemoteCandidate" "', argument " "4"" of type '" "uint16_t""'");
    } 
    arg4 = static_cast< uint16_t >(val4);
    result = (int)(arg1)->AddRemoteCandidate((std::string const &)*arg2,(char const *)arg3,arg4);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (SWIG_IsNewObj(res2)) delete arg2;
    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_SetAffinity(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    int arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int val2 ;
    int ecode2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPBundleTransport_SetAffinity.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_SetAffinity" "', argument " "1"" of type '" "RTPBundleTransport *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    ecode2 = SWIG_AsVal_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPBundleTransport_SetAffinity" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
    result = (bool)(arg1)->SetAffinity(arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_SetIceTimeout(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    uint32_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned int val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPBundleTransport_SetIceTimeout.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_SetIceTimeout" "', argument " "1"" of type '" "RTPBundleTransport *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPBundleTransport_SetIceTimeout" "', argument " "2"" of type '" "uint32_t""'");
    } 
    arg2 = static_cast< uint32_t >(val2);
    (arg1)->SetIceTimeout(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPBundleTransport_GetTimeService(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPBundleTransport *arg1 = (RTPBundleTransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    TimeService *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPBundleTransport_GetTimeService.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPBundleTransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPBundleTransport_GetTimeService" "', argument " "1"" of type '" "RTPBundleTransport *""'"); 
    }
    arg1 = reinterpret_cast< RTPBundleTransport * >(argp1);
    result = (TimeService *) &(arg1)->GetTimeService();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeService, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPBundleTransport(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPBundleTransport(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPBundleTransport(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPBundleTransport(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPBundleTransport(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPBundleTransport * arg1 = (RTPBundleTransport *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_UDPReader(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_UDPReader(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_UDPReader(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_UDPReader(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_UDPReader(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              UDPReader * arg1 = (UDPReader *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_UDPReader_Next(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    UDPReader *arg1 = (UDPReader *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint64_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_UDPReader_Next.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_UDPReader, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UDPReader_Next" "', argument " "1"" of type '" "UDPReader *""'"); 
    }
    arg1 = reinterpret_cast< UDPReader * >(argp1);
    result = (uint64_t)(arg1)->Next();
    jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_UDPReader_GetUDPData(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    UDPReader *arg1 = (UDPReader *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint8_t *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_UDPReader_GetUDPData.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_UDPReader, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UDPReader_GetUDPData" "', argument " "1"" of type '" "UDPReader const *""'"); 
    }
    arg1 = reinterpret_cast< UDPReader * >(argp1);
    result = (uint8_t *)((UDPReader const *)arg1)->GetUDPData();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_UDPReader_GetUDPSize(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    UDPReader *arg1 = (UDPReader *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint32_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_UDPReader_GetUDPSize.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_UDPReader, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UDPReader_GetUDPSize" "', argument " "1"" of type '" "UDPReader const *""'"); 
    }
    arg1 = reinterpret_cast< UDPReader * >(argp1);
    result = (uint32_t)((UDPReader const *)arg1)->GetUDPSize();
    jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_UDPReader_Seek(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    UDPReader *arg1 = (UDPReader *) 0 ;
    uint64_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned long long val2 ;
    int ecode2 = 0 ;
    uint64_t result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_UDPReader_Seek.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_UDPReader, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UDPReader_Seek" "', argument " "1"" of type '" "UDPReader *""'"); 
    }
    arg1 = reinterpret_cast< UDPReader * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UDPReader_Seek" "', argument " "2"" of type '" "uint64_t""'");
    } 
    arg2 = static_cast< uint64_t >(val2);
    result = (uint64_t)(arg1)->Seek(arg2);
    jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_UDPReader_Rewind(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    UDPReader *arg1 = (UDPReader *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_UDPReader_Rewind.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_UDPReader, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UDPReader_Rewind" "', argument " "1"" of type '" "UDPReader *""'"); 
    }
    arg1 = reinterpret_cast< UDPReader * >(argp1);
    (arg1)->Rewind();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_UDPReader_Close(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    UDPReader *arg1 = (UDPReader *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_UDPReader_Close.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_UDPReader, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UDPReader_Close" "', argument " "1"" of type '" "UDPReader *""'"); 
    }
    arg1 = reinterpret_cast< UDPReader * >(argp1);
    result = (bool)(arg1)->Close();
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_veto_UDPReader(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class UDPReader can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_PCAPTransportEmulator(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    PCAPTransportEmulator *result;
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_PCAPTransportEmulator.");
    result = (PCAPTransportEmulator *)new PCAPTransportEmulator();
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_PCAPTransportEmulator, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_SetRemoteProperties(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    Properties *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_SetRemoteProperties.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_SetRemoteProperties" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2, SWIGTYPE_p_Properties,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCAPTransportEmulator_SetRemoteProperties" "', argument " "2"" of type '" "Properties const &""'"); 
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PCAPTransportEmulator_SetRemoteProperties" "', argument " "2"" of type '" "Properties const &""'"); 
    }
    arg2 = reinterpret_cast< Properties * >(argp2);
    (arg1)->SetRemoteProperties((Properties const &)*arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_AddIncomingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    RTPIncomingSourceGroup *arg2 = (RTPIncomingSourceGroup *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_AddIncomingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_AddIncomingSourceGroup" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCAPTransportEmulator_AddIncomingSourceGroup" "', argument " "2"" of type '" "RTPIncomingSourceGroup *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingSourceGroup * >(argp2);
    result = (bool)(arg1)->AddIncomingSourceGroup(arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_RemoveIncomingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    RTPIncomingSourceGroup *arg2 = (RTPIncomingSourceGroup *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_RemoveIncomingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_RemoveIncomingSourceGroup" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCAPTransportEmulator_RemoveIncomingSourceGroup" "', argument " "2"" of type '" "RTPIncomingSourceGroup *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingSourceGroup * >(argp2);
    result = (bool)(arg1)->RemoveIncomingSourceGroup(arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_Open(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    char *arg2 = (char *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_Open.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_Open" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCAPTransportEmulator_Open" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    result = (bool)(arg1)->Open((char const *)arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_SetReader(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    UDPReader *arg2 = (UDPReader *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_SetReader.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_SetReader" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_UDPReader, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PCAPTransportEmulator_SetReader" "', argument " "2"" of type '" "UDPReader *""'"); 
    }
    arg2 = reinterpret_cast< UDPReader * >(argp2);
    result = (bool)(arg1)->SetReader(arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_Play(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_Play.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_Play" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    result = (bool)(arg1)->Play();
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_Seek(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    uint64_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned long long val2 ;
    int ecode2 = 0 ;
    uint64_t result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_Seek.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_Seek" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PCAPTransportEmulator_Seek" "', argument " "2"" of type '" "uint64_t""'");
    } 
    arg2 = static_cast< uint64_t >(val2);
    result = (uint64_t)(arg1)->Seek(arg2);
    jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_Stop(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_Stop.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_Stop" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    result = (bool)(arg1)->Stop();
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_Close(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_Close.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_Close" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    result = (bool)(arg1)->Close();
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulator_GetTimeService(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    TimeService *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulator_GetTimeService.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulator_GetTimeService" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    result = (TimeService *) &(arg1)->GetTimeService();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeService, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_PCAPTransportEmulator(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_PCAPTransportEmulator(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_PCAPTransportEmulator(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_PCAPTransportEmulator(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_PCAPTransportEmulator(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              PCAPTransportEmulator * arg1 = (PCAPTransportEmulator *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_DTLSICETransportListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    v8::Handle< v8::Object > arg1 ;
    DTLSICETransportListener *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_DTLSICETransportListener.");
    {
      arg1 = v8::Handle<v8::Object>::Cast(args[0]);
    }
    result = (DTLSICETransportListener *)new DTLSICETransportListener(arg1);
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_DTLSICETransportListener, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_DTLSICETransportListener(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_DTLSICETransportListener(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_DTLSICETransportListener(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_DTLSICETransportListener(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_DTLSICETransportListener(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              DTLSICETransportListener * arg1 = (DTLSICETransportListener *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RemoteRateEstimatorListener(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RemoteRateEstimatorListener(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RemoteRateEstimatorListener(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RemoteRateEstimatorListener(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RemoteRateEstimatorListener(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RemoteRateEstimatorListener * arg1 = (RemoteRateEstimatorListener *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_veto_RemoteRateEstimatorListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class RemoteRateEstimatorListener can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    DTLSICETransportListener *arg2 = (DTLSICETransportListener *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetListener.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetListener" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_DTLSICETransportListener, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_SetListener" "', argument " "2"" of type '" "DTLSICETransportListener *""'"); 
    }
    arg2 = reinterpret_cast< DTLSICETransportListener * >(argp2);
    (arg1)->SetListener(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Start(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_Start.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Start" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    (arg1)->Start();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Stop(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_Stop.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Stop" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    (arg1)->Stop();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetSRTPProtectionProfiles(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    std::string *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 = SWIG_OLDOBJ ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetSRTPProtectionProfiles.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetSRTPProtectionProfiles" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    {
      std::string *ptr = (std::string *)0;
      res2 = SWIG_AsPtr_std_string(args[0], &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_SetSRTPProtectionProfiles" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DTLSICETransport_SetSRTPProtectionProfiles" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      arg2 = ptr;
    }
    (arg1)->SetSRTPProtectionProfiles((std::string const &)*arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    if (SWIG_IsNewObj(res2)) delete arg2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetRemoteProperties(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    Properties *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetRemoteProperties.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetRemoteProperties" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2, SWIGTYPE_p_Properties,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_SetRemoteProperties" "', argument " "2"" of type '" "Properties const &""'"); 
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DTLSICETransport_SetRemoteProperties" "', argument " "2"" of type '" "Properties const &""'"); 
    }
    arg2 = reinterpret_cast< Properties * >(argp2);
    (arg1)->SetRemoteProperties((Properties const &)*arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetLocalProperties(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    Properties *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetLocalProperties.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetLocalProperties" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2, SWIGTYPE_p_Properties,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_SetLocalProperties" "', argument " "2"" of type '" "Properties const &""'"); 
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DTLSICETransport_SetLocalProperties" "', argument " "2"" of type '" "Properties const &""'"); 
    }
    arg2 = reinterpret_cast< Properties * >(argp2);
    (arg1)->SetLocalProperties((Properties const &)*arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SendPLI(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    uint32_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned int val2 ;
    int ecode2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SendPLI.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SendPLI" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DTLSICETransport_SendPLI" "', argument " "2"" of type '" "uint32_t""'");
    } 
    arg2 = static_cast< uint32_t >(val2);
    result = (int)(arg1)->SendPLI(arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Enqueue(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    RTPPacket::shared *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 ;
    int res2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_Enqueue.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Enqueue" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2, SWIGTYPE_p_RTPPacket__shared,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Enqueue" "', argument " "2"" of type '" "RTPPacket::shared const &""'"); 
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DTLSICETransport_Enqueue" "', argument " "2"" of type '" "RTPPacket::shared const &""'"); 
    }
    arg2 = reinterpret_cast< RTPPacket::shared * >(argp2);
    result = (int)(arg1)->Enqueue((RTPPacket::shared const &)*arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_0(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    bool arg4 ;
    bool arg5 ;
    bool arg6 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    bool val4 ;
    int ecode4 = 0 ;
    bool val5 ;
    int ecode5 = 0 ;
    bool val6 ;
    int ecode6 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DTLSICETransport_Dump" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    ecode4 = SWIG_AsVal_bool(args[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DTLSICETransport_Dump" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
    ecode5 = SWIG_AsVal_bool(args[3], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DTLSICETransport_Dump" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
    ecode6 = SWIG_AsVal_bool(args[4], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DTLSICETransport_Dump" "', argument " "6"" of type '" "bool""'");
    } 
    arg6 = static_cast< bool >(val6);
    result = (int)(arg1)->Dump((char const *)arg2,arg3,arg4,arg5,arg6);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_1(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    bool arg4 ;
    bool arg5 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    bool val4 ;
    int ecode4 = 0 ;
    bool val5 ;
    int ecode5 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DTLSICETransport_Dump" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    ecode4 = SWIG_AsVal_bool(args[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DTLSICETransport_Dump" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
    ecode5 = SWIG_AsVal_bool(args[3], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DTLSICETransport_Dump" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
    result = (int)(arg1)->Dump((char const *)arg2,arg3,arg4,arg5);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_2(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    bool arg4 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    bool val4 ;
    int ecode4 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DTLSICETransport_Dump" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    ecode4 = SWIG_AsVal_bool(args[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DTLSICETransport_Dump" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
    result = (int)(arg1)->Dump((char const *)arg2,arg3,arg4);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_3(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    char *arg2 = (char *) 0 ;
    bool arg3 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DTLSICETransport_Dump" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    result = (int)(arg1)->Dump((char const *)arg2,arg3);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_4(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    char *arg2 = (char *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    result = (int)(arg1)->Dump((char const *)arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_5(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    UDPDumper *arg2 = (UDPDumper *) 0 ;
    bool arg3 ;
    bool arg4 ;
    bool arg5 ;
    bool arg6 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    bool val4 ;
    int ecode4 = 0 ;
    bool val5 ;
    int ecode5 = 0 ;
    bool val6 ;
    int ecode6 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_UDPDumper, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "UDPDumper *""'"); 
    }
    arg2 = reinterpret_cast< UDPDumper * >(argp2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DTLSICETransport_Dump" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    ecode4 = SWIG_AsVal_bool(args[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DTLSICETransport_Dump" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
    ecode5 = SWIG_AsVal_bool(args[3], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DTLSICETransport_Dump" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
    ecode6 = SWIG_AsVal_bool(args[4], &val6);
    if (!SWIG_IsOK(ecode6)) {
      SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "DTLSICETransport_Dump" "', argument " "6"" of type '" "bool""'");
    } 
    arg6 = static_cast< bool >(val6);
    result = (int)(arg1)->Dump(arg2,arg3,arg4,arg5,arg6);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_6(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    UDPDumper *arg2 = (UDPDumper *) 0 ;
    bool arg3 ;
    bool arg4 ;
    bool arg5 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    bool val4 ;
    int ecode4 = 0 ;
    bool val5 ;
    int ecode5 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_UDPDumper, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "UDPDumper *""'"); 
    }
    arg2 = reinterpret_cast< UDPDumper * >(argp2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DTLSICETransport_Dump" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    ecode4 = SWIG_AsVal_bool(args[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DTLSICETransport_Dump" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
    ecode5 = SWIG_AsVal_bool(args[3], &val5);
    if (!SWIG_IsOK(ecode5)) {
      SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "DTLSICETransport_Dump" "', argument " "5"" of type '" "bool""'");
    } 
    arg5 = static_cast< bool >(val5);
    result = (int)(arg1)->Dump(arg2,arg3,arg4,arg5);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_7(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    UDPDumper *arg2 = (UDPDumper *) 0 ;
    bool arg3 ;
    bool arg4 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    bool val4 ;
    int ecode4 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_UDPDumper, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "UDPDumper *""'"); 
    }
    arg2 = reinterpret_cast< UDPDumper * >(argp2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DTLSICETransport_Dump" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    ecode4 = SWIG_AsVal_bool(args[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DTLSICETransport_Dump" "', argument " "4"" of type '" "bool""'");
    } 
    arg4 = static_cast< bool >(val4);
    result = (int)(arg1)->Dump(arg2,arg3,arg4);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_8(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    UDPDumper *arg2 = (UDPDumper *) 0 ;
    bool arg3 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_UDPDumper, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "UDPDumper *""'"); 
    }
    arg2 = reinterpret_cast< UDPDumper * >(argp2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DTLSICETransport_Dump" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    result = (int)(arg1)->Dump(arg2,arg3);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Dump__SWIG_9(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    UDPDumper *arg2 = (UDPDumper *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    int result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Dump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_UDPDumper, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_Dump" "', argument " "2"" of type '" "UDPDumper *""'"); 
    }
    arg2 = reinterpret_cast< UDPDumper * >(argp2);
    result = (int)(arg1)->Dump(arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport__wrap_DTLSICETransport_Dump(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    OverloadErrorHandler errorHandler;
    
    
    if(args.Length() == 5) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 4) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 3) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_2(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_2(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 2) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_3(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_3(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_4(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_4(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 5) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_5(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_5(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 4) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_6(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_6(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 3) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_7(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_7(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 2) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_8(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_8(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_DTLSICETransport_Dump__SWIG_9(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_DTLSICETransport_Dump__SWIG_9(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for function Dump.");
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_StopDump(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_StopDump.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_StopDump" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (int)(arg1)->StopDump();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_DumpBWEStats(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    char *arg2 = (char *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_DumpBWEStats.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_DumpBWEStats" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_DumpBWEStats" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    result = (int)(arg1)->DumpBWEStats((char const *)arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_StopDumpBWEStats(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_StopDumpBWEStats.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_StopDumpBWEStats" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (int)(arg1)->StopDumpBWEStats();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_Reset(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_Reset.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_Reset" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    (arg1)->Reset();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_ActivateRemoteCandidate(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    ICERemoteCandidate *arg2 = (ICERemoteCandidate *) 0 ;
    bool arg3 ;
    uint32_t arg4 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    unsigned int val4 ;
    int ecode4 = 0 ;
    
    if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_ActivateRemoteCandidate.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_ActivateRemoteCandidate" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_ICERemoteCandidate, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_ActivateRemoteCandidate" "', argument " "2"" of type '" "ICERemoteCandidate *""'"); 
    }
    arg2 = reinterpret_cast< ICERemoteCandidate * >(argp2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "DTLSICETransport_ActivateRemoteCandidate" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    ecode4 = SWIG_AsVal_unsigned_SS_int(args[2], &val4);
    if (!SWIG_IsOK(ecode4)) {
      SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "DTLSICETransport_ActivateRemoteCandidate" "', argument " "4"" of type '" "uint32_t""'");
    } 
    arg4 = static_cast< uint32_t >(val4);
    (arg1)->ActivateRemoteCandidate(arg2,arg3,arg4);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetRemoteCryptoDTLS(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    char *arg4 = (char *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    int res3 ;
    char *buf3 = 0 ;
    int alloc3 = 0 ;
    int res4 ;
    char *buf4 = 0 ;
    int alloc4 = 0 ;
    int result;
    
    if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetRemoteCryptoDTLS.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetRemoteCryptoDTLS" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_SetRemoteCryptoDTLS" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    res3 = SWIG_AsCharPtrAndSize(args[1], &buf3, NULL, &alloc3);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DTLSICETransport_SetRemoteCryptoDTLS" "', argument " "3"" of type '" "char const *""'");
    }
    arg3 = reinterpret_cast< char * >(buf3);
    res4 = SWIG_AsCharPtrAndSize(args[2], &buf4, NULL, &alloc4);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "DTLSICETransport_SetRemoteCryptoDTLS" "', argument " "4"" of type '" "char const *""'");
    }
    arg4 = reinterpret_cast< char * >(buf4);
    result = (int)(arg1)->SetRemoteCryptoDTLS((char const *)arg2,(char const *)arg3,(char const *)arg4);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetLocalSTUNCredentials(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    int res3 ;
    char *buf3 = 0 ;
    int alloc3 = 0 ;
    int result;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetLocalSTUNCredentials.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetLocalSTUNCredentials" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_SetLocalSTUNCredentials" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    res3 = SWIG_AsCharPtrAndSize(args[1], &buf3, NULL, &alloc3);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DTLSICETransport_SetLocalSTUNCredentials" "', argument " "3"" of type '" "char const *""'");
    }
    arg3 = reinterpret_cast< char * >(buf3);
    result = (int)(arg1)->SetLocalSTUNCredentials((char const *)arg2,(char const *)arg3);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetRemoteSTUNCredentials(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    char *arg2 = (char *) 0 ;
    char *arg3 = (char *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    int res3 ;
    char *buf3 = 0 ;
    int alloc3 = 0 ;
    int result;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetRemoteSTUNCredentials.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetRemoteSTUNCredentials" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_SetRemoteSTUNCredentials" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    res3 = SWIG_AsCharPtrAndSize(args[1], &buf3, NULL, &alloc3);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "DTLSICETransport_SetRemoteSTUNCredentials" "', argument " "3"" of type '" "char const *""'");
    }
    arg3 = reinterpret_cast< char * >(buf3);
    result = (int)(arg1)->SetRemoteSTUNCredentials((char const *)arg2,(char const *)arg3);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_AddOutgoingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    RTPOutgoingSourceGroup *arg2 = (RTPOutgoingSourceGroup *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_AddOutgoingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_AddOutgoingSourceGroup" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_AddOutgoingSourceGroup" "', argument " "2"" of type '" "RTPOutgoingSourceGroup *""'"); 
    }
    arg2 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp2);
    result = (bool)(arg1)->AddOutgoingSourceGroup(arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_RemoveOutgoingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    RTPOutgoingSourceGroup *arg2 = (RTPOutgoingSourceGroup *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_RemoveOutgoingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_RemoveOutgoingSourceGroup" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_RemoveOutgoingSourceGroup" "', argument " "2"" of type '" "RTPOutgoingSourceGroup *""'"); 
    }
    arg2 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp2);
    result = (bool)(arg1)->RemoveOutgoingSourceGroup(arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_AddIncomingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    RTPIncomingSourceGroup *arg2 = (RTPIncomingSourceGroup *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_AddIncomingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_AddIncomingSourceGroup" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_AddIncomingSourceGroup" "', argument " "2"" of type '" "RTPIncomingSourceGroup *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingSourceGroup * >(argp2);
    result = (bool)(arg1)->AddIncomingSourceGroup(arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_RemoveIncomingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    RTPIncomingSourceGroup *arg2 = (RTPIncomingSourceGroup *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_RemoveIncomingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_RemoveIncomingSourceGroup" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_RemoveIncomingSourceGroup" "', argument " "2"" of type '" "RTPIncomingSourceGroup *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingSourceGroup * >(argp2);
    result = (bool)(arg1)->RemoveIncomingSourceGroup(arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetBandwidthProbing(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    bool arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetBandwidthProbing.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetBandwidthProbing" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    ecode2 = SWIG_AsVal_bool(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DTLSICETransport_SetBandwidthProbing" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
    (arg1)->SetBandwidthProbing(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetMaxProbingBitrate(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    uint32_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned int val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetMaxProbingBitrate.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetMaxProbingBitrate" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DTLSICETransport_SetMaxProbingBitrate" "', argument " "2"" of type '" "uint32_t""'");
    } 
    arg2 = static_cast< uint32_t >(val2);
    (arg1)->SetMaxProbingBitrate(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetProbingBitrateLimit(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    uint32_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned int val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetProbingBitrateLimit.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetProbingBitrateLimit" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DTLSICETransport_SetProbingBitrateLimit" "', argument " "2"" of type '" "uint32_t""'");
    } 
    arg2 = static_cast< uint32_t >(val2);
    (arg1)->SetProbingBitrateLimit(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_SetSenderSideEstimatorListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    RemoteRateEstimatorListener *arg2 = (RemoteRateEstimatorListener *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_SetSenderSideEstimatorListener.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_SetSenderSideEstimatorListener" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RemoteRateEstimatorListener, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DTLSICETransport_SetSenderSideEstimatorListener" "', argument " "2"" of type '" "RemoteRateEstimatorListener *""'"); 
    }
    arg2 = reinterpret_cast< RemoteRateEstimatorListener * >(argp2);
    (arg1)->SetSenderSideEstimatorListener(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_GetRemoteUsername(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    char *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_GetRemoteUsername.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_GetRemoteUsername" "', argument " "1"" of type '" "DTLSICETransport const *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (char *)((DTLSICETransport const *)arg1)->GetRemoteUsername();
    jsresult = SWIG_FromCharPtr((const char *)result);
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_GetRemotePwd(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    char *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_GetRemotePwd.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_GetRemotePwd" "', argument " "1"" of type '" "DTLSICETransport const *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (char *)((DTLSICETransport const *)arg1)->GetRemotePwd();
    jsresult = SWIG_FromCharPtr((const char *)result);
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_GetLocalUsername(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    char *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_GetLocalUsername.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_GetLocalUsername" "', argument " "1"" of type '" "DTLSICETransport const *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (char *)((DTLSICETransport const *)arg1)->GetLocalUsername();
    jsresult = SWIG_FromCharPtr((const char *)result);
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_GetLocalPwd(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    char *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_GetLocalPwd.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_GetLocalPwd" "', argument " "1"" of type '" "DTLSICETransport const *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (char *)((DTLSICETransport const *)arg1)->GetLocalPwd();
    jsresult = SWIG_FromCharPtr((const char *)result);
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_GetRTT(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint32_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_GetRTT.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_GetRTT" "', argument " "1"" of type '" "DTLSICETransport const *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (uint32_t)((DTLSICETransport const *)arg1)->GetRTT();
    jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_DTLSICETransport_GetTimeService(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    TimeService *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_DTLSICETransport_GetTimeService.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DTLSICETransport_GetTimeService" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (TimeService *) &(arg1)->GetTimeService();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_TimeService, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_DTLSICETransport(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_DTLSICETransport(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_DTLSICETransport(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_DTLSICETransport(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_DTLSICETransport(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              DTLSICETransport * arg1 = (DTLSICETransport *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_veto_DTLSICETransport(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class DTLSICETransport can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPSessionFacade(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    MediaFrameType arg1 ;
    int val1 ;
    int ecode1 = 0 ;
    RTPSessionFacade *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPSessionFacade.");
    ecode1 = SWIG_AsVal_int(args[0], &val1);
    if (!SWIG_IsOK(ecode1)) {
      SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RTPSessionFacade" "', argument " "1"" of type '" "MediaFrameType""'");
    } 
    arg1 = static_cast< MediaFrameType >(val1);
    result = (RTPSessionFacade *)new RTPSessionFacade(arg1);
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPSessionFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSessionFacade_Init(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    Properties *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 ;
    int res2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSessionFacade_Init.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSessionFacade_Init" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2, SWIGTYPE_p_Properties,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPSessionFacade_Init" "', argument " "2"" of type '" "Properties const &""'"); 
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTPSessionFacade_Init" "', argument " "2"" of type '" "Properties const &""'"); 
    }
    arg2 = reinterpret_cast< Properties * >(argp2);
    result = (int)(arg1)->Init((Properties const &)*arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSessionFacade_SetLocalPort(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    int arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int val2 ;
    int ecode2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSessionFacade_SetLocalPort.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSessionFacade_SetLocalPort" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    ecode2 = SWIG_AsVal_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSessionFacade_SetLocalPort" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
    result = (int)(arg1)->SetLocalPort(arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSessionFacade_GetLocalPort(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSessionFacade_GetLocalPort.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSessionFacade_GetLocalPort" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    result = (int)(arg1)->GetLocalPort();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSessionFacade_SetRemotePort(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    char *arg2 = (char *) 0 ;
    int arg3 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    int val3 ;
    int ecode3 = 0 ;
    int result;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSessionFacade_SetRemotePort.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSessionFacade_SetRemotePort" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPSessionFacade_SetRemotePort" "', argument " "2"" of type '" "char *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    ecode3 = SWIG_AsVal_int(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RTPSessionFacade_SetRemotePort" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
    result = (int)(arg1)->SetRemotePort(arg2,arg3);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSessionFacade_GetOutgoingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPOutgoingSourceGroup *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSessionFacade_GetOutgoingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSessionFacade_GetOutgoingSourceGroup" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    result = (RTPOutgoingSourceGroup *)(arg1)->GetOutgoingSourceGroup();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSessionFacade_GetIncomingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPIncomingSourceGroup *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSessionFacade_GetIncomingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSessionFacade_GetIncomingSourceGroup" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    result = (RTPIncomingSourceGroup *)(arg1)->GetIncomingSourceGroup();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSessionFacade_End(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSessionFacade_End.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSessionFacade_End" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    result = (int)(arg1)->End();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSessionFacade_Enqueue(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    RTPPacket::shared *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 ;
    int res2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSessionFacade_Enqueue.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSessionFacade_Enqueue" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2, SWIGTYPE_p_RTPPacket__shared,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPSessionFacade_Enqueue" "', argument " "2"" of type '" "RTPPacket::shared const &""'"); 
    }
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTPSessionFacade_Enqueue" "', argument " "2"" of type '" "RTPPacket::shared const &""'"); 
    }
    arg2 = reinterpret_cast< RTPPacket::shared * >(argp2);
    result = (int)(arg1)->Enqueue((RTPPacket::shared const &)*arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSessionFacade_SendPLI(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    uint32_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned int val2 ;
    int ecode2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSessionFacade_SendPLI.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSessionFacade_SendPLI" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPSessionFacade_SendPLI" "', argument " "2"" of type '" "uint32_t""'");
    } 
    arg2 = static_cast< uint32_t >(val2);
    result = (int)(arg1)->SendPLI(arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPSessionFacade(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPSessionFacade(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPSessionFacade(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPSessionFacade(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPSessionFacade(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPSessionFacade * arg1 = (RTPSessionFacade *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_RTPSenderFacade__SWIG_0(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPSenderFacade *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPSenderFacade__SWIG_0.");
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RTPSenderFacade" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (RTPSenderFacade *)new RTPSenderFacade(arg1);
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPSenderFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPSenderFacade__SWIG_1(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPSenderFacade *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPSenderFacade__SWIG_1.");
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RTPSenderFacade" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    result = (RTPSenderFacade *)new RTPSenderFacade(arg1);
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPSenderFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPSenderFacade(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    OverloadErrorHandler errorHandler;
    v8::Handle<v8::Value> self;
    
    // switch all cases by means of series of if-returns.
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      self = _wrap_new_RTPSenderFacade__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(self);
      }
  #else
      _wrap_new_RTPSenderFacade__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      self = _wrap_new_RTPSenderFacade__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(self);
      }
  #else
      _wrap_new_RTPSenderFacade__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    // default:
    SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for construction of _exports_RTPSenderFacade");
    
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPSenderFacade_get(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSenderFacade *arg1 = (RTPSenderFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPSender *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPSenderFacade_get.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPSenderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPSenderFacade_get" "', argument " "1"" of type '" "RTPSenderFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSenderFacade * >(argp1);
    result = (RTPSender *)(arg1)->get();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPSender, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPSenderFacade(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPSenderFacade(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPSenderFacade(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPSenderFacade(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPSenderFacade(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPSenderFacade * arg1 = (RTPSenderFacade *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_RTPReceiverFacade__SWIG_0(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPReceiverFacade *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPReceiverFacade__SWIG_0.");
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RTPReceiverFacade" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (RTPReceiverFacade *)new RTPReceiverFacade(arg1);
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPReceiverFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPReceiverFacade__SWIG_1(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPReceiverFacade *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPReceiverFacade__SWIG_1.");
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RTPReceiverFacade" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    result = (RTPReceiverFacade *)new RTPReceiverFacade(arg1);
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPReceiverFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPReceiverFacade__SWIG_2(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPReceiverFacade *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPReceiverFacade__SWIG_2.");
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RTPReceiverFacade" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    result = (RTPReceiverFacade *)new RTPReceiverFacade(arg1);
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPReceiverFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPReceiverFacade(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    OverloadErrorHandler errorHandler;
    v8::Handle<v8::Value> self;
    
    // switch all cases by means of series of if-returns.
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      self = _wrap_new_RTPReceiverFacade__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(self);
      }
  #else
      _wrap_new_RTPReceiverFacade__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      self = _wrap_new_RTPReceiverFacade__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(self);
      }
  #else
      _wrap_new_RTPReceiverFacade__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      self = _wrap_new_RTPReceiverFacade__SWIG_2(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(self);
      }
  #else
      _wrap_new_RTPReceiverFacade__SWIG_2(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    // default:
    SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for construction of _exports_RTPReceiverFacade");
    
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPReceiverFacade_get(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPReceiverFacade *arg1 = (RTPReceiverFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPReceiver *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPReceiverFacade_get.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPReceiverFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPReceiverFacade_get" "', argument " "1"" of type '" "RTPReceiverFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPReceiverFacade * >(argp1);
    result = (RTPReceiver *)(arg1)->get();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPReceiver, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPReceiverFacade_SendPLI(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPReceiverFacade *arg1 = (RTPReceiverFacade *) 0 ;
    uint32_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned int val2 ;
    int ecode2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPReceiverFacade_SendPLI.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPReceiverFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPReceiverFacade_SendPLI" "', argument " "1"" of type '" "RTPReceiverFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPReceiverFacade * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPReceiverFacade_SendPLI" "', argument " "2"" of type '" "uint32_t""'");
    } 
    arg2 = static_cast< uint32_t >(val2);
    result = (int)(arg1)->SendPLI(arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPReceiverFacade(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPReceiverFacade(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPReceiverFacade(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPReceiverFacade(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPReceiverFacade(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPReceiverFacade * arg1 = (RTPReceiverFacade *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_TransportToSender(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPSenderFacade *result = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_TransportToSender.");
    
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportToSender" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (RTPSenderFacade *)TransportToSender(arg1);
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPSenderFacade, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_TransportToReceiver(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    DTLSICETransport *arg1 = (DTLSICETransport *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPReceiverFacade *result = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_TransportToReceiver.");
    
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_DTLSICETransport, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TransportToReceiver" "', argument " "1"" of type '" "DTLSICETransport *""'"); 
    }
    arg1 = reinterpret_cast< DTLSICETransport * >(argp1);
    result = (RTPReceiverFacade *)TransportToReceiver(arg1);
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPReceiverFacade, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PCAPTransportEmulatorToReceiver(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PCAPTransportEmulator *arg1 = (PCAPTransportEmulator *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPReceiverFacade *result = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PCAPTransportEmulatorToReceiver.");
    
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_PCAPTransportEmulator, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PCAPTransportEmulatorToReceiver" "', argument " "1"" of type '" "PCAPTransportEmulator *""'"); 
    }
    arg1 = reinterpret_cast< PCAPTransportEmulator * >(argp1);
    result = (RTPReceiverFacade *)PCAPTransportEmulatorToReceiver(arg1);
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPReceiverFacade, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_SessionToSender(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPSenderFacade *result = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_SessionToSender.");
    
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionToSender" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    result = (RTPSenderFacade *)SessionToSender(arg1);
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPSenderFacade, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_SessionToReceiver(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPSessionFacade *arg1 = (RTPSessionFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPReceiverFacade *result = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_SessionToReceiver.");
    
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_RTPSessionFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SessionToReceiver" "', argument " "1"" of type '" "RTPSessionFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPSessionFacade * >(argp1);
    result = (RTPReceiverFacade *)SessionToReceiver(arg1);
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPReceiverFacade, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPStreamTransponderFacade(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    RTPOutgoingSourceGroup *arg1 = (RTPOutgoingSourceGroup *) 0 ;
    RTPSenderFacade *arg2 = (RTPSenderFacade *) 0 ;
    v8::Handle< v8::Object > arg3 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    RTPStreamTransponderFacade *result;
    if(args.Length() != 3) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPStreamTransponderFacade.");
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_RTPOutgoingSourceGroup, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RTPStreamTransponderFacade" "', argument " "1"" of type '" "RTPOutgoingSourceGroup *""'"); 
    }
    arg1 = reinterpret_cast< RTPOutgoingSourceGroup * >(argp1);
    res2 = SWIG_ConvertPtr(args[1], &argp2,SWIGTYPE_p_RTPSenderFacade, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_RTPStreamTransponderFacade" "', argument " "2"" of type '" "RTPSenderFacade *""'"); 
    }
    arg2 = reinterpret_cast< RTPSenderFacade * >(argp2);
    {
      arg3 = v8::Handle<v8::Object>::Cast(args[2]);
    }
    result = (RTPStreamTransponderFacade *)new RTPStreamTransponderFacade(arg1,arg2,arg3);
    
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPStreamTransponderFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPStreamTransponderFacade_SetIncoming__SWIG_0(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPStreamTransponderFacade *arg1 = (RTPStreamTransponderFacade *) 0 ;
    RTPIncomingMediaStream *arg2 = (RTPIncomingMediaStream *) 0 ;
    RTPReceiverFacade *arg3 = (RTPReceiverFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    void *argp3 = 0 ;
    int res3 = 0 ;
    bool result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPStreamTransponderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPStreamTransponderFacade_SetIncoming" "', argument " "1"" of type '" "RTPStreamTransponderFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPStreamTransponderFacade * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingMediaStream, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPStreamTransponderFacade_SetIncoming" "', argument " "2"" of type '" "RTPIncomingMediaStream *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingMediaStream * >(argp2);
    res3 = SWIG_ConvertPtr(args[1], &argp3,SWIGTYPE_p_RTPReceiverFacade, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RTPStreamTransponderFacade_SetIncoming" "', argument " "3"" of type '" "RTPReceiverFacade *""'"); 
    }
    arg3 = reinterpret_cast< RTPReceiverFacade * >(argp3);
    result = (bool)(arg1)->SetIncoming(arg2,arg3);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPStreamTransponderFacade_SetIncoming__SWIG_1(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPStreamTransponderFacade *arg1 = (RTPStreamTransponderFacade *) 0 ;
    RTPIncomingMediaStream *arg2 = (RTPIncomingMediaStream *) 0 ;
    RTPReceiver *arg3 = (RTPReceiver *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    void *argp3 = 0 ;
    int res3 = 0 ;
    bool result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPStreamTransponderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPStreamTransponderFacade_SetIncoming" "', argument " "1"" of type '" "RTPStreamTransponderFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPStreamTransponderFacade * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingMediaStream, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPStreamTransponderFacade_SetIncoming" "', argument " "2"" of type '" "RTPIncomingMediaStream *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingMediaStream * >(argp2);
    res3 = SWIG_ConvertPtr(args[1], &argp3,SWIGTYPE_p_RTPReceiver, 0 |  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "RTPStreamTransponderFacade_SetIncoming" "', argument " "3"" of type '" "RTPReceiver *""'"); 
    }
    arg3 = reinterpret_cast< RTPReceiver * >(argp3);
    result = (bool)(arg1)->SetIncoming(arg2,arg3);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPStreamTransponderFacade__wrap_RTPStreamTransponderFacade_SetIncoming(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    OverloadErrorHandler errorHandler;
    
    
    if(args.Length() == 2) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_RTPStreamTransponderFacade_SetIncoming__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_RTPStreamTransponderFacade_SetIncoming__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 2) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_RTPStreamTransponderFacade_SetIncoming__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_RTPStreamTransponderFacade_SetIncoming__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for function SetIncoming.");
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPStreamTransponderFacade_AppendH264ParameterSets(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPStreamTransponderFacade *arg1 = (RTPStreamTransponderFacade *) 0 ;
    std::string *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 = SWIG_OLDOBJ ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPStreamTransponderFacade_AppendH264ParameterSets.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPStreamTransponderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPStreamTransponderFacade_AppendH264ParameterSets" "', argument " "1"" of type '" "RTPStreamTransponderFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPStreamTransponderFacade * >(argp1);
    {
      std::string *ptr = (std::string *)0;
      res2 = SWIG_AsPtr_std_string(args[0], &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPStreamTransponderFacade_AppendH264ParameterSets" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RTPStreamTransponderFacade_AppendH264ParameterSets" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      arg2 = ptr;
    }
    result = (bool)(arg1)->AppendH264ParameterSets((std::string const &)*arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    if (SWIG_IsNewObj(res2)) delete arg2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPStreamTransponderFacade_SelectLayer(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPStreamTransponderFacade *arg1 = (RTPStreamTransponderFacade *) 0 ;
    int arg2 ;
    int arg3 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int val2 ;
    int ecode2 = 0 ;
    int val3 ;
    int ecode3 = 0 ;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPStreamTransponderFacade_SelectLayer.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPStreamTransponderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPStreamTransponderFacade_SelectLayer" "', argument " "1"" of type '" "RTPStreamTransponderFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPStreamTransponderFacade * >(argp1);
    ecode2 = SWIG_AsVal_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPStreamTransponderFacade_SelectLayer" "', argument " "2"" of type '" "int""'");
    } 
    arg2 = static_cast< int >(val2);
    ecode3 = SWIG_AsVal_int(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RTPStreamTransponderFacade_SelectLayer" "', argument " "3"" of type '" "int""'");
    } 
    arg3 = static_cast< int >(val3);
    (arg1)->SelectLayer(arg2,arg3);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPStreamTransponderFacade_Mute(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPStreamTransponderFacade *arg1 = (RTPStreamTransponderFacade *) 0 ;
    bool arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPStreamTransponderFacade_Mute.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPStreamTransponderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPStreamTransponderFacade_Mute" "', argument " "1"" of type '" "RTPStreamTransponderFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPStreamTransponderFacade * >(argp1);
    ecode2 = SWIG_AsVal_bool(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RTPStreamTransponderFacade_Mute" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
    (arg1)->Mute(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPStreamTransponderFacade_Close(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPStreamTransponderFacade *arg1 = (RTPStreamTransponderFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPStreamTransponderFacade_Close.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPStreamTransponderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPStreamTransponderFacade_Close" "', argument " "1"" of type '" "RTPStreamTransponderFacade *""'"); 
    }
    arg1 = reinterpret_cast< RTPStreamTransponderFacade * >(argp1);
    (arg1)->Close();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPStreamTransponderFacade(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPStreamTransponderFacade(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPStreamTransponderFacade(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPStreamTransponderFacade(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPStreamTransponderFacade(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPStreamTransponderFacade * arg1 = (RTPStreamTransponderFacade *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_veto_MediaFrameListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    SWIG_exception(SWIG_ERROR, "Class MediaFrameListener can not be instantiated");
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_new_RTPIncomingMediaStreamDepacketizer(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    RTPIncomingMediaStream *arg1 = (RTPIncomingMediaStream *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPIncomingMediaStreamDepacketizer *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_RTPIncomingMediaStreamDepacketizer.");
    res1 = SWIG_ConvertPtr(args[0], &argp1,SWIGTYPE_p_RTPIncomingMediaStream, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_RTPIncomingMediaStreamDepacketizer" "', argument " "1"" of type '" "RTPIncomingMediaStream *""'"); 
    }
    arg1 = reinterpret_cast< RTPIncomingMediaStream * >(argp1);
    result = (RTPIncomingMediaStreamDepacketizer *)new RTPIncomingMediaStreamDepacketizer(arg1);
    
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_RTPIncomingMediaStreamDepacketizer, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPIncomingMediaStreamDepacketizer_AddMediaListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPIncomingMediaStreamDepacketizer *arg1 = (RTPIncomingMediaStreamDepacketizer *) 0 ;
    MediaFrameListener *arg2 = (MediaFrameListener *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPIncomingMediaStreamDepacketizer_AddMediaListener.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPIncomingMediaStreamDepacketizer, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingMediaStreamDepacketizer_AddMediaListener" "', argument " "1"" of type '" "RTPIncomingMediaStreamDepacketizer *""'"); 
    }
    arg1 = reinterpret_cast< RTPIncomingMediaStreamDepacketizer * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_MediaFrameListener, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPIncomingMediaStreamDepacketizer_AddMediaListener" "', argument " "2"" of type '" "MediaFrameListener *""'"); 
    }
    arg2 = reinterpret_cast< MediaFrameListener * >(argp2);
    (arg1)->AddMediaListener(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPIncomingMediaStreamDepacketizer_RemoveMediaListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPIncomingMediaStreamDepacketizer *arg1 = (RTPIncomingMediaStreamDepacketizer *) 0 ;
    MediaFrameListener *arg2 = (MediaFrameListener *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPIncomingMediaStreamDepacketizer_RemoveMediaListener.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPIncomingMediaStreamDepacketizer, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingMediaStreamDepacketizer_RemoveMediaListener" "', argument " "1"" of type '" "RTPIncomingMediaStreamDepacketizer *""'"); 
    }
    arg1 = reinterpret_cast< RTPIncomingMediaStreamDepacketizer * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_MediaFrameListener, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RTPIncomingMediaStreamDepacketizer_RemoveMediaListener" "', argument " "2"" of type '" "MediaFrameListener *""'"); 
    }
    arg2 = reinterpret_cast< MediaFrameListener * >(argp2);
    (arg1)->RemoveMediaListener(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_RTPIncomingMediaStreamDepacketizer_Stop(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    RTPIncomingMediaStreamDepacketizer *arg1 = (RTPIncomingMediaStreamDepacketizer *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_RTPIncomingMediaStreamDepacketizer_Stop.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_RTPIncomingMediaStreamDepacketizer, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RTPIncomingMediaStreamDepacketizer_Stop" "', argument " "1"" of type '" "RTPIncomingMediaStreamDepacketizer *""'"); 
    }
    arg1 = reinterpret_cast< RTPIncomingMediaStreamDepacketizer * >(argp1);
    (arg1)->Stop();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_RTPIncomingMediaStreamDepacketizer(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_RTPIncomingMediaStreamDepacketizer(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_RTPIncomingMediaStreamDepacketizer(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_RTPIncomingMediaStreamDepacketizer(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_RTPIncomingMediaStreamDepacketizer(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              RTPIncomingMediaStreamDepacketizer * arg1 = (RTPIncomingMediaStreamDepacketizer *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_MP4RecorderFacade(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    v8::Handle< v8::Object > arg1 ;
    MP4RecorderFacade *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_MP4RecorderFacade.");
    {
      arg1 = v8::Handle<v8::Object>::Cast(args[0]);
    }
    result = (MP4RecorderFacade *)new MP4RecorderFacade(arg1);
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_MP4RecorderFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MP4RecorderFacade_Create(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    MP4RecorderFacade *arg1 = (MP4RecorderFacade *) 0 ;
    char *arg2 = (char *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MP4RecorderFacade_Create.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_MP4RecorderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MP4RecorderFacade_Create" "', argument " "1"" of type '" "MP4RecorderFacade *""'"); 
    }
    arg1 = reinterpret_cast< MP4RecorderFacade * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MP4RecorderFacade_Create" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    result = (bool)(arg1)->Create((char const *)arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MP4RecorderFacade_Record(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    MP4RecorderFacade *arg1 = (MP4RecorderFacade *) 0 ;
    bool arg2 ;
    bool arg3 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool val2 ;
    int ecode2 = 0 ;
    bool val3 ;
    int ecode3 = 0 ;
    bool result;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MP4RecorderFacade_Record.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_MP4RecorderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MP4RecorderFacade_Record" "', argument " "1"" of type '" "MP4RecorderFacade *""'"); 
    }
    arg1 = reinterpret_cast< MP4RecorderFacade * >(argp1);
    ecode2 = SWIG_AsVal_bool(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MP4RecorderFacade_Record" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
    ecode3 = SWIG_AsVal_bool(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MP4RecorderFacade_Record" "', argument " "3"" of type '" "bool""'");
    } 
    arg3 = static_cast< bool >(val3);
    result = (bool)(arg1)->Record(arg2,arg3);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MP4RecorderFacade_Stop(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    MP4RecorderFacade *arg1 = (MP4RecorderFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MP4RecorderFacade_Stop.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_MP4RecorderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MP4RecorderFacade_Stop" "', argument " "1"" of type '" "MP4RecorderFacade *""'"); 
    }
    arg1 = reinterpret_cast< MP4RecorderFacade * >(argp1);
    result = (bool)(arg1)->Stop();
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MP4RecorderFacade_Close__SWIG_0(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    MP4RecorderFacade *arg1 = (MP4RecorderFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_MP4RecorderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MP4RecorderFacade_Close" "', argument " "1"" of type '" "MP4RecorderFacade *""'"); 
    }
    arg1 = reinterpret_cast< MP4RecorderFacade * >(argp1);
    result = (bool)(arg1)->Close();
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MP4RecorderFacade_SetTimeShiftDuration(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    MP4RecorderFacade *arg1 = (MP4RecorderFacade *) 0 ;
    uint32_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned int val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MP4RecorderFacade_SetTimeShiftDuration.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_MP4RecorderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MP4RecorderFacade_SetTimeShiftDuration" "', argument " "1"" of type '" "MP4RecorderFacade *""'"); 
    }
    arg1 = reinterpret_cast< MP4RecorderFacade * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MP4RecorderFacade_SetTimeShiftDuration" "', argument " "2"" of type '" "uint32_t""'");
    } 
    arg2 = static_cast< uint32_t >(val2);
    (arg1)->SetTimeShiftDuration(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MP4RecorderFacade_SetH264ParameterSets(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    MP4RecorderFacade *arg1 = (MP4RecorderFacade *) 0 ;
    std::string *arg2 = 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 = SWIG_OLDOBJ ;
    bool result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_MP4RecorderFacade_SetH264ParameterSets.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_MP4RecorderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MP4RecorderFacade_SetH264ParameterSets" "', argument " "1"" of type '" "MP4RecorderFacade *""'"); 
    }
    arg1 = reinterpret_cast< MP4RecorderFacade * >(argp1);
    {
      std::string *ptr = (std::string *)0;
      res2 = SWIG_AsPtr_std_string(args[0], &ptr);
      if (!SWIG_IsOK(res2)) {
        SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MP4RecorderFacade_SetH264ParameterSets" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      if (!ptr) {
        SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MP4RecorderFacade_SetH264ParameterSets" "', argument " "2"" of type '" "std::string const &""'"); 
      }
      arg2 = ptr;
    }
    result = (bool)(arg1)->SetH264ParameterSets((std::string const &)*arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    if (SWIG_IsNewObj(res2)) delete arg2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MP4RecorderFacade_Close__SWIG_1(const SwigV8Arguments &args, V8ErrorHandler &SWIGV8_ErrorHandler)
  {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    MP4RecorderFacade *arg1 = (MP4RecorderFacade *) 0 ;
    bool arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool val2 ;
    int ecode2 = 0 ;
    bool result;
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_MP4RecorderFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MP4RecorderFacade_Close" "', argument " "1"" of type '" "MP4RecorderFacade *""'"); 
    }
    arg1 = reinterpret_cast< MP4RecorderFacade * >(argp1);
    ecode2 = SWIG_AsVal_bool(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MP4RecorderFacade_Close" "', argument " "2"" of type '" "bool""'");
    } 
    arg2 = static_cast< bool >(val2);
    result = (bool)(arg1)->Close(arg2);
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_MP4RecorderFacade__wrap_MP4RecorderFacade_Close(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    OverloadErrorHandler errorHandler;
    
    
    if(args.Length() == 0) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_MP4RecorderFacade_Close__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_MP4RecorderFacade_Close__SWIG_0(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    if(args.Length() == 1) {
      errorHandler.err.Clear();
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
      jsresult = _wrap_MP4RecorderFacade_Close__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        SWIGV8_ESCAPE(jsresult);
      }
  #else
      _wrap_MP4RecorderFacade_Close__SWIG_1(args, errorHandler);
      if(errorHandler.err.IsEmpty()) {
        return;
      }
  #endif
    }
    
    
    SWIG_exception_fail(SWIG_ERROR, "Illegal arguments for function Close.");
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_MP4RecorderFacade(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_MP4RecorderFacade(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_MP4RecorderFacade(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_MP4RecorderFacade(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_MP4RecorderFacade(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              MP4RecorderFacade * arg1 = (MP4RecorderFacade *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_PlayerFacade(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    v8::Handle< v8::Object > arg1 ;
    PlayerFacade *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_PlayerFacade.");
    {
      arg1 = v8::Handle<v8::Object>::Cast(args[0]);
    }
    result = (PlayerFacade *)new PlayerFacade(arg1);
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_PlayerFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_GetAudioSource(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPIncomingSourceGroup *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_GetAudioSource.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_GetAudioSource" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (RTPIncomingSourceGroup *)(arg1)->GetAudioSource();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_GetVideoSource(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    RTPIncomingSourceGroup *result = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_GetVideoSource.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_GetVideoSource" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (RTPIncomingSourceGroup *)(arg1)->GetVideoSource();
    jsresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_RTPIncomingSourceGroup, 0 |  0 );
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_Reset(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_Reset.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_Reset" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    (arg1)->Reset();
    jsresult = SWIGV8_UNDEFINED();
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_Open(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    char *arg2 = (char *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int res2 ;
    char *buf2 = 0 ;
    int alloc2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_Open.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_Open" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    res2 = SWIG_AsCharPtrAndSize(args[0], &buf2, NULL, &alloc2);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PlayerFacade_Open" "', argument " "2"" of type '" "char const *""'");
    }
    arg2 = reinterpret_cast< char * >(buf2);
    result = (int)(arg1)->Open((char const *)arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_HasAudioTrack(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_HasAudioTrack.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_HasAudioTrack" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (bool)(arg1)->HasAudioTrack();
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_HasVideoTrack(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    bool result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_HasVideoTrack.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_HasVideoTrack" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (bool)(arg1)->HasVideoTrack();
    jsresult = SWIG_From_bool(static_cast< bool >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_GetAudioCodec(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint32_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_GetAudioCodec.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_GetAudioCodec" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (uint32_t)(arg1)->GetAudioCodec();
    jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_GetVideoCodec(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint32_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_GetVideoCodec.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_GetVideoCodec" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (uint32_t)(arg1)->GetVideoCodec();
    jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_GetDuration(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    double result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_GetDuration.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_GetDuration" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (double)(arg1)->GetDuration();
    jsresult = SWIG_From_double(static_cast< double >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_GetVideoWidth(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint32_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_GetVideoWidth.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_GetVideoWidth" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (uint32_t)(arg1)->GetVideoWidth();
    jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_GetVideoHeight(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint32_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_GetVideoHeight.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_GetVideoHeight" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (uint32_t)(arg1)->GetVideoHeight();
    jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_GetVideoBitrate(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint32_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_GetVideoBitrate.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_GetVideoBitrate" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (uint32_t)(arg1)->GetVideoBitrate();
    jsresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_GetVideoFramerate(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    double result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_GetVideoFramerate.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_GetVideoFramerate" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (double)(arg1)->GetVideoFramerate();
    jsresult = SWIG_From_double(static_cast< double >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_Play(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_Play.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_Play" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (int)(arg1)->Play();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_PreSeek(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    uint64_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned long long val2 ;
    int ecode2 = 0 ;
    uint64_t result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_PreSeek.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_PreSeek" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlayerFacade_PreSeek" "', argument " "2"" of type '" "uint64_t""'");
    } 
    arg2 = static_cast< uint64_t >(val2);
    result = (uint64_t)(arg1)->PreSeek(arg2);
    jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_Seek(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    uint64_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned long long val2 ;
    int ecode2 = 0 ;
    int result;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_Seek.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_Seek" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PlayerFacade_Seek" "', argument " "2"" of type '" "uint64_t""'");
    } 
    arg2 = static_cast< uint64_t >(val2);
    result = (int)(arg1)->Seek(arg2);
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_Tell(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    uint64_t result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_Tell.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_Tell" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (uint64_t)(arg1)->Tell();
    jsresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_Stop(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_Stop.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_Stop" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (int)(arg1)->Stop();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_PlayerFacade_Close(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    PlayerFacade *arg1 = (PlayerFacade *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int result;
    
    if(args.Length() != 0) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_PlayerFacade_Close.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_PlayerFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PlayerFacade_Close" "', argument " "1"" of type '" "PlayerFacade *""'"); 
    }
    arg1 = reinterpret_cast< PlayerFacade * >(argp1);
    result = (int)(arg1)->Close();
    jsresult = SWIG_From_int(static_cast< int >(result));
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_PlayerFacade(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_PlayerFacade(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_PlayerFacade(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_PlayerFacade(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_PlayerFacade(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              PlayerFacade * arg1 = (PlayerFacade *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_SenderSideEstimatorListener(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    v8::Handle< v8::Object > arg1 ;
    SenderSideEstimatorListener *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_SenderSideEstimatorListener.");
    {
      arg1 = v8::Handle<v8::Object>::Cast(args[0]);
    }
    result = (SenderSideEstimatorListener *)new SenderSideEstimatorListener(arg1);
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_SenderSideEstimatorListener, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_SenderSideEstimatorListener(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_SenderSideEstimatorListener(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_SenderSideEstimatorListener(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_SenderSideEstimatorListener(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_SenderSideEstimatorListener(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              SenderSideEstimatorListener * arg1 = (SenderSideEstimatorListener *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  static SwigV8ReturnValue _wrap_new_ActiveSpeakerDetectorFacade(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> self = args.Holder();
    v8::Handle< v8::Object > arg1 ;
    ActiveSpeakerDetectorFacade *result;
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_new_ActiveSpeakerDetectorFacade.");
    {
      arg1 = v8::Handle<v8::Object>::Cast(args[0]);
    }
    result = (ActiveSpeakerDetectorFacade *)new ActiveSpeakerDetectorFacade(arg1);
    
    
    
    SWIGV8_SetPrivateData(self, result, SWIGTYPE_p_ActiveSpeakerDetectorFacade, SWIG_POINTER_OWN);
    SWIGV8_RETURN(self);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_ActiveSpeakerDetectorFacade_SetMinChangePeriod(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    ActiveSpeakerDetectorFacade *arg1 = (ActiveSpeakerDetectorFacade *) 0 ;
    uint32_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned int val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_ActiveSpeakerDetectorFacade_SetMinChangePeriod.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_ActiveSpeakerDetectorFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveSpeakerDetectorFacade_SetMinChangePeriod" "', argument " "1"" of type '" "ActiveSpeakerDetectorFacade *""'"); 
    }
    arg1 = reinterpret_cast< ActiveSpeakerDetectorFacade * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActiveSpeakerDetectorFacade_SetMinChangePeriod" "', argument " "2"" of type '" "uint32_t""'");
    } 
    arg2 = static_cast< uint32_t >(val2);
    (arg1)->SetMinChangePeriod(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_ActiveSpeakerDetectorFacade_SetMaxAccumulatedScore(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    ActiveSpeakerDetectorFacade *arg1 = (ActiveSpeakerDetectorFacade *) 0 ;
    uint64_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned long long val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_ActiveSpeakerDetectorFacade_SetMaxAccumulatedScore.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_ActiveSpeakerDetectorFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveSpeakerDetectorFacade_SetMaxAccumulatedScore" "', argument " "1"" of type '" "ActiveSpeakerDetectorFacade *""'"); 
    }
    arg1 = reinterpret_cast< ActiveSpeakerDetectorFacade * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActiveSpeakerDetectorFacade_SetMaxAccumulatedScore" "', argument " "2"" of type '" "uint64_t""'");
    } 
    arg2 = static_cast< uint64_t >(val2);
    (arg1)->SetMaxAccumulatedScore(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_ActiveSpeakerDetectorFacade_SetNoiseGatingThreshold(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    ActiveSpeakerDetectorFacade *arg1 = (ActiveSpeakerDetectorFacade *) 0 ;
    uint8_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned char val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_ActiveSpeakerDetectorFacade_SetNoiseGatingThreshold.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_ActiveSpeakerDetectorFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveSpeakerDetectorFacade_SetNoiseGatingThreshold" "', argument " "1"" of type '" "ActiveSpeakerDetectorFacade *""'"); 
    }
    arg1 = reinterpret_cast< ActiveSpeakerDetectorFacade * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_char(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActiveSpeakerDetectorFacade_SetNoiseGatingThreshold" "', argument " "2"" of type '" "uint8_t""'");
    } 
    arg2 = static_cast< uint8_t >(val2);
    (arg1)->SetNoiseGatingThreshold(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_ActiveSpeakerDetectorFacade_SetMinActivationScore(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    ActiveSpeakerDetectorFacade *arg1 = (ActiveSpeakerDetectorFacade *) 0 ;
    uint32_t arg2 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    unsigned int val2 ;
    int ecode2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_ActiveSpeakerDetectorFacade_SetMinActivationScore.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_ActiveSpeakerDetectorFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveSpeakerDetectorFacade_SetMinActivationScore" "', argument " "1"" of type '" "ActiveSpeakerDetectorFacade *""'"); 
    }
    arg1 = reinterpret_cast< ActiveSpeakerDetectorFacade * >(argp1);
    ecode2 = SWIG_AsVal_unsigned_SS_int(args[0], &val2);
    if (!SWIG_IsOK(ecode2)) {
      SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ActiveSpeakerDetectorFacade_SetMinActivationScore" "', argument " "2"" of type '" "uint32_t""'");
    } 
    arg2 = static_cast< uint32_t >(val2);
    (arg1)->SetMinActivationScore(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_ActiveSpeakerDetectorFacade_AddIncomingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    ActiveSpeakerDetectorFacade *arg1 = (ActiveSpeakerDetectorFacade *) 0 ;
    RTPIncomingMediaStream *arg2 = (RTPIncomingMediaStream *) 0 ;
    uint32_t arg3 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    unsigned int val3 ;
    int ecode3 = 0 ;
    
    if(args.Length() != 2) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_ActiveSpeakerDetectorFacade_AddIncomingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_ActiveSpeakerDetectorFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveSpeakerDetectorFacade_AddIncomingSourceGroup" "', argument " "1"" of type '" "ActiveSpeakerDetectorFacade *""'"); 
    }
    arg1 = reinterpret_cast< ActiveSpeakerDetectorFacade * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingMediaStream, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActiveSpeakerDetectorFacade_AddIncomingSourceGroup" "', argument " "2"" of type '" "RTPIncomingMediaStream *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingMediaStream * >(argp2);
    ecode3 = SWIG_AsVal_unsigned_SS_int(args[1], &val3);
    if (!SWIG_IsOK(ecode3)) {
      SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ActiveSpeakerDetectorFacade_AddIncomingSourceGroup" "', argument " "3"" of type '" "uint32_t""'");
    } 
    arg3 = static_cast< uint32_t >(val3);
    (arg1)->AddIncomingSourceGroup(arg2,arg3);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  static SwigV8ReturnValue _wrap_ActiveSpeakerDetectorFacade_RemoveIncomingSourceGroup(const SwigV8Arguments &args) {
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Value> jsresult;
    ActiveSpeakerDetectorFacade *arg1 = (ActiveSpeakerDetectorFacade *) 0 ;
    RTPIncomingMediaStream *arg2 = (RTPIncomingMediaStream *) 0 ;
    void *argp1 = 0 ;
    int res1 = 0 ;
    void *argp2 = 0 ;
    int res2 = 0 ;
    
    if(args.Length() != 1) SWIG_exception_fail(SWIG_ERROR, "Illegal number of arguments for _wrap_ActiveSpeakerDetectorFacade_RemoveIncomingSourceGroup.");
    
    res1 = SWIG_ConvertPtr(args.Holder(), &argp1,SWIGTYPE_p_ActiveSpeakerDetectorFacade, 0 |  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActiveSpeakerDetectorFacade_RemoveIncomingSourceGroup" "', argument " "1"" of type '" "ActiveSpeakerDetectorFacade *""'"); 
    }
    arg1 = reinterpret_cast< ActiveSpeakerDetectorFacade * >(argp1);
    res2 = SWIG_ConvertPtr(args[0], &argp2,SWIGTYPE_p_RTPIncomingMediaStream, 0 |  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ActiveSpeakerDetectorFacade_RemoveIncomingSourceGroup" "', argument " "2"" of type '" "RTPIncomingMediaStream *""'"); 
    }
    arg2 = reinterpret_cast< RTPIncomingMediaStream * >(argp2);
    (arg1)->RemoveIncomingSourceGroup(arg2);
    jsresult = SWIGV8_UNDEFINED();
    
    
    
    SWIGV8_RETURN(jsresult);
    
    goto fail;
  fail:
    SWIGV8_RETURN(SWIGV8_UNDEFINED());
  }
  
  
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
  static void _wrap_delete_ActiveSpeakerDetectorFacade(v8::Persistent<v8::Value> object, void *parameter) {
    SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
    static void _wrap_delete_ActiveSpeakerDetectorFacade(v8::Isolate *isolate, v8::Persistent<v8::Value> object, void *parameter) {
      SWIGV8_Proxy *proxy = static_cast<SWIGV8_Proxy *>(parameter);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
      static void _wrap_delete_ActiveSpeakerDetectorFacade(v8::Isolate *isolate, v8::Persistent< v8::Object> *object, SWIGV8_Proxy *proxy) {
  #elif (V8_MAJOR_VERSION-0) < 5
        static void _wrap_delete_ActiveSpeakerDetectorFacade(const v8::WeakCallbackData<v8::Object, SWIGV8_Proxy> &data) {
          v8::Local<v8::Object> object = data.GetValue();
          SWIGV8_Proxy *proxy = data.GetParameter();
  #else
          static void _wrap_delete_ActiveSpeakerDetectorFacade(const v8::WeakCallbackInfo<SWIGV8_Proxy> &data) {
            SWIGV8_Proxy *proxy = data.GetParameter();
  #endif
            
            if(proxy->swigCMemOwn && proxy->swigCObject) {
              ActiveSpeakerDetectorFacade * arg1 = (ActiveSpeakerDetectorFacade *)proxy->swigCObject;
              delete arg1;
            }
            delete proxy;
            
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031710)
            object.Dispose();
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031900)
            object.Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x032100)
            object->Dispose(isolate);
  #elif (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < SWIGV8_SETWEAK_VERSION)
            object->Dispose();
  #elif (V8_MAJOR_VERSION-0) < 5
            object.Clear();
  #endif
          }
  
  
  /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
  
  static void *_p_LayerSourceTo_p_LayerInfo(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((LayerInfo *)  ((LayerSource *) x));
  }
  static void *_p_PropertiesFacadeTo_p_Properties(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((Properties *)  ((PropertiesFacade *) x));
  }
  static void *_p_RTPIncomingMediaStreamMultiplexerTo_p_RTPIncomingMediaStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((RTPIncomingMediaStream *)  ((RTPIncomingMediaStreamMultiplexer *) x));
  }
  static void *_p_RTPIncomingSourceGroupTo_p_RTPIncomingMediaStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((RTPIncomingMediaStream *)  ((RTPIncomingSourceGroup *) x));
  }
  static void *_p_RTPSessionFacadeTo_p_RTPSender(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((RTPSender *)  ((RTPSessionFacade *) x));
  }
  static void *_p_RTPSessionFacadeTo_p_RTPReceiver(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((RTPReceiver *)  ((RTPSessionFacade *) x));
  }
  static void *_p_RTPIncomingSourceTo_p_RTPSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((RTPSource *)  ((RTPIncomingSource *) x));
  }
  static void *_p_RTPOutgoingSourceTo_p_RTPSource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((RTPSource *)  ((RTPOutgoingSource *) x));
  }
  static void *_p_SenderSideEstimatorListenerTo_p_RemoteRateEstimatorListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((RemoteRateEstimatorListener *)  ((SenderSideEstimatorListener *) x));
  }
  static void *_p_MP4RecorderFacadeTo_p_MediaFrameListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((MediaFrameListener *)  ((MP4RecorderFacade *) x));
  }
  static void *_p_RTPIncomingMediaStreamMultiplexerTo_p_RTPIncomingMediaStreamListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
      return (void *)((RTPIncomingMediaStreamListener *)  ((RTPIncomingMediaStreamMultiplexer *) x));
  }
  static swig_type_info _swigt__p_ActiveSpeakerDetectorFacade = {"_p_ActiveSpeakerDetectorFacade", "p_ActiveSpeakerDetectorFacade|ActiveSpeakerDetectorFacade *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_DTLSICETransport = {"_p_DTLSICETransport", "p_DTLSICETransport|DTLSICETransport *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_DTLSICETransportListener = {"_p_DTLSICETransportListener", "p_DTLSICETransportListener|DTLSICETransportListener *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_ICERemoteCandidate = {"_p_ICERemoteCandidate", "ICERemoteCandidate *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_LayerInfo = {"_p_LayerInfo", "LayerInfo *|p_LayerInfo", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_LayerSource = {"_p_LayerSource", "p_LayerSource|LayerSource *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_LayerSources = {"_p_LayerSources", "LayerSources *|p_LayerSources", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_MP4RecorderFacade = {"_p_MP4RecorderFacade", "p_MP4RecorderFacade|MP4RecorderFacade *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_MediaFrameListener = {"_p_MediaFrameListener", "p_MediaFrameListener|MediaFrameListener *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_MediaServer = {"_p_MediaServer", "p_MediaServer", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_PCAPTransportEmulator = {"_p_PCAPTransportEmulator", "PCAPTransportEmulator *|p_PCAPTransportEmulator", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_PlayerFacade = {"_p_PlayerFacade", "p_PlayerFacade|PlayerFacade *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_Properties = {"_p_Properties", "Properties *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_PropertiesFacade = {"_p_PropertiesFacade", "PropertiesFacade *|p_PropertiesFacade", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPBundleTransport = {"_p_RTPBundleTransport", "p_RTPBundleTransport|RTPBundleTransport *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPBundleTransportConnection = {"_p_RTPBundleTransportConnection", "RTPBundleTransportConnection *|p_RTPBundleTransportConnection", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPIncomingMediaStream = {"_p_RTPIncomingMediaStream", "p_RTPIncomingMediaStream|RTPIncomingMediaStream *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPIncomingMediaStreamDepacketizer = {"_p_RTPIncomingMediaStreamDepacketizer", "p_RTPIncomingMediaStreamDepacketizer|RTPIncomingMediaStreamDepacketizer *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPIncomingMediaStreamListener = {"_p_RTPIncomingMediaStreamListener", "p_RTPIncomingMediaStreamListener|RTPIncomingMediaStreamListener *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPIncomingMediaStreamMultiplexer = {"_p_RTPIncomingMediaStreamMultiplexer", "p_RTPIncomingMediaStreamMultiplexer|RTPIncomingMediaStreamMultiplexer *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPIncomingSource = {"_p_RTPIncomingSource", "p_RTPIncomingSource|RTPIncomingSource *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPIncomingSourceGroup = {"_p_RTPIncomingSourceGroup", "RTPIncomingSourceGroup *|p_RTPIncomingSourceGroup", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPOutgoingSource = {"_p_RTPOutgoingSource", "p_RTPOutgoingSource|RTPOutgoingSource *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPOutgoingSourceGroup = {"_p_RTPOutgoingSourceGroup", "RTPOutgoingSourceGroup *|p_RTPOutgoingSourceGroup", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPPacket__shared = {"_p_RTPPacket__shared", "RTPPacket::shared *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPReceiver = {"_p_RTPReceiver", "RTPReceiver *|p_RTPReceiver", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPReceiverFacade = {"_p_RTPReceiverFacade", "p_RTPReceiverFacade|RTPReceiverFacade *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPSender = {"_p_RTPSender", "RTPSender *|p_RTPSender", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPSenderFacade = {"_p_RTPSenderFacade", "p_RTPSenderFacade|RTPSenderFacade *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPSessionFacade = {"_p_RTPSessionFacade", "p_RTPSessionFacade|RTPSessionFacade *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPSource = {"_p_RTPSource", "p_RTPSource|RTPSource *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RTPStreamTransponderFacade = {"_p_RTPStreamTransponderFacade", "p_RTPStreamTransponderFacade|RTPStreamTransponderFacade *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_RemoteRateEstimatorListener = {"_p_RemoteRateEstimatorListener", "p_RemoteRateEstimatorListener|RemoteRateEstimatorListener *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_SenderSideEstimatorListener = {"_p_SenderSideEstimatorListener", "p_SenderSideEstimatorListener", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_TimeService = {"_p_TimeService", "p_TimeService|TimeService *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_UDPDumper = {"_p_UDPDumper", "UDPDumper *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_UDPReader = {"_p_UDPReader", "p_UDPReader|UDPReader *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_int = {"_p_int", "intptr_t *|int *|int_least32_t *|int_fast32_t *|int32_t *|int_fast16_t *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t *|int_fast64_t *|int64_t *|long long *|intmax_t *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_short = {"_p_short", "short *|int_least16_t *|int16_t *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char *|int_least8_t *|int_fast8_t *|int8_t *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|uint_least8_t *|uint_fast8_t *|uint8_t *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t *|uint_least32_t *|uint_fast32_t *|uint32_t *|unsigned int *|uint_fast16_t *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t *|uint_fast64_t *|uint64_t *|unsigned long long *|uintmax_t *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *|uint_least16_t *|uint16_t *", 0, 0, (void*)0, 0};
  static swig_type_info _swigt__p_v8__HandleT_v8__Object_t = {"_p_v8__HandleT_v8__Object_t", "v8::Handle< v8::Object > *", 0, 0, (void*)0, 0};
  
  static swig_type_info *swig_type_initial[] = {
    &_swigt__p_ActiveSpeakerDetectorFacade,
    &_swigt__p_DTLSICETransport,
    &_swigt__p_DTLSICETransportListener,
    &_swigt__p_ICERemoteCandidate,
    &_swigt__p_LayerInfo,
    &_swigt__p_LayerSource,
    &_swigt__p_LayerSources,
    &_swigt__p_MP4RecorderFacade,
    &_swigt__p_MediaFrameListener,
    &_swigt__p_MediaServer,
    &_swigt__p_PCAPTransportEmulator,
    &_swigt__p_PlayerFacade,
    &_swigt__p_Properties,
    &_swigt__p_PropertiesFacade,
    &_swigt__p_RTPBundleTransport,
    &_swigt__p_RTPBundleTransportConnection,
    &_swigt__p_RTPIncomingMediaStream,
    &_swigt__p_RTPIncomingMediaStreamDepacketizer,
    &_swigt__p_RTPIncomingMediaStreamListener,
    &_swigt__p_RTPIncomingMediaStreamMultiplexer,
    &_swigt__p_RTPIncomingSource,
    &_swigt__p_RTPIncomingSourceGroup,
    &_swigt__p_RTPOutgoingSource,
    &_swigt__p_RTPOutgoingSourceGroup,
    &_swigt__p_RTPPacket__shared,
    &_swigt__p_RTPReceiver,
    &_swigt__p_RTPReceiverFacade,
    &_swigt__p_RTPSender,
    &_swigt__p_RTPSenderFacade,
    &_swigt__p_RTPSessionFacade,
    &_swigt__p_RTPSource,
    &_swigt__p_RTPStreamTransponderFacade,
    &_swigt__p_RemoteRateEstimatorListener,
    &_swigt__p_SenderSideEstimatorListener,
    &_swigt__p_TimeService,
    &_swigt__p_UDPDumper,
    &_swigt__p_UDPReader,
    &_swigt__p_char,
    &_swigt__p_int,
    &_swigt__p_long_long,
    &_swigt__p_short,
    &_swigt__p_signed_char,
    &_swigt__p_std__string,
    &_swigt__p_unsigned_char,
    &_swigt__p_unsigned_int,
    &_swigt__p_unsigned_long_long,
    &_swigt__p_unsigned_short,
    &_swigt__p_v8__HandleT_v8__Object_t,
  };
  
  static swig_cast_info _swigc__p_ActiveSpeakerDetectorFacade[] = {  {&_swigt__p_ActiveSpeakerDetectorFacade, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_DTLSICETransport[] = {  {&_swigt__p_DTLSICETransport, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_DTLSICETransportListener[] = {  {&_swigt__p_DTLSICETransportListener, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_ICERemoteCandidate[] = {  {&_swigt__p_ICERemoteCandidate, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_LayerInfo[] = {  {&_swigt__p_LayerSource, _p_LayerSourceTo_p_LayerInfo, 0, 0},  {&_swigt__p_LayerInfo, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_LayerSource[] = {  {&_swigt__p_LayerSource, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_LayerSources[] = {  {&_swigt__p_LayerSources, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_MP4RecorderFacade[] = {  {&_swigt__p_MP4RecorderFacade, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_MediaFrameListener[] = {  {&_swigt__p_MediaFrameListener, 0, 0, 0},  {&_swigt__p_MP4RecorderFacade, _p_MP4RecorderFacadeTo_p_MediaFrameListener, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_MediaServer[] = {  {&_swigt__p_MediaServer, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_PCAPTransportEmulator[] = {  {&_swigt__p_PCAPTransportEmulator, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_PlayerFacade[] = {  {&_swigt__p_PlayerFacade, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_Properties[] = {  {&_swigt__p_Properties, 0, 0, 0},  {&_swigt__p_PropertiesFacade, _p_PropertiesFacadeTo_p_Properties, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_PropertiesFacade[] = {  {&_swigt__p_PropertiesFacade, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPBundleTransport[] = {  {&_swigt__p_RTPBundleTransport, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPBundleTransportConnection[] = {  {&_swigt__p_RTPBundleTransportConnection, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPIncomingMediaStream[] = {  {&_swigt__p_RTPIncomingMediaStream, 0, 0, 0},  {&_swigt__p_RTPIncomingMediaStreamMultiplexer, _p_RTPIncomingMediaStreamMultiplexerTo_p_RTPIncomingMediaStream, 0, 0},  {&_swigt__p_RTPIncomingSourceGroup, _p_RTPIncomingSourceGroupTo_p_RTPIncomingMediaStream, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPIncomingMediaStreamDepacketizer[] = {  {&_swigt__p_RTPIncomingMediaStreamDepacketizer, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPIncomingMediaStreamListener[] = {  {&_swigt__p_RTPIncomingMediaStreamMultiplexer, _p_RTPIncomingMediaStreamMultiplexerTo_p_RTPIncomingMediaStreamListener, 0, 0},  {&_swigt__p_RTPIncomingMediaStreamListener, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPIncomingMediaStreamMultiplexer[] = {  {&_swigt__p_RTPIncomingMediaStreamMultiplexer, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPIncomingSource[] = {  {&_swigt__p_RTPIncomingSource, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPIncomingSourceGroup[] = {  {&_swigt__p_RTPIncomingSourceGroup, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPOutgoingSource[] = {  {&_swigt__p_RTPOutgoingSource, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPOutgoingSourceGroup[] = {  {&_swigt__p_RTPOutgoingSourceGroup, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPPacket__shared[] = {  {&_swigt__p_RTPPacket__shared, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPReceiver[] = {  {&_swigt__p_RTPReceiver, 0, 0, 0},  {&_swigt__p_RTPSessionFacade, _p_RTPSessionFacadeTo_p_RTPReceiver, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPReceiverFacade[] = {  {&_swigt__p_RTPReceiverFacade, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPSender[] = {  {&_swigt__p_RTPSender, 0, 0, 0},  {&_swigt__p_RTPSessionFacade, _p_RTPSessionFacadeTo_p_RTPSender, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPSenderFacade[] = {  {&_swigt__p_RTPSenderFacade, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPSessionFacade[] = {  {&_swigt__p_RTPSessionFacade, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPSource[] = {  {&_swigt__p_RTPSource, 0, 0, 0},  {&_swigt__p_RTPIncomingSource, _p_RTPIncomingSourceTo_p_RTPSource, 0, 0},  {&_swigt__p_RTPOutgoingSource, _p_RTPOutgoingSourceTo_p_RTPSource, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RTPStreamTransponderFacade[] = {  {&_swigt__p_RTPStreamTransponderFacade, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_RemoteRateEstimatorListener[] = {  {&_swigt__p_RemoteRateEstimatorListener, 0, 0, 0},  {&_swigt__p_SenderSideEstimatorListener, _p_SenderSideEstimatorListenerTo_p_RemoteRateEstimatorListener, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_SenderSideEstimatorListener[] = {  {&_swigt__p_SenderSideEstimatorListener, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_TimeService[] = {  {&_swigt__p_TimeService, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_UDPDumper[] = {  {&_swigt__p_UDPDumper, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_UDPReader[] = {  {&_swigt__p_UDPReader, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_long_long[] = {  {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_short[] = {  {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_signed_char[] = {  {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_std__string[] = {  {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_unsigned_long_long[] = {  {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_unsigned_short[] = {  {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
  static swig_cast_info _swigc__p_v8__HandleT_v8__Object_t[] = {  {&_swigt__p_v8__HandleT_v8__Object_t, 0, 0, 0},{0, 0, 0, 0}};
  
  static swig_cast_info *swig_cast_initial[] = {
    _swigc__p_ActiveSpeakerDetectorFacade,
    _swigc__p_DTLSICETransport,
    _swigc__p_DTLSICETransportListener,
    _swigc__p_ICERemoteCandidate,
    _swigc__p_LayerInfo,
    _swigc__p_LayerSource,
    _swigc__p_LayerSources,
    _swigc__p_MP4RecorderFacade,
    _swigc__p_MediaFrameListener,
    _swigc__p_MediaServer,
    _swigc__p_PCAPTransportEmulator,
    _swigc__p_PlayerFacade,
    _swigc__p_Properties,
    _swigc__p_PropertiesFacade,
    _swigc__p_RTPBundleTransport,
    _swigc__p_RTPBundleTransportConnection,
    _swigc__p_RTPIncomingMediaStream,
    _swigc__p_RTPIncomingMediaStreamDepacketizer,
    _swigc__p_RTPIncomingMediaStreamListener,
    _swigc__p_RTPIncomingMediaStreamMultiplexer,
    _swigc__p_RTPIncomingSource,
    _swigc__p_RTPIncomingSourceGroup,
    _swigc__p_RTPOutgoingSource,
    _swigc__p_RTPOutgoingSourceGroup,
    _swigc__p_RTPPacket__shared,
    _swigc__p_RTPReceiver,
    _swigc__p_RTPReceiverFacade,
    _swigc__p_RTPSender,
    _swigc__p_RTPSenderFacade,
    _swigc__p_RTPSessionFacade,
    _swigc__p_RTPSource,
    _swigc__p_RTPStreamTransponderFacade,
    _swigc__p_RemoteRateEstimatorListener,
    _swigc__p_SenderSideEstimatorListener,
    _swigc__p_TimeService,
    _swigc__p_UDPDumper,
    _swigc__p_UDPReader,
    _swigc__p_char,
    _swigc__p_int,
    _swigc__p_long_long,
    _swigc__p_short,
    _swigc__p_signed_char,
    _swigc__p_std__string,
    _swigc__p_unsigned_char,
    _swigc__p_unsigned_int,
    _swigc__p_unsigned_long_long,
    _swigc__p_unsigned_short,
    _swigc__p_v8__HandleT_v8__Object_t,
  };
  
  
  /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
  
  
  
  
  SWIGRUNTIME void
  SWIG_V8_SetModule(void *, swig_module_info *swig_module) {
    v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
    v8::Local<v8::External> mod = SWIGV8_EXTERNAL_NEW(swig_module);
    assert(!mod.IsEmpty());
  #if (V8_MAJOR_VERSION-0) < 5
    global_obj->SetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"), mod);
  #else
    v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("swig_module_info_data"));
    global_obj->SetPrivate(SWIGV8_CURRENT_CONTEXT(), privateKey, mod);
  #endif
  }
  
  SWIGRUNTIME swig_module_info *
  SWIG_V8_GetModule(void *) {
    v8::Local<v8::Object> global_obj = SWIGV8_CURRENT_CONTEXT()->Global();
  #if (V8_MAJOR_VERSION-0) < 5
    v8::Local<v8::Value> moduleinfo = global_obj->GetHiddenValue(SWIGV8_STRING_NEW("swig_module_info_data"));
  #else
    v8::Local<v8::Private> privateKey = v8::Private::ForApi(v8::Isolate::GetCurrent(), SWIGV8_STRING_NEW("swig_module_info_data"));
    v8::Local<v8::Value> moduleinfo;
    if (!global_obj->GetPrivate(SWIGV8_CURRENT_CONTEXT(), privateKey).ToLocal(&moduleinfo))
      return 0;
  #endif
  
    if (moduleinfo.IsEmpty() || moduleinfo->IsNull() || moduleinfo->IsUndefined())
    {
      // It's not yet loaded
      return 0;
    }
  
    v8::Local<v8::External> moduleinfo_extern = v8::Local<v8::External>::Cast(moduleinfo);
  
    if (moduleinfo_extern.IsEmpty() || moduleinfo_extern->IsNull() || moduleinfo_extern->IsUndefined())
    {
      // Something's not right
      return 0;
    }
  
    void *ptr = moduleinfo_extern->Value();
    assert(ptr);
    swig_module_info *retptr = static_cast<swig_module_info *>(ptr);
    assert(retptr);
    return retptr;
  }
  
  #define SWIG_GetModule(clientdata)                SWIG_V8_GetModule(clientdata)
  #define SWIG_SetModule(clientdata, pointer)       SWIG_V8_SetModule(clientdata, pointer)
  
  
  /* -----------------------------------------------------------------------------
   * Type initialization:
   * This problem is tough by the requirement that no dynamic
   * memory is used. Also, since swig_type_info structures store pointers to
   * swig_cast_info structures and swig_cast_info structures store pointers back
   * to swig_type_info structures, we need some lookup code at initialization.
   * The idea is that swig generates all the structures that are needed.
   * The runtime then collects these partially filled structures.
   * The SWIG_InitializeModule function takes these initial arrays out of
   * swig_module, and does all the lookup, filling in the swig_module.types
   * array with the correct data and linking the correct swig_cast_info
   * structures together.
   *
   * The generated swig_type_info structures are assigned statically to an initial
   * array. We just loop through that array, and handle each type individually.
   * First we lookup if this type has been already loaded, and if so, use the
   * loaded structure instead of the generated one. Then we have to fill in the
   * cast linked list. The cast data is initially stored in something like a
   * two-dimensional array. Each row corresponds to a type (there are the same
   * number of rows as there are in the swig_type_initial array). Each entry in
   * a column is one of the swig_cast_info structures for that type.
   * The cast_initial array is actually an array of arrays, because each row has
   * a variable number of columns. So to actually build the cast linked list,
   * we find the array of casts associated with the type, and loop through it
   * adding the casts to the list. The one last trick we need to do is making
   * sure the type pointer in the swig_cast_info struct is correct.
   *
   * First off, we lookup the cast->type name to see if it is already loaded.
   * There are three cases to handle:
   *  1) If the cast->type has already been loaded AND the type we are adding
   *     casting info to has not been loaded (it is in this module), THEN we
   *     replace the cast->type pointer with the type pointer that has already
   *     been loaded.
   *  2) If BOTH types (the one we are adding casting info to, and the
   *     cast->type) are loaded, THEN the cast info has already been loaded by
   *     the previous module so we just ignore it.
   *  3) Finally, if cast->type has not already been loaded, then we add that
   *     swig_cast_info to the linked list (because the cast->type) pointer will
   *     be correct.
   * ----------------------------------------------------------------------------- */
  
  #ifdef __cplusplus
  extern "C" {
  #if 0
  } /* c-mode */
  #endif
  #endif
  
  #if 0
  #define SWIGRUNTIME_DEBUG
  #endif
  
  
  SWIGRUNTIME void
  SWIG_InitializeModule(void *clientdata) {
    size_t i;
    swig_module_info *module_head, *iter;
    int init;
  
    /* check to see if the circular list has been setup, if not, set it up */
    if (swig_module.next==0) {
      /* Initialize the swig_module */
      swig_module.type_initial = swig_type_initial;
      swig_module.cast_initial = swig_cast_initial;
      swig_module.next = &swig_module;
      init = 1;
    } else {
      init = 0;
    }
  
    /* Try and load any already created modules */
    module_head = SWIG_GetModule(clientdata);
    if (!module_head) {
      /* This is the first module loaded for this interpreter */
      /* so set the swig module into the interpreter */
      SWIG_SetModule(clientdata, &swig_module);
    } else {
      /* the interpreter has loaded a SWIG module, but has it loaded this one? */
      iter=module_head;
      do {
        if (iter==&swig_module) {
          /* Our module is already in the list, so there's nothing more to do. */
          return;
        }
        iter=iter->next;
      } while (iter!= module_head);
  
      /* otherwise we must add our module into the list */
      swig_module.next = module_head->next;
      module_head->next = &swig_module;
    }
  
    /* When multiple interpreters are used, a module could have already been initialized in
       a different interpreter, but not yet have a pointer in this interpreter.
       In this case, we do not want to continue adding types... everything should be
       set up already */
    if (init == 0) return;
  
    /* Now work on filling in swig_module.types */
  #ifdef SWIGRUNTIME_DEBUG
    printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size);
  #endif
    for (i = 0; i < swig_module.size; ++i) {
      swig_type_info *type = 0;
      swig_type_info *ret;
      swig_cast_info *cast;
  
  #ifdef SWIGRUNTIME_DEBUG
      printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
  #endif
  
      /* if there is another module already loaded */
      if (swig_module.next != &swig_module) {
        type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
      }
      if (type) {
        /* Overwrite clientdata field */
  #ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found type %s\n", type->name);
  #endif
        if (swig_module.type_initial[i]->clientdata) {
  	type->clientdata = swig_module.type_initial[i]->clientdata;
  #ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
  #endif
        }
      } else {
        type = swig_module.type_initial[i];
      }
  
      /* Insert casting types */
      cast = swig_module.cast_initial[i];
      while (cast->type) {
  
        /* Don't need to add information already in the list */
        ret = 0;
  #ifdef SWIGRUNTIME_DEBUG
        printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
  #endif
        if (swig_module.next != &swig_module) {
          ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
  #ifdef SWIGRUNTIME_DEBUG
  	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
  #endif
        }
        if (ret) {
  	if (type == swig_module.type_initial[i]) {
  #ifdef SWIGRUNTIME_DEBUG
  	  printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
  #endif
  	  cast->type = ret;
  	  ret = 0;
  	} else {
  	  /* Check for casting already in the list */
  	  swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
  #ifdef SWIGRUNTIME_DEBUG
  	  if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
  #endif
  	  if (!ocast) ret = 0;
  	}
        }
  
        if (!ret) {
  #ifdef SWIGRUNTIME_DEBUG
  	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
  #endif
          if (type->cast) {
            type->cast->prev = cast;
            cast->next = type->cast;
          }
          type->cast = cast;
        }
        cast++;
      }
      /* Set entry in modules->types array equal to the type */
      swig_module.types[i] = type;
    }
    swig_module.types[i] = 0;
  
  #ifdef SWIGRUNTIME_DEBUG
    printf("**** SWIG_InitializeModule: Cast List ******\n");
    for (i = 0; i < swig_module.size; ++i) {
      int j = 0;
      swig_cast_info *cast = swig_module.cast_initial[i];
      printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name);
      while (cast->type) {
        printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
        cast++;
        ++j;
      }
    printf("---- Total casts: %d\n",j);
    }
    printf("**** SWIG_InitializeModule: Cast List ******\n");
  #endif
  }
  
  /* This function will propagate the clientdata field of type to
  * any new swig_type_info structures that have been added into the list
  * of equivalent types.  It is like calling
  * SWIG_TypeClientData(type, clientdata) a second time.
  */
  SWIGRUNTIME void
  SWIG_PropagateClientData(void) {
    size_t i;
    swig_cast_info *equiv;
    static int init_run = 0;
  
    if (init_run) return;
    init_run = 1;
  
    for (i = 0; i < swig_module.size; i++) {
      if (swig_module.types[i]->clientdata) {
        equiv = swig_module.types[i]->cast;
        while (equiv) {
          if (!equiv->converter) {
            if (equiv->type && !equiv->type->clientdata)
              SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
          }
          equiv = equiv->next;
        }
      }
    }
  }
  
  #ifdef __cplusplus
  #if 0
  { /* c-mode */
  #endif
  }
  #endif
  
  
  // Note: 'extern "C"'' disables name mangling which makes it easier to load the symbol manually
  // TODO: is it ok to do that?
  extern "C"
  #if (NODE_MODULE_VERSION < 0x000C)
  void SWIGV8_INIT (v8::Handle<v8::Object> exports)
  #else
  void SWIGV8_INIT (v8::Handle<v8::Object> exports, v8::Handle<v8::Object> /*module*/)
  #endif
  {
    SWIG_InitializeModule(static_cast<void *>(&exports));
  
    SWIGV8_HANDLESCOPE();
    
    v8::Handle<v8::Object> exports_obj = exports;
  
  
    // a class template for creating proxies of undefined types
    SWIGV8_SET_CLASS_TEMPL(SWIGV8_SWIGTYPE_Proxy_class_templ, SWIGV8_CreateClassTemplate("SwigProxy"));
  
    /* create objects for namespaces */
    
  
    /* create class templates */
    /* Name: _exports_LayerInfo, Type: p_LayerInfo, Dtor: _wrap_delete_LayerInfo */
  v8::Handle<v8::FunctionTemplate> _exports_LayerInfo_class = SWIGV8_CreateClassTemplate("_exports_LayerInfo");
  SWIGV8_SET_CLASS_TEMPL(_exports_LayerInfo_clientData.class_templ, _exports_LayerInfo_class);
  _exports_LayerInfo_clientData.dtor = _wrap_delete_LayerInfo;
  if (SWIGTYPE_p_LayerInfo->clientdata == 0) {
    SWIGTYPE_p_LayerInfo->clientdata = &_exports_LayerInfo_clientData;
  }
  /* Name: _exports_LayerSource, Type: p_LayerSource, Dtor: _wrap_delete_LayerSource */
  v8::Handle<v8::FunctionTemplate> _exports_LayerSource_class = SWIGV8_CreateClassTemplate("_exports_LayerSource");
  SWIGV8_SET_CLASS_TEMPL(_exports_LayerSource_clientData.class_templ, _exports_LayerSource_class);
  _exports_LayerSource_clientData.dtor = _wrap_delete_LayerSource;
  if (SWIGTYPE_p_LayerSource->clientdata == 0) {
    SWIGTYPE_p_LayerSource->clientdata = &_exports_LayerSource_clientData;
  }
  /* Name: _exports_LayerSources, Type: p_LayerSources, Dtor: _wrap_delete_LayerSources */
  v8::Handle<v8::FunctionTemplate> _exports_LayerSources_class = SWIGV8_CreateClassTemplate("_exports_LayerSources");
  SWIGV8_SET_CLASS_TEMPL(_exports_LayerSources_clientData.class_templ, _exports_LayerSources_class);
  _exports_LayerSources_clientData.dtor = _wrap_delete_LayerSources;
  if (SWIGTYPE_p_LayerSources->clientdata == 0) {
    SWIGTYPE_p_LayerSources->clientdata = &_exports_LayerSources_clientData;
  }
  /* Name: _exports_RTPSource, Type: p_RTPSource, Dtor: _wrap_delete_RTPSource */
  v8::Handle<v8::FunctionTemplate> _exports_RTPSource_class = SWIGV8_CreateClassTemplate("_exports_RTPSource");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPSource_clientData.class_templ, _exports_RTPSource_class);
  _exports_RTPSource_clientData.dtor = _wrap_delete_RTPSource;
  if (SWIGTYPE_p_RTPSource->clientdata == 0) {
    SWIGTYPE_p_RTPSource->clientdata = &_exports_RTPSource_clientData;
  }
  /* Name: _exports_RTPIncomingSource, Type: p_RTPIncomingSource, Dtor: _wrap_delete_RTPIncomingSource */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingSource_class = SWIGV8_CreateClassTemplate("_exports_RTPIncomingSource");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPIncomingSource_clientData.class_templ, _exports_RTPIncomingSource_class);
  _exports_RTPIncomingSource_clientData.dtor = _wrap_delete_RTPIncomingSource;
  if (SWIGTYPE_p_RTPIncomingSource->clientdata == 0) {
    SWIGTYPE_p_RTPIncomingSource->clientdata = &_exports_RTPIncomingSource_clientData;
  }
  /* Name: _exports_RTPOutgoingSource, Type: p_RTPOutgoingSource, Dtor: _wrap_delete_RTPOutgoingSource */
  v8::Handle<v8::FunctionTemplate> _exports_RTPOutgoingSource_class = SWIGV8_CreateClassTemplate("_exports_RTPOutgoingSource");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPOutgoingSource_clientData.class_templ, _exports_RTPOutgoingSource_class);
  _exports_RTPOutgoingSource_clientData.dtor = _wrap_delete_RTPOutgoingSource;
  if (SWIGTYPE_p_RTPOutgoingSource->clientdata == 0) {
    SWIGTYPE_p_RTPOutgoingSource->clientdata = &_exports_RTPOutgoingSource_clientData;
  }
  /* Name: _exports_TimeService, Type: p_TimeService, Dtor: _wrap_delete_TimeService */
  v8::Handle<v8::FunctionTemplate> _exports_TimeService_class = SWIGV8_CreateClassTemplate("_exports_TimeService");
  SWIGV8_SET_CLASS_TEMPL(_exports_TimeService_clientData.class_templ, _exports_TimeService_class);
  _exports_TimeService_clientData.dtor = _wrap_delete_TimeService;
  if (SWIGTYPE_p_TimeService->clientdata == 0) {
    SWIGTYPE_p_TimeService->clientdata = &_exports_TimeService_clientData;
  }
  /* Name: _exports_RTPOutgoingSourceGroup, Type: p_RTPOutgoingSourceGroup, Dtor: _wrap_delete_RTPOutgoingSourceGroup */
  v8::Handle<v8::FunctionTemplate> _exports_RTPOutgoingSourceGroup_class = SWIGV8_CreateClassTemplate("_exports_RTPOutgoingSourceGroup");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPOutgoingSourceGroup_clientData.class_templ, _exports_RTPOutgoingSourceGroup_class);
  _exports_RTPOutgoingSourceGroup_clientData.dtor = _wrap_delete_RTPOutgoingSourceGroup;
  if (SWIGTYPE_p_RTPOutgoingSourceGroup->clientdata == 0) {
    SWIGTYPE_p_RTPOutgoingSourceGroup->clientdata = &_exports_RTPOutgoingSourceGroup_clientData;
  }
  /* Name: _exports_RTPSender, Type: p_RTPSender, Dtor: 0 */
  v8::Handle<v8::FunctionTemplate> _exports_RTPSender_class = SWIGV8_CreateClassTemplate("_exports_RTPSender");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPSender_clientData.class_templ, _exports_RTPSender_class);
  _exports_RTPSender_clientData.dtor = 0;
  if (SWIGTYPE_p_RTPSender->clientdata == 0) {
    SWIGTYPE_p_RTPSender->clientdata = &_exports_RTPSender_clientData;
  }
  /* Name: _exports_RTPReceiver, Type: p_RTPReceiver, Dtor: 0 */
  v8::Handle<v8::FunctionTemplate> _exports_RTPReceiver_class = SWIGV8_CreateClassTemplate("_exports_RTPReceiver");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPReceiver_clientData.class_templ, _exports_RTPReceiver_class);
  _exports_RTPReceiver_clientData.dtor = 0;
  if (SWIGTYPE_p_RTPReceiver->clientdata == 0) {
    SWIGTYPE_p_RTPReceiver->clientdata = &_exports_RTPReceiver_clientData;
  }
  /* Name: _exports_RTPIncomingMediaStreamListener, Type: p_RTPIncomingMediaStreamListener, Dtor: _wrap_delete_RTPIncomingMediaStreamListener */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingMediaStreamListener_class = SWIGV8_CreateClassTemplate("_exports_RTPIncomingMediaStreamListener");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPIncomingMediaStreamListener_clientData.class_templ, _exports_RTPIncomingMediaStreamListener_class);
  _exports_RTPIncomingMediaStreamListener_clientData.dtor = _wrap_delete_RTPIncomingMediaStreamListener;
  if (SWIGTYPE_p_RTPIncomingMediaStreamListener->clientdata == 0) {
    SWIGTYPE_p_RTPIncomingMediaStreamListener->clientdata = &_exports_RTPIncomingMediaStreamListener_clientData;
  }
  /* Name: _exports_RTPIncomingMediaStream, Type: p_RTPIncomingMediaStream, Dtor: 0 */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingMediaStream_class = SWIGV8_CreateClassTemplate("_exports_RTPIncomingMediaStream");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPIncomingMediaStream_clientData.class_templ, _exports_RTPIncomingMediaStream_class);
  _exports_RTPIncomingMediaStream_clientData.dtor = 0;
  if (SWIGTYPE_p_RTPIncomingMediaStream->clientdata == 0) {
    SWIGTYPE_p_RTPIncomingMediaStream->clientdata = &_exports_RTPIncomingMediaStream_clientData;
  }
  /* Name: _exports_RTPIncomingSourceGroup, Type: p_RTPIncomingSourceGroup, Dtor: _wrap_delete_RTPIncomingSourceGroup */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingSourceGroup_class = SWIGV8_CreateClassTemplate("_exports_RTPIncomingSourceGroup");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPIncomingSourceGroup_clientData.class_templ, _exports_RTPIncomingSourceGroup_class);
  _exports_RTPIncomingSourceGroup_clientData.dtor = _wrap_delete_RTPIncomingSourceGroup;
  if (SWIGTYPE_p_RTPIncomingSourceGroup->clientdata == 0) {
    SWIGTYPE_p_RTPIncomingSourceGroup->clientdata = &_exports_RTPIncomingSourceGroup_clientData;
  }
  /* Name: _exports_RTPIncomingMediaStreamMultiplexer, Type: p_RTPIncomingMediaStreamMultiplexer, Dtor: _wrap_delete_RTPIncomingMediaStreamMultiplexer */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingMediaStreamMultiplexer_class = SWIGV8_CreateClassTemplate("_exports_RTPIncomingMediaStreamMultiplexer");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPIncomingMediaStreamMultiplexer_clientData.class_templ, _exports_RTPIncomingMediaStreamMultiplexer_class);
  _exports_RTPIncomingMediaStreamMultiplexer_clientData.dtor = _wrap_delete_RTPIncomingMediaStreamMultiplexer;
  if (SWIGTYPE_p_RTPIncomingMediaStreamMultiplexer->clientdata == 0) {
    SWIGTYPE_p_RTPIncomingMediaStreamMultiplexer->clientdata = &_exports_RTPIncomingMediaStreamMultiplexer_clientData;
  }
  /* Name: _exports_PropertiesFacade, Type: p_PropertiesFacade, Dtor: _wrap_delete_PropertiesFacade */
  v8::Handle<v8::FunctionTemplate> _exports_PropertiesFacade_class = SWIGV8_CreateClassTemplate("_exports_PropertiesFacade");
  SWIGV8_SET_CLASS_TEMPL(_exports_PropertiesFacade_clientData.class_templ, _exports_PropertiesFacade_class);
  _exports_PropertiesFacade_clientData.dtor = _wrap_delete_PropertiesFacade;
  if (SWIGTYPE_p_PropertiesFacade->clientdata == 0) {
    SWIGTYPE_p_PropertiesFacade->clientdata = &_exports_PropertiesFacade_clientData;
  }
  /* Name: _exports_MediaServer, Type: p_MediaServer, Dtor: _wrap_delete_MediaServer */
  v8::Handle<v8::FunctionTemplate> _exports_MediaServer_class = SWIGV8_CreateClassTemplate("_exports_MediaServer");
  SWIGV8_SET_CLASS_TEMPL(_exports_MediaServer_clientData.class_templ, _exports_MediaServer_class);
  _exports_MediaServer_clientData.dtor = _wrap_delete_MediaServer;
  if (SWIGTYPE_p_MediaServer->clientdata == 0) {
    SWIGTYPE_p_MediaServer->clientdata = &_exports_MediaServer_clientData;
  }
  /* Name: _exports_RTPBundleTransportConnection, Type: p_RTPBundleTransportConnection, Dtor: 0 */
  v8::Handle<v8::FunctionTemplate> _exports_RTPBundleTransportConnection_class = SWIGV8_CreateClassTemplate("_exports_RTPBundleTransportConnection");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPBundleTransportConnection_clientData.class_templ, _exports_RTPBundleTransportConnection_class);
  _exports_RTPBundleTransportConnection_clientData.dtor = 0;
  if (SWIGTYPE_p_RTPBundleTransportConnection->clientdata == 0) {
    SWIGTYPE_p_RTPBundleTransportConnection->clientdata = &_exports_RTPBundleTransportConnection_clientData;
  }
  /* Name: _exports_RTPBundleTransport, Type: p_RTPBundleTransport, Dtor: _wrap_delete_RTPBundleTransport */
  v8::Handle<v8::FunctionTemplate> _exports_RTPBundleTransport_class = SWIGV8_CreateClassTemplate("_exports_RTPBundleTransport");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPBundleTransport_clientData.class_templ, _exports_RTPBundleTransport_class);
  _exports_RTPBundleTransport_clientData.dtor = _wrap_delete_RTPBundleTransport;
  if (SWIGTYPE_p_RTPBundleTransport->clientdata == 0) {
    SWIGTYPE_p_RTPBundleTransport->clientdata = &_exports_RTPBundleTransport_clientData;
  }
  /* Name: _exports_UDPReader, Type: p_UDPReader, Dtor: _wrap_delete_UDPReader */
  v8::Handle<v8::FunctionTemplate> _exports_UDPReader_class = SWIGV8_CreateClassTemplate("_exports_UDPReader");
  SWIGV8_SET_CLASS_TEMPL(_exports_UDPReader_clientData.class_templ, _exports_UDPReader_class);
  _exports_UDPReader_clientData.dtor = _wrap_delete_UDPReader;
  if (SWIGTYPE_p_UDPReader->clientdata == 0) {
    SWIGTYPE_p_UDPReader->clientdata = &_exports_UDPReader_clientData;
  }
  /* Name: _exports_PCAPTransportEmulator, Type: p_PCAPTransportEmulator, Dtor: _wrap_delete_PCAPTransportEmulator */
  v8::Handle<v8::FunctionTemplate> _exports_PCAPTransportEmulator_class = SWIGV8_CreateClassTemplate("_exports_PCAPTransportEmulator");
  SWIGV8_SET_CLASS_TEMPL(_exports_PCAPTransportEmulator_clientData.class_templ, _exports_PCAPTransportEmulator_class);
  _exports_PCAPTransportEmulator_clientData.dtor = _wrap_delete_PCAPTransportEmulator;
  if (SWIGTYPE_p_PCAPTransportEmulator->clientdata == 0) {
    SWIGTYPE_p_PCAPTransportEmulator->clientdata = &_exports_PCAPTransportEmulator_clientData;
  }
  /* Name: _exports_DTLSICETransportListener, Type: p_DTLSICETransportListener, Dtor: _wrap_delete_DTLSICETransportListener */
  v8::Handle<v8::FunctionTemplate> _exports_DTLSICETransportListener_class = SWIGV8_CreateClassTemplate("_exports_DTLSICETransportListener");
  SWIGV8_SET_CLASS_TEMPL(_exports_DTLSICETransportListener_clientData.class_templ, _exports_DTLSICETransportListener_class);
  _exports_DTLSICETransportListener_clientData.dtor = _wrap_delete_DTLSICETransportListener;
  if (SWIGTYPE_p_DTLSICETransportListener->clientdata == 0) {
    SWIGTYPE_p_DTLSICETransportListener->clientdata = &_exports_DTLSICETransportListener_clientData;
  }
  /* Name: _exports_RemoteRateEstimatorListener, Type: p_RemoteRateEstimatorListener, Dtor: _wrap_delete_RemoteRateEstimatorListener */
  v8::Handle<v8::FunctionTemplate> _exports_RemoteRateEstimatorListener_class = SWIGV8_CreateClassTemplate("_exports_RemoteRateEstimatorListener");
  SWIGV8_SET_CLASS_TEMPL(_exports_RemoteRateEstimatorListener_clientData.class_templ, _exports_RemoteRateEstimatorListener_class);
  _exports_RemoteRateEstimatorListener_clientData.dtor = _wrap_delete_RemoteRateEstimatorListener;
  if (SWIGTYPE_p_RemoteRateEstimatorListener->clientdata == 0) {
    SWIGTYPE_p_RemoteRateEstimatorListener->clientdata = &_exports_RemoteRateEstimatorListener_clientData;
  }
  /* Name: _exports_DTLSICETransport, Type: p_DTLSICETransport, Dtor: _wrap_delete_DTLSICETransport */
  v8::Handle<v8::FunctionTemplate> _exports_DTLSICETransport_class = SWIGV8_CreateClassTemplate("_exports_DTLSICETransport");
  SWIGV8_SET_CLASS_TEMPL(_exports_DTLSICETransport_clientData.class_templ, _exports_DTLSICETransport_class);
  _exports_DTLSICETransport_clientData.dtor = _wrap_delete_DTLSICETransport;
  if (SWIGTYPE_p_DTLSICETransport->clientdata == 0) {
    SWIGTYPE_p_DTLSICETransport->clientdata = &_exports_DTLSICETransport_clientData;
  }
  /* Name: _exports_RTPSessionFacade, Type: p_RTPSessionFacade, Dtor: _wrap_delete_RTPSessionFacade */
  v8::Handle<v8::FunctionTemplate> _exports_RTPSessionFacade_class = SWIGV8_CreateClassTemplate("_exports_RTPSessionFacade");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPSessionFacade_clientData.class_templ, _exports_RTPSessionFacade_class);
  _exports_RTPSessionFacade_clientData.dtor = _wrap_delete_RTPSessionFacade;
  if (SWIGTYPE_p_RTPSessionFacade->clientdata == 0) {
    SWIGTYPE_p_RTPSessionFacade->clientdata = &_exports_RTPSessionFacade_clientData;
  }
  /* Name: _exports_RTPSenderFacade, Type: p_RTPSenderFacade, Dtor: _wrap_delete_RTPSenderFacade */
  v8::Handle<v8::FunctionTemplate> _exports_RTPSenderFacade_class = SWIGV8_CreateClassTemplate("_exports_RTPSenderFacade");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPSenderFacade_clientData.class_templ, _exports_RTPSenderFacade_class);
  _exports_RTPSenderFacade_clientData.dtor = _wrap_delete_RTPSenderFacade;
  if (SWIGTYPE_p_RTPSenderFacade->clientdata == 0) {
    SWIGTYPE_p_RTPSenderFacade->clientdata = &_exports_RTPSenderFacade_clientData;
  }
  /* Name: _exports_RTPReceiverFacade, Type: p_RTPReceiverFacade, Dtor: _wrap_delete_RTPReceiverFacade */
  v8::Handle<v8::FunctionTemplate> _exports_RTPReceiverFacade_class = SWIGV8_CreateClassTemplate("_exports_RTPReceiverFacade");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPReceiverFacade_clientData.class_templ, _exports_RTPReceiverFacade_class);
  _exports_RTPReceiverFacade_clientData.dtor = _wrap_delete_RTPReceiverFacade;
  if (SWIGTYPE_p_RTPReceiverFacade->clientdata == 0) {
    SWIGTYPE_p_RTPReceiverFacade->clientdata = &_exports_RTPReceiverFacade_clientData;
  }
  /* Name: _exports_RTPStreamTransponderFacade, Type: p_RTPStreamTransponderFacade, Dtor: _wrap_delete_RTPStreamTransponderFacade */
  v8::Handle<v8::FunctionTemplate> _exports_RTPStreamTransponderFacade_class = SWIGV8_CreateClassTemplate("_exports_RTPStreamTransponderFacade");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPStreamTransponderFacade_clientData.class_templ, _exports_RTPStreamTransponderFacade_class);
  _exports_RTPStreamTransponderFacade_clientData.dtor = _wrap_delete_RTPStreamTransponderFacade;
  if (SWIGTYPE_p_RTPStreamTransponderFacade->clientdata == 0) {
    SWIGTYPE_p_RTPStreamTransponderFacade->clientdata = &_exports_RTPStreamTransponderFacade_clientData;
  }
  /* Name: _exports_MediaFrameListener, Type: p_MediaFrameListener, Dtor: 0 */
  v8::Handle<v8::FunctionTemplate> _exports_MediaFrameListener_class = SWIGV8_CreateClassTemplate("_exports_MediaFrameListener");
  SWIGV8_SET_CLASS_TEMPL(_exports_MediaFrameListener_clientData.class_templ, _exports_MediaFrameListener_class);
  _exports_MediaFrameListener_clientData.dtor = 0;
  if (SWIGTYPE_p_MediaFrameListener->clientdata == 0) {
    SWIGTYPE_p_MediaFrameListener->clientdata = &_exports_MediaFrameListener_clientData;
  }
  /* Name: _exports_RTPIncomingMediaStreamDepacketizer, Type: p_RTPIncomingMediaStreamDepacketizer, Dtor: _wrap_delete_RTPIncomingMediaStreamDepacketizer */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingMediaStreamDepacketizer_class = SWIGV8_CreateClassTemplate("_exports_RTPIncomingMediaStreamDepacketizer");
  SWIGV8_SET_CLASS_TEMPL(_exports_RTPIncomingMediaStreamDepacketizer_clientData.class_templ, _exports_RTPIncomingMediaStreamDepacketizer_class);
  _exports_RTPIncomingMediaStreamDepacketizer_clientData.dtor = _wrap_delete_RTPIncomingMediaStreamDepacketizer;
  if (SWIGTYPE_p_RTPIncomingMediaStreamDepacketizer->clientdata == 0) {
    SWIGTYPE_p_RTPIncomingMediaStreamDepacketizer->clientdata = &_exports_RTPIncomingMediaStreamDepacketizer_clientData;
  }
  /* Name: _exports_MP4RecorderFacade, Type: p_MP4RecorderFacade, Dtor: _wrap_delete_MP4RecorderFacade */
  v8::Handle<v8::FunctionTemplate> _exports_MP4RecorderFacade_class = SWIGV8_CreateClassTemplate("_exports_MP4RecorderFacade");
  SWIGV8_SET_CLASS_TEMPL(_exports_MP4RecorderFacade_clientData.class_templ, _exports_MP4RecorderFacade_class);
  _exports_MP4RecorderFacade_clientData.dtor = _wrap_delete_MP4RecorderFacade;
  if (SWIGTYPE_p_MP4RecorderFacade->clientdata == 0) {
    SWIGTYPE_p_MP4RecorderFacade->clientdata = &_exports_MP4RecorderFacade_clientData;
  }
  /* Name: _exports_PlayerFacade, Type: p_PlayerFacade, Dtor: _wrap_delete_PlayerFacade */
  v8::Handle<v8::FunctionTemplate> _exports_PlayerFacade_class = SWIGV8_CreateClassTemplate("_exports_PlayerFacade");
  SWIGV8_SET_CLASS_TEMPL(_exports_PlayerFacade_clientData.class_templ, _exports_PlayerFacade_class);
  _exports_PlayerFacade_clientData.dtor = _wrap_delete_PlayerFacade;
  if (SWIGTYPE_p_PlayerFacade->clientdata == 0) {
    SWIGTYPE_p_PlayerFacade->clientdata = &_exports_PlayerFacade_clientData;
  }
  /* Name: _exports_SenderSideEstimatorListener, Type: p_SenderSideEstimatorListener, Dtor: _wrap_delete_SenderSideEstimatorListener */
  v8::Handle<v8::FunctionTemplate> _exports_SenderSideEstimatorListener_class = SWIGV8_CreateClassTemplate("_exports_SenderSideEstimatorListener");
  SWIGV8_SET_CLASS_TEMPL(_exports_SenderSideEstimatorListener_clientData.class_templ, _exports_SenderSideEstimatorListener_class);
  _exports_SenderSideEstimatorListener_clientData.dtor = _wrap_delete_SenderSideEstimatorListener;
  if (SWIGTYPE_p_SenderSideEstimatorListener->clientdata == 0) {
    SWIGTYPE_p_SenderSideEstimatorListener->clientdata = &_exports_SenderSideEstimatorListener_clientData;
  }
  /* Name: _exports_ActiveSpeakerDetectorFacade, Type: p_ActiveSpeakerDetectorFacade, Dtor: _wrap_delete_ActiveSpeakerDetectorFacade */
  v8::Handle<v8::FunctionTemplate> _exports_ActiveSpeakerDetectorFacade_class = SWIGV8_CreateClassTemplate("_exports_ActiveSpeakerDetectorFacade");
  SWIGV8_SET_CLASS_TEMPL(_exports_ActiveSpeakerDetectorFacade_clientData.class_templ, _exports_ActiveSpeakerDetectorFacade_class);
  _exports_ActiveSpeakerDetectorFacade_clientData.dtor = _wrap_delete_ActiveSpeakerDetectorFacade;
  if (SWIGTYPE_p_ActiveSpeakerDetectorFacade->clientdata == 0) {
    SWIGTYPE_p_ActiveSpeakerDetectorFacade->clientdata = &_exports_ActiveSpeakerDetectorFacade_clientData;
  }
  
  
    /* register wrapper functions */
    SWIGV8_AddMemberVariable(_exports_LayerInfo_class, "temporalLayerId", _wrap_LayerInfo_temporalLayerId_get, _wrap_LayerInfo_temporalLayerId_set);
  SWIGV8_AddMemberVariable(_exports_LayerInfo_class, "spatialLayerId", _wrap_LayerInfo_spatialLayerId_get, _wrap_LayerInfo_spatialLayerId_set);
  SWIGV8_AddMemberVariable(_exports_LayerSource_class, "numPackets", _wrap_LayerSource_numPackets_get, _wrap_LayerSource_numPackets_set);
  SWIGV8_AddMemberVariable(_exports_LayerSource_class, "totalBytes", _wrap_LayerSource_totalBytes_get, _wrap_LayerSource_totalBytes_set);
  SWIGV8_AddMemberVariable(_exports_LayerSource_class, "bitrate", _wrap_LayerSource_bitrate_get, _wrap_LayerSource_bitrate_set);
  SWIGV8_AddMemberFunction(_exports_LayerSources_class, "size", _wrap_LayerSources_size);
  SWIGV8_AddMemberFunction(_exports_LayerSources_class, "get", _wrap_LayerSources_get);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "ssrc", _wrap_RTPSource_ssrc_get, _wrap_RTPSource_ssrc_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "extSeqNum", _wrap_RTPSource_extSeqNum_get, _wrap_RTPSource_extSeqNum_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "cycles", _wrap_RTPSource_cycles_get, _wrap_RTPSource_cycles_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "jitter", _wrap_RTPSource_jitter_get, _wrap_RTPSource_jitter_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "numPackets", _wrap_RTPSource_numPackets_get, _wrap_RTPSource_numPackets_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "numPacketsDelta", _wrap_RTPSource_numPacketsDelta_get, _wrap_RTPSource_numPacketsDelta_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "numRTCPPackets", _wrap_RTPSource_numRTCPPackets_get, _wrap_RTPSource_numRTCPPackets_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "totalBytes", _wrap_RTPSource_totalBytes_get, _wrap_RTPSource_totalBytes_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "totalRTCPBytes", _wrap_RTPSource_totalRTCPBytes_get, _wrap_RTPSource_totalRTCPBytes_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "bitrate", _wrap_RTPSource_bitrate_get, _wrap_RTPSource_bitrate_set);
  SWIGV8_AddMemberVariable(_exports_RTPSource_class, "clockrate", _wrap_RTPSource_clockrate_get, _wrap_RTPSource_clockrate_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "numFrames", _wrap_RTPIncomingSource_numFrames_get, _wrap_RTPIncomingSource_numFrames_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "numFramesDelta", _wrap_RTPIncomingSource_numFramesDelta_get, _wrap_RTPIncomingSource_numFramesDelta_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "lostPackets", _wrap_RTPIncomingSource_lostPackets_get, _wrap_RTPIncomingSource_lostPackets_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "lostPacketsDelta", _wrap_RTPIncomingSource_lostPacketsDelta_get, _wrap_RTPIncomingSource_lostPacketsDelta_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "dropPackets", _wrap_RTPIncomingSource_dropPackets_get, _wrap_RTPIncomingSource_dropPackets_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "totalPacketsSinceLastSR", _wrap_RTPIncomingSource_totalPacketsSinceLastSR_get, _wrap_RTPIncomingSource_totalPacketsSinceLastSR_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "totalBytesSinceLastSR", _wrap_RTPIncomingSource_totalBytesSinceLastSR_get, _wrap_RTPIncomingSource_totalBytesSinceLastSR_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "minExtSeqNumSinceLastSR", _wrap_RTPIncomingSource_minExtSeqNumSinceLastSR_get, _wrap_RTPIncomingSource_minExtSeqNumSinceLastSR_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "lostPacketsSinceLastSR", _wrap_RTPIncomingSource_lostPacketsSinceLastSR_get, _wrap_RTPIncomingSource_lostPacketsSinceLastSR_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "lastReceivedSenderNTPTimestamp", _wrap_RTPIncomingSource_lastReceivedSenderNTPTimestamp_get, _wrap_RTPIncomingSource_lastReceivedSenderNTPTimestamp_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "lastReceivedSenderReport", _wrap_RTPIncomingSource_lastReceivedSenderReport_get, _wrap_RTPIncomingSource_lastReceivedSenderReport_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "lastReport", _wrap_RTPIncomingSource_lastReport_get, _wrap_RTPIncomingSource_lastReport_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "totalPLIs", _wrap_RTPIncomingSource_totalPLIs_get, _wrap_RTPIncomingSource_totalPLIs_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "totalNACKs", _wrap_RTPIncomingSource_totalNACKs_get, _wrap_RTPIncomingSource_totalNACKs_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "skew", _wrap_RTPIncomingSource_skew_get, _wrap_RTPIncomingSource_skew_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSource_class, "drift", _wrap_RTPIncomingSource_drift_get, _wrap_RTPIncomingSource_drift_set);
  SWIGV8_AddMemberFunction(_exports_RTPIncomingSource_class, "layers", _wrap_RTPIncomingSource_layers);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "time", _wrap_RTPOutgoingSource_time_get, _wrap_RTPOutgoingSource_time_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "lastTime", _wrap_RTPOutgoingSource_lastTime_get, _wrap_RTPOutgoingSource_lastTime_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "numPackets", _wrap_RTPOutgoingSource_numPackets_get, _wrap_RTPOutgoingSource_numPackets_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "numRTCPPackets", _wrap_RTPOutgoingSource_numRTCPPackets_get, _wrap_RTPOutgoingSource_numRTCPPackets_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "totalBytes", _wrap_RTPOutgoingSource_totalBytes_get, _wrap_RTPOutgoingSource_totalBytes_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "totalRTCPBytes", _wrap_RTPOutgoingSource_totalRTCPBytes_get, _wrap_RTPOutgoingSource_totalRTCPBytes_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "lastSenderReport", _wrap_RTPOutgoingSource_lastSenderReport_get, _wrap_RTPOutgoingSource_lastSenderReport_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "lastSenderReportNTP", _wrap_RTPOutgoingSource_lastSenderReportNTP_get, _wrap_RTPOutgoingSource_lastSenderReportNTP_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "remb", _wrap_RTPOutgoingSource_remb_get, _wrap_RTPOutgoingSource_remb_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "reportCount", _wrap_RTPOutgoingSource_reportCount_get, _wrap_RTPOutgoingSource_reportCount_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "reportCountDelta", _wrap_RTPOutgoingSource_reportCountDelta_get, _wrap_RTPOutgoingSource_reportCountDelta_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "reportedLostCount", _wrap_RTPOutgoingSource_reportedLostCount_get, _wrap_RTPOutgoingSource_reportedLostCount_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "reportedLostCountDelta", _wrap_RTPOutgoingSource_reportedLostCountDelta_get, _wrap_RTPOutgoingSource_reportedLostCountDelta_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "reportedFractionLost", _wrap_RTPOutgoingSource_reportedFractionLost_get, _wrap_RTPOutgoingSource_reportedFractionLost_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "reportedJitter", _wrap_RTPOutgoingSource_reportedJitter_get, _wrap_RTPOutgoingSource_reportedJitter_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSource_class, "rtt", _wrap_RTPOutgoingSource_rtt_get, _wrap_RTPOutgoingSource_rtt_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSourceGroup_class, "type", _wrap_RTPOutgoingSourceGroup_type_get, _wrap_RTPOutgoingSourceGroup_type_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSourceGroup_class, "media", _wrap_RTPOutgoingSourceGroup_media_get, _wrap_RTPOutgoingSourceGroup_media_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSourceGroup_class, "fec", _wrap_RTPOutgoingSourceGroup_fec_get, _wrap_RTPOutgoingSourceGroup_fec_set);
  SWIGV8_AddMemberVariable(_exports_RTPOutgoingSourceGroup_class, "rtx", _wrap_RTPOutgoingSourceGroup_rtx_get, _wrap_RTPOutgoingSourceGroup_rtx_set);
  SWIGV8_AddMemberFunction(_exports_RTPOutgoingSourceGroup_class, "Update", _wrap_RTPOutgoingSourceGroup_Update);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "rid", _wrap_RTPIncomingSourceGroup_rid_get, _wrap_RTPIncomingSourceGroup_rid_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "mid", _wrap_RTPIncomingSourceGroup_mid_get, _wrap_RTPIncomingSourceGroup_mid_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "rtt", _wrap_RTPIncomingSourceGroup_rtt_get, _wrap_RTPIncomingSourceGroup_rtt_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "type", _wrap_RTPIncomingSourceGroup_type_get, _wrap_RTPIncomingSourceGroup_type_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "media", _wrap_RTPIncomingSourceGroup_media_get, _wrap_RTPIncomingSourceGroup_media_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "fec", _wrap_RTPIncomingSourceGroup_fec_get, _wrap_RTPIncomingSourceGroup_fec_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "rtx", _wrap_RTPIncomingSourceGroup_rtx_get, _wrap_RTPIncomingSourceGroup_rtx_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "lost", _wrap_RTPIncomingSourceGroup_lost_get, _wrap_RTPIncomingSourceGroup_lost_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "minWaitedTime", _wrap_RTPIncomingSourceGroup_minWaitedTime_get, _wrap_RTPIncomingSourceGroup_minWaitedTime_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "maxWaitedTime", _wrap_RTPIncomingSourceGroup_maxWaitedTime_get, _wrap_RTPIncomingSourceGroup_maxWaitedTime_set);
  SWIGV8_AddMemberVariable(_exports_RTPIncomingSourceGroup_class, "avgWaitedTime", _wrap_RTPIncomingSourceGroup_avgWaitedTime_get, _wrap_RTPIncomingSourceGroup_avgWaitedTime_set);
  SWIGV8_AddMemberFunction(_exports_RTPIncomingSourceGroup_class, "AddListener", _wrap_RTPIncomingSourceGroup_AddListener);
  SWIGV8_AddMemberFunction(_exports_RTPIncomingSourceGroup_class, "RemoveListener", _wrap_RTPIncomingSourceGroup_RemoveListener);
  SWIGV8_AddMemberFunction(_exports_RTPIncomingSourceGroup_class, "Update", _wrap_RTPIncomingSourceGroup_Update);
  SWIGV8_AddMemberFunction(_exports_RTPIncomingMediaStreamMultiplexer_class, "Stop", _wrap_RTPIncomingMediaStreamMultiplexer_Stop);
  SWIGV8_AddMemberFunction(_exports_PropertiesFacade_class, "SetPropertyInt", _wrap_PropertiesFacade_SetPropertyInt);
  SWIGV8_AddMemberFunction(_exports_PropertiesFacade_class, "SetPropertyStr", _wrap_PropertiesFacade_SetPropertyStr);
  SWIGV8_AddMemberFunction(_exports_PropertiesFacade_class, "SetPropertyBool", _wrap_PropertiesFacade_SetPropertyBool);
  SWIGV8_AddMemberVariable(_exports_RTPBundleTransportConnection_class, "transport", _wrap_RTPBundleTransportConnection_transport_get, _wrap_RTPBundleTransportConnection_transport_set);
  SWIGV8_AddMemberVariable(_exports_RTPBundleTransportConnection_class, "disableSTUNKeepAlive", _wrap_RTPBundleTransportConnection_disableSTUNKeepAlive_get, _wrap_RTPBundleTransportConnection_disableSTUNKeepAlive_set);
  SWIGV8_AddMemberVariable(_exports_RTPBundleTransportConnection_class, "iceRequestsSent", _wrap_RTPBundleTransportConnection_iceRequestsSent_get, _wrap_RTPBundleTransportConnection_iceRequestsSent_set);
  SWIGV8_AddMemberVariable(_exports_RTPBundleTransportConnection_class, "iceRequestsReceived", _wrap_RTPBundleTransportConnection_iceRequestsReceived_get, _wrap_RTPBundleTransportConnection_iceRequestsReceived_set);
  SWIGV8_AddMemberVariable(_exports_RTPBundleTransportConnection_class, "iceResponsesSent", _wrap_RTPBundleTransportConnection_iceResponsesSent_get, _wrap_RTPBundleTransportConnection_iceResponsesSent_set);
  SWIGV8_AddMemberVariable(_exports_RTPBundleTransportConnection_class, "iceResponsesReceived", _wrap_RTPBundleTransportConnection_iceResponsesReceived_get, _wrap_RTPBundleTransportConnection_iceResponsesReceived_set);
  SWIGV8_AddMemberFunction(_exports_RTPBundleTransport_class, "Init", _wrap_RTPBundleTransport__wrap_RTPBundleTransport_Init);
  SWIGV8_AddMemberFunction(_exports_RTPBundleTransport_class, "AddICETransport", _wrap_RTPBundleTransport_AddICETransport);
  SWIGV8_AddMemberFunction(_exports_RTPBundleTransport_class, "RemoveICETransport", _wrap_RTPBundleTransport_RemoveICETransport);
  SWIGV8_AddMemberFunction(_exports_RTPBundleTransport_class, "End", _wrap_RTPBundleTransport_End);
  SWIGV8_AddMemberFunction(_exports_RTPBundleTransport_class, "GetLocalPort", _wrap_RTPBundleTransport_GetLocalPort);
  SWIGV8_AddMemberFunction(_exports_RTPBundleTransport_class, "AddRemoteCandidate", _wrap_RTPBundleTransport_AddRemoteCandidate);
  SWIGV8_AddMemberFunction(_exports_RTPBundleTransport_class, "SetAffinity", _wrap_RTPBundleTransport_SetAffinity);
  SWIGV8_AddMemberFunction(_exports_RTPBundleTransport_class, "SetIceTimeout", _wrap_RTPBundleTransport_SetIceTimeout);
  SWIGV8_AddMemberFunction(_exports_RTPBundleTransport_class, "GetTimeService", _wrap_RTPBundleTransport_GetTimeService);
  SWIGV8_AddMemberFunction(_exports_UDPReader_class, "Next", _wrap_UDPReader_Next);
  SWIGV8_AddMemberFunction(_exports_UDPReader_class, "GetUDPData", _wrap_UDPReader_GetUDPData);
  SWIGV8_AddMemberFunction(_exports_UDPReader_class, "GetUDPSize", _wrap_UDPReader_GetUDPSize);
  SWIGV8_AddMemberFunction(_exports_UDPReader_class, "Seek", _wrap_UDPReader_Seek);
  SWIGV8_AddMemberFunction(_exports_UDPReader_class, "Rewind", _wrap_UDPReader_Rewind);
  SWIGV8_AddMemberFunction(_exports_UDPReader_class, "Close", _wrap_UDPReader_Close);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "SetRemoteProperties", _wrap_PCAPTransportEmulator_SetRemoteProperties);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "AddIncomingSourceGroup", _wrap_PCAPTransportEmulator_AddIncomingSourceGroup);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "RemoveIncomingSourceGroup", _wrap_PCAPTransportEmulator_RemoveIncomingSourceGroup);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "Open", _wrap_PCAPTransportEmulator_Open);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "SetReader", _wrap_PCAPTransportEmulator_SetReader);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "Play", _wrap_PCAPTransportEmulator_Play);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "Seek", _wrap_PCAPTransportEmulator_Seek);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "Stop", _wrap_PCAPTransportEmulator_Stop);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "Close", _wrap_PCAPTransportEmulator_Close);
  SWIGV8_AddMemberFunction(_exports_PCAPTransportEmulator_class, "GetTimeService", _wrap_PCAPTransportEmulator_GetTimeService);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetListener", _wrap_DTLSICETransport_SetListener);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "Start", _wrap_DTLSICETransport_Start);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "Stop", _wrap_DTLSICETransport_Stop);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetSRTPProtectionProfiles", _wrap_DTLSICETransport_SetSRTPProtectionProfiles);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetRemoteProperties", _wrap_DTLSICETransport_SetRemoteProperties);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetLocalProperties", _wrap_DTLSICETransport_SetLocalProperties);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SendPLI", _wrap_DTLSICETransport_SendPLI);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "Enqueue", _wrap_DTLSICETransport_Enqueue);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "Dump", _wrap_DTLSICETransport__wrap_DTLSICETransport_Dump);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "StopDump", _wrap_DTLSICETransport_StopDump);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "DumpBWEStats", _wrap_DTLSICETransport_DumpBWEStats);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "StopDumpBWEStats", _wrap_DTLSICETransport_StopDumpBWEStats);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "Reset", _wrap_DTLSICETransport_Reset);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "ActivateRemoteCandidate", _wrap_DTLSICETransport_ActivateRemoteCandidate);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetRemoteCryptoDTLS", _wrap_DTLSICETransport_SetRemoteCryptoDTLS);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetLocalSTUNCredentials", _wrap_DTLSICETransport_SetLocalSTUNCredentials);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetRemoteSTUNCredentials", _wrap_DTLSICETransport_SetRemoteSTUNCredentials);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "AddOutgoingSourceGroup", _wrap_DTLSICETransport_AddOutgoingSourceGroup);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "RemoveOutgoingSourceGroup", _wrap_DTLSICETransport_RemoveOutgoingSourceGroup);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "AddIncomingSourceGroup", _wrap_DTLSICETransport_AddIncomingSourceGroup);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "RemoveIncomingSourceGroup", _wrap_DTLSICETransport_RemoveIncomingSourceGroup);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetBandwidthProbing", _wrap_DTLSICETransport_SetBandwidthProbing);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetMaxProbingBitrate", _wrap_DTLSICETransport_SetMaxProbingBitrate);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetProbingBitrateLimit", _wrap_DTLSICETransport_SetProbingBitrateLimit);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "SetSenderSideEstimatorListener", _wrap_DTLSICETransport_SetSenderSideEstimatorListener);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "GetRemoteUsername", _wrap_DTLSICETransport_GetRemoteUsername);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "GetRemotePwd", _wrap_DTLSICETransport_GetRemotePwd);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "GetLocalUsername", _wrap_DTLSICETransport_GetLocalUsername);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "GetLocalPwd", _wrap_DTLSICETransport_GetLocalPwd);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "GetRTT", _wrap_DTLSICETransport_GetRTT);
  SWIGV8_AddMemberFunction(_exports_DTLSICETransport_class, "GetTimeService", _wrap_DTLSICETransport_GetTimeService);
  SWIGV8_AddMemberFunction(_exports_RTPSessionFacade_class, "Init", _wrap_RTPSessionFacade_Init);
  SWIGV8_AddMemberFunction(_exports_RTPSessionFacade_class, "SetLocalPort", _wrap_RTPSessionFacade_SetLocalPort);
  SWIGV8_AddMemberFunction(_exports_RTPSessionFacade_class, "GetLocalPort", _wrap_RTPSessionFacade_GetLocalPort);
  SWIGV8_AddMemberFunction(_exports_RTPSessionFacade_class, "SetRemotePort", _wrap_RTPSessionFacade_SetRemotePort);
  SWIGV8_AddMemberFunction(_exports_RTPSessionFacade_class, "GetOutgoingSourceGroup", _wrap_RTPSessionFacade_GetOutgoingSourceGroup);
  SWIGV8_AddMemberFunction(_exports_RTPSessionFacade_class, "GetIncomingSourceGroup", _wrap_RTPSessionFacade_GetIncomingSourceGroup);
  SWIGV8_AddMemberFunction(_exports_RTPSessionFacade_class, "End", _wrap_RTPSessionFacade_End);
  SWIGV8_AddMemberFunction(_exports_RTPSessionFacade_class, "Enqueue", _wrap_RTPSessionFacade_Enqueue);
  SWIGV8_AddMemberFunction(_exports_RTPSessionFacade_class, "SendPLI", _wrap_RTPSessionFacade_SendPLI);
  SWIGV8_AddMemberFunction(_exports_RTPSenderFacade_class, "get", _wrap_RTPSenderFacade_get);
  SWIGV8_AddMemberFunction(_exports_RTPReceiverFacade_class, "get", _wrap_RTPReceiverFacade_get);
  SWIGV8_AddMemberFunction(_exports_RTPReceiverFacade_class, "SendPLI", _wrap_RTPReceiverFacade_SendPLI);
  SWIGV8_AddMemberFunction(_exports_RTPStreamTransponderFacade_class, "SetIncoming", _wrap_RTPStreamTransponderFacade__wrap_RTPStreamTransponderFacade_SetIncoming);
  SWIGV8_AddMemberFunction(_exports_RTPStreamTransponderFacade_class, "AppendH264ParameterSets", _wrap_RTPStreamTransponderFacade_AppendH264ParameterSets);
  SWIGV8_AddMemberFunction(_exports_RTPStreamTransponderFacade_class, "SelectLayer", _wrap_RTPStreamTransponderFacade_SelectLayer);
  SWIGV8_AddMemberFunction(_exports_RTPStreamTransponderFacade_class, "Mute", _wrap_RTPStreamTransponderFacade_Mute);
  SWIGV8_AddMemberFunction(_exports_RTPStreamTransponderFacade_class, "Close", _wrap_RTPStreamTransponderFacade_Close);
  SWIGV8_AddMemberFunction(_exports_RTPIncomingMediaStreamDepacketizer_class, "AddMediaListener", _wrap_RTPIncomingMediaStreamDepacketizer_AddMediaListener);
  SWIGV8_AddMemberFunction(_exports_RTPIncomingMediaStreamDepacketizer_class, "RemoveMediaListener", _wrap_RTPIncomingMediaStreamDepacketizer_RemoveMediaListener);
  SWIGV8_AddMemberFunction(_exports_RTPIncomingMediaStreamDepacketizer_class, "Stop", _wrap_RTPIncomingMediaStreamDepacketizer_Stop);
  SWIGV8_AddMemberFunction(_exports_MP4RecorderFacade_class, "Create", _wrap_MP4RecorderFacade_Create);
  SWIGV8_AddMemberFunction(_exports_MP4RecorderFacade_class, "Record", _wrap_MP4RecorderFacade_Record);
  SWIGV8_AddMemberFunction(_exports_MP4RecorderFacade_class, "Stop", _wrap_MP4RecorderFacade_Stop);
  SWIGV8_AddMemberFunction(_exports_MP4RecorderFacade_class, "SetTimeShiftDuration", _wrap_MP4RecorderFacade_SetTimeShiftDuration);
  SWIGV8_AddMemberFunction(_exports_MP4RecorderFacade_class, "SetH264ParameterSets", _wrap_MP4RecorderFacade_SetH264ParameterSets);
  SWIGV8_AddMemberFunction(_exports_MP4RecorderFacade_class, "Close", _wrap_MP4RecorderFacade__wrap_MP4RecorderFacade_Close);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "GetAudioSource", _wrap_PlayerFacade_GetAudioSource);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "GetVideoSource", _wrap_PlayerFacade_GetVideoSource);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "Reset", _wrap_PlayerFacade_Reset);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "Open", _wrap_PlayerFacade_Open);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "HasAudioTrack", _wrap_PlayerFacade_HasAudioTrack);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "HasVideoTrack", _wrap_PlayerFacade_HasVideoTrack);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "GetAudioCodec", _wrap_PlayerFacade_GetAudioCodec);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "GetVideoCodec", _wrap_PlayerFacade_GetVideoCodec);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "GetDuration", _wrap_PlayerFacade_GetDuration);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "GetVideoWidth", _wrap_PlayerFacade_GetVideoWidth);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "GetVideoHeight", _wrap_PlayerFacade_GetVideoHeight);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "GetVideoBitrate", _wrap_PlayerFacade_GetVideoBitrate);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "GetVideoFramerate", _wrap_PlayerFacade_GetVideoFramerate);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "Play", _wrap_PlayerFacade_Play);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "PreSeek", _wrap_PlayerFacade_PreSeek);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "Seek", _wrap_PlayerFacade_Seek);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "Tell", _wrap_PlayerFacade_Tell);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "Stop", _wrap_PlayerFacade_Stop);
  SWIGV8_AddMemberFunction(_exports_PlayerFacade_class, "Close", _wrap_PlayerFacade_Close);
  SWIGV8_AddMemberFunction(_exports_ActiveSpeakerDetectorFacade_class, "SetMinChangePeriod", _wrap_ActiveSpeakerDetectorFacade_SetMinChangePeriod);
  SWIGV8_AddMemberFunction(_exports_ActiveSpeakerDetectorFacade_class, "SetMaxAccumulatedScore", _wrap_ActiveSpeakerDetectorFacade_SetMaxAccumulatedScore);
  SWIGV8_AddMemberFunction(_exports_ActiveSpeakerDetectorFacade_class, "SetNoiseGatingThreshold", _wrap_ActiveSpeakerDetectorFacade_SetNoiseGatingThreshold);
  SWIGV8_AddMemberFunction(_exports_ActiveSpeakerDetectorFacade_class, "SetMinActivationScore", _wrap_ActiveSpeakerDetectorFacade_SetMinActivationScore);
  SWIGV8_AddMemberFunction(_exports_ActiveSpeakerDetectorFacade_class, "AddIncomingSourceGroup", _wrap_ActiveSpeakerDetectorFacade_AddIncomingSourceGroup);
  SWIGV8_AddMemberFunction(_exports_ActiveSpeakerDetectorFacade_class, "RemoveIncomingSourceGroup", _wrap_ActiveSpeakerDetectorFacade_RemoveIncomingSourceGroup);
  
  
    /* setup inheritances */
    if (SWIGTYPE_p_LayerInfo->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_LayerInfo->clientdata)->class_templ.IsEmpty()))
  {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    _exports_LayerSource_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_LayerInfo->clientdata)->class_templ);
  #else
    _exports_LayerSource_class->Inherit(
      v8::Local<v8::FunctionTemplate>::New(
        v8::Isolate::GetCurrent(),
        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_LayerInfo->clientdata)->class_templ)
      );
  #endif
    
  #ifdef SWIGRUNTIME_DEBUG
    printf("Inheritance successful _exports_LayerSource _LayerInfo\n");
  #endif
  } else {
  #ifdef SWIGRUNTIME_DEBUG
    printf("Unable to inherit baseclass, it didn't exist _exports_LayerSource _LayerInfo\n");
  #endif
  }
  if (SWIGTYPE_p_RTPSource->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPSource->clientdata)->class_templ.IsEmpty()))
  {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    _exports_RTPIncomingSource_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPSource->clientdata)->class_templ);
  #else
    _exports_RTPIncomingSource_class->Inherit(
      v8::Local<v8::FunctionTemplate>::New(
        v8::Isolate::GetCurrent(),
        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPSource->clientdata)->class_templ)
      );
  #endif
    
  #ifdef SWIGRUNTIME_DEBUG
    printf("Inheritance successful _exports_RTPIncomingSource _RTPSource\n");
  #endif
  } else {
  #ifdef SWIGRUNTIME_DEBUG
    printf("Unable to inherit baseclass, it didn't exist _exports_RTPIncomingSource _RTPSource\n");
  #endif
  }
  if (SWIGTYPE_p_RTPSource->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPSource->clientdata)->class_templ.IsEmpty()))
  {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    _exports_RTPOutgoingSource_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPSource->clientdata)->class_templ);
  #else
    _exports_RTPOutgoingSource_class->Inherit(
      v8::Local<v8::FunctionTemplate>::New(
        v8::Isolate::GetCurrent(),
        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPSource->clientdata)->class_templ)
      );
  #endif
    
  #ifdef SWIGRUNTIME_DEBUG
    printf("Inheritance successful _exports_RTPOutgoingSource _RTPSource\n");
  #endif
  } else {
  #ifdef SWIGRUNTIME_DEBUG
    printf("Unable to inherit baseclass, it didn't exist _exports_RTPOutgoingSource _RTPSource\n");
  #endif
  }
  if (SWIGTYPE_p_RTPIncomingMediaStream->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPIncomingMediaStream->clientdata)->class_templ.IsEmpty()))
  {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    _exports_RTPIncomingSourceGroup_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPIncomingMediaStream->clientdata)->class_templ);
  #else
    _exports_RTPIncomingSourceGroup_class->Inherit(
      v8::Local<v8::FunctionTemplate>::New(
        v8::Isolate::GetCurrent(),
        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPIncomingMediaStream->clientdata)->class_templ)
      );
  #endif
    
  #ifdef SWIGRUNTIME_DEBUG
    printf("Inheritance successful _exports_RTPIncomingSourceGroup _RTPIncomingMediaStream\n");
  #endif
  } else {
  #ifdef SWIGRUNTIME_DEBUG
    printf("Unable to inherit baseclass, it didn't exist _exports_RTPIncomingSourceGroup _RTPIncomingMediaStream\n");
  #endif
  }
  if (SWIGTYPE_p_RTPIncomingMediaStream->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPIncomingMediaStream->clientdata)->class_templ.IsEmpty()))
  {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    _exports_RTPIncomingMediaStreamMultiplexer_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPIncomingMediaStream->clientdata)->class_templ);
  #else
    _exports_RTPIncomingMediaStreamMultiplexer_class->Inherit(
      v8::Local<v8::FunctionTemplate>::New(
        v8::Isolate::GetCurrent(),
        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPIncomingMediaStream->clientdata)->class_templ)
      );
  #endif
    
  #ifdef SWIGRUNTIME_DEBUG
    printf("Inheritance successful _exports_RTPIncomingMediaStreamMultiplexer _RTPIncomingMediaStream\n");
  #endif
  } else {
  #ifdef SWIGRUNTIME_DEBUG
    printf("Unable to inherit baseclass, it didn't exist _exports_RTPIncomingMediaStreamMultiplexer _RTPIncomingMediaStream\n");
  #endif
  }
  if (SWIGTYPE_p_RTPSender->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPSender->clientdata)->class_templ.IsEmpty()))
  {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    _exports_RTPSessionFacade_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPSender->clientdata)->class_templ);
  #else
    _exports_RTPSessionFacade_class->Inherit(
      v8::Local<v8::FunctionTemplate>::New(
        v8::Isolate::GetCurrent(),
        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RTPSender->clientdata)->class_templ)
      );
  #endif
    
  #ifdef SWIGRUNTIME_DEBUG
    printf("Inheritance successful _exports_RTPSessionFacade _RTPSender\n");
  #endif
  } else {
  #ifdef SWIGRUNTIME_DEBUG
    printf("Unable to inherit baseclass, it didn't exist _exports_RTPSessionFacade _RTPSender\n");
  #endif
  }
  if (SWIGTYPE_p_MediaFrameListener->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_MediaFrameListener->clientdata)->class_templ.IsEmpty()))
  {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    _exports_MP4RecorderFacade_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_MediaFrameListener->clientdata)->class_templ);
  #else
    _exports_MP4RecorderFacade_class->Inherit(
      v8::Local<v8::FunctionTemplate>::New(
        v8::Isolate::GetCurrent(),
        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_MediaFrameListener->clientdata)->class_templ)
      );
  #endif
    
  #ifdef SWIGRUNTIME_DEBUG
    printf("Inheritance successful _exports_MP4RecorderFacade _MediaFrameListener\n");
  #endif
  } else {
  #ifdef SWIGRUNTIME_DEBUG
    printf("Unable to inherit baseclass, it didn't exist _exports_MP4RecorderFacade _MediaFrameListener\n");
  #endif
  }
  if (SWIGTYPE_p_RemoteRateEstimatorListener->clientdata && !(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RemoteRateEstimatorListener->clientdata)->class_templ.IsEmpty()))
  {
  #if (V8_MAJOR_VERSION-0) < 4 && (SWIG_V8_VERSION < 0x031903)
    _exports_SenderSideEstimatorListener_class->Inherit(static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RemoteRateEstimatorListener->clientdata)->class_templ);
  #else
    _exports_SenderSideEstimatorListener_class->Inherit(
      v8::Local<v8::FunctionTemplate>::New(
        v8::Isolate::GetCurrent(),
        static_cast<SWIGV8_ClientData *>(SWIGTYPE_p_RemoteRateEstimatorListener->clientdata)->class_templ)
      );
  #endif
    
  #ifdef SWIGRUNTIME_DEBUG
    printf("Inheritance successful _exports_SenderSideEstimatorListener _RemoteRateEstimatorListener\n");
  #endif
  } else {
  #ifdef SWIGRUNTIME_DEBUG
    printf("Unable to inherit baseclass, it didn't exist _exports_SenderSideEstimatorListener _RemoteRateEstimatorListener\n");
  #endif
  }
  
  
    /* class instances */
    /* Class: LayerInfo (_exports_LayerInfo) */
  v8::Handle<v8::FunctionTemplate> _exports_LayerInfo_class_0 = SWIGV8_CreateClassTemplate("LayerInfo");
  _exports_LayerInfo_class_0->SetCallHandler(_wrap_new_LayerInfo);
  _exports_LayerInfo_class_0->Inherit(_exports_LayerInfo_class);
  _exports_LayerInfo_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_LayerInfo_obj = _exports_LayerInfo_class_0->GetFunction();
  /* Class: LayerSource (_exports_LayerSource) */
  v8::Handle<v8::FunctionTemplate> _exports_LayerSource_class_0 = SWIGV8_CreateClassTemplate("LayerSource");
  _exports_LayerSource_class_0->SetCallHandler(_wrap_new_LayerSource);
  _exports_LayerSource_class_0->Inherit(_exports_LayerSource_class);
  _exports_LayerSource_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_LayerSource_obj = _exports_LayerSource_class_0->GetFunction();
  /* Class: LayerSources (_exports_LayerSources) */
  v8::Handle<v8::FunctionTemplate> _exports_LayerSources_class_0 = SWIGV8_CreateClassTemplate("LayerSources");
  _exports_LayerSources_class_0->SetCallHandler(_wrap_new_LayerSources);
  _exports_LayerSources_class_0->Inherit(_exports_LayerSources_class);
  _exports_LayerSources_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_LayerSources_obj = _exports_LayerSources_class_0->GetFunction();
  /* Class: RTPSource (_exports_RTPSource) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPSource_class_0 = SWIGV8_CreateClassTemplate("RTPSource");
  _exports_RTPSource_class_0->SetCallHandler(_wrap_new_RTPSource);
  _exports_RTPSource_class_0->Inherit(_exports_RTPSource_class);
  _exports_RTPSource_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPSource_obj = _exports_RTPSource_class_0->GetFunction();
  /* Class: RTPIncomingSource (_exports_RTPIncomingSource) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingSource_class_0 = SWIGV8_CreateClassTemplate("RTPIncomingSource");
  _exports_RTPIncomingSource_class_0->SetCallHandler(_wrap_new_RTPIncomingSource);
  _exports_RTPIncomingSource_class_0->Inherit(_exports_RTPIncomingSource_class);
  _exports_RTPIncomingSource_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPIncomingSource_obj = _exports_RTPIncomingSource_class_0->GetFunction();
  /* Class: RTPOutgoingSource (_exports_RTPOutgoingSource) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPOutgoingSource_class_0 = SWIGV8_CreateClassTemplate("RTPOutgoingSource");
  _exports_RTPOutgoingSource_class_0->SetCallHandler(_wrap_new_RTPOutgoingSource);
  _exports_RTPOutgoingSource_class_0->Inherit(_exports_RTPOutgoingSource_class);
  _exports_RTPOutgoingSource_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPOutgoingSource_obj = _exports_RTPOutgoingSource_class_0->GetFunction();
  /* Class: TimeService (_exports_TimeService) */
  v8::Handle<v8::FunctionTemplate> _exports_TimeService_class_0 = SWIGV8_CreateClassTemplate("TimeService");
  _exports_TimeService_class_0->SetCallHandler(_wrap_new_veto_TimeService);
  _exports_TimeService_class_0->Inherit(_exports_TimeService_class);
  _exports_TimeService_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_TimeService_obj = _exports_TimeService_class_0->GetFunction();
  /* Class: RTPOutgoingSourceGroup (_exports_RTPOutgoingSourceGroup) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPOutgoingSourceGroup_class_0 = SWIGV8_CreateClassTemplate("RTPOutgoingSourceGroup");
  _exports_RTPOutgoingSourceGroup_class_0->SetCallHandler(_wrap_new_RTPOutgoingSourceGroup);
  _exports_RTPOutgoingSourceGroup_class_0->Inherit(_exports_RTPOutgoingSourceGroup_class);
  _exports_RTPOutgoingSourceGroup_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPOutgoingSourceGroup_obj = _exports_RTPOutgoingSourceGroup_class_0->GetFunction();
  /* Class: RTPSender (_exports_RTPSender) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPSender_class_0 = SWIGV8_CreateClassTemplate("RTPSender");
  _exports_RTPSender_class_0->SetCallHandler(_wrap_new_veto_RTPSender);
  _exports_RTPSender_class_0->Inherit(_exports_RTPSender_class);
  _exports_RTPSender_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPSender_obj = _exports_RTPSender_class_0->GetFunction();
  /* Class: RTPReceiver (_exports_RTPReceiver) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPReceiver_class_0 = SWIGV8_CreateClassTemplate("RTPReceiver");
  _exports_RTPReceiver_class_0->SetCallHandler(_wrap_new_veto_RTPReceiver);
  _exports_RTPReceiver_class_0->Inherit(_exports_RTPReceiver_class);
  _exports_RTPReceiver_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPReceiver_obj = _exports_RTPReceiver_class_0->GetFunction();
  /* Class: RTPIncomingMediaStreamListener (_exports_RTPIncomingMediaStreamListener) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingMediaStreamListener_class_0 = SWIGV8_CreateClassTemplate("RTPIncomingMediaStreamListener");
  _exports_RTPIncomingMediaStreamListener_class_0->SetCallHandler(_wrap_new_veto_RTPIncomingMediaStreamListener);
  _exports_RTPIncomingMediaStreamListener_class_0->Inherit(_exports_RTPIncomingMediaStreamListener_class);
  _exports_RTPIncomingMediaStreamListener_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPIncomingMediaStreamListener_obj = _exports_RTPIncomingMediaStreamListener_class_0->GetFunction();
  /* Class: RTPIncomingMediaStream (_exports_RTPIncomingMediaStream) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingMediaStream_class_0 = SWIGV8_CreateClassTemplate("RTPIncomingMediaStream");
  _exports_RTPIncomingMediaStream_class_0->SetCallHandler(_wrap_new_veto_RTPIncomingMediaStream);
  _exports_RTPIncomingMediaStream_class_0->Inherit(_exports_RTPIncomingMediaStream_class);
  _exports_RTPIncomingMediaStream_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPIncomingMediaStream_obj = _exports_RTPIncomingMediaStream_class_0->GetFunction();
  /* Class: RTPIncomingSourceGroup (_exports_RTPIncomingSourceGroup) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingSourceGroup_class_0 = SWIGV8_CreateClassTemplate("RTPIncomingSourceGroup");
  _exports_RTPIncomingSourceGroup_class_0->SetCallHandler(_wrap_new_RTPIncomingSourceGroup);
  _exports_RTPIncomingSourceGroup_class_0->Inherit(_exports_RTPIncomingSourceGroup_class);
  _exports_RTPIncomingSourceGroup_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPIncomingSourceGroup_obj = _exports_RTPIncomingSourceGroup_class_0->GetFunction();
  /* Class: RTPIncomingMediaStreamMultiplexer (_exports_RTPIncomingMediaStreamMultiplexer) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingMediaStreamMultiplexer_class_0 = SWIGV8_CreateClassTemplate("RTPIncomingMediaStreamMultiplexer");
  _exports_RTPIncomingMediaStreamMultiplexer_class_0->SetCallHandler(_wrap_new_RTPIncomingMediaStreamMultiplexer);
  _exports_RTPIncomingMediaStreamMultiplexer_class_0->Inherit(_exports_RTPIncomingMediaStreamMultiplexer_class);
  _exports_RTPIncomingMediaStreamMultiplexer_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPIncomingMediaStreamMultiplexer_obj = _exports_RTPIncomingMediaStreamMultiplexer_class_0->GetFunction();
  /* Class: PropertiesFacade (_exports_PropertiesFacade) */
  v8::Handle<v8::FunctionTemplate> _exports_PropertiesFacade_class_0 = SWIGV8_CreateClassTemplate("PropertiesFacade");
  _exports_PropertiesFacade_class_0->SetCallHandler(_wrap_new_PropertiesFacade);
  _exports_PropertiesFacade_class_0->Inherit(_exports_PropertiesFacade_class);
  _exports_PropertiesFacade_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_PropertiesFacade_obj = _exports_PropertiesFacade_class_0->GetFunction();
  /* Class: MediaServer (_exports_MediaServer) */
  v8::Handle<v8::FunctionTemplate> _exports_MediaServer_class_0 = SWIGV8_CreateClassTemplate("MediaServer");
  _exports_MediaServer_class_0->SetCallHandler(_wrap_new_MediaServer);
  _exports_MediaServer_class_0->Inherit(_exports_MediaServer_class);
  _exports_MediaServer_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_MediaServer_obj = _exports_MediaServer_class_0->GetFunction();
  /* Class: RTPBundleTransportConnection (_exports_RTPBundleTransportConnection) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPBundleTransportConnection_class_0 = SWIGV8_CreateClassTemplate("RTPBundleTransportConnection");
  _exports_RTPBundleTransportConnection_class_0->SetCallHandler(_wrap_new_veto_RTPBundleTransportConnection);
  _exports_RTPBundleTransportConnection_class_0->Inherit(_exports_RTPBundleTransportConnection_class);
  _exports_RTPBundleTransportConnection_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPBundleTransportConnection_obj = _exports_RTPBundleTransportConnection_class_0->GetFunction();
  /* Class: RTPBundleTransport (_exports_RTPBundleTransport) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPBundleTransport_class_0 = SWIGV8_CreateClassTemplate("RTPBundleTransport");
  _exports_RTPBundleTransport_class_0->SetCallHandler(_wrap_new_RTPBundleTransport);
  _exports_RTPBundleTransport_class_0->Inherit(_exports_RTPBundleTransport_class);
  _exports_RTPBundleTransport_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPBundleTransport_obj = _exports_RTPBundleTransport_class_0->GetFunction();
  /* Class: UDPReader (_exports_UDPReader) */
  v8::Handle<v8::FunctionTemplate> _exports_UDPReader_class_0 = SWIGV8_CreateClassTemplate("UDPReader");
  _exports_UDPReader_class_0->SetCallHandler(_wrap_new_veto_UDPReader);
  _exports_UDPReader_class_0->Inherit(_exports_UDPReader_class);
  _exports_UDPReader_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_UDPReader_obj = _exports_UDPReader_class_0->GetFunction();
  /* Class: PCAPTransportEmulator (_exports_PCAPTransportEmulator) */
  v8::Handle<v8::FunctionTemplate> _exports_PCAPTransportEmulator_class_0 = SWIGV8_CreateClassTemplate("PCAPTransportEmulator");
  _exports_PCAPTransportEmulator_class_0->SetCallHandler(_wrap_new_PCAPTransportEmulator);
  _exports_PCAPTransportEmulator_class_0->Inherit(_exports_PCAPTransportEmulator_class);
  _exports_PCAPTransportEmulator_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_PCAPTransportEmulator_obj = _exports_PCAPTransportEmulator_class_0->GetFunction();
  /* Class: DTLSICETransportListener (_exports_DTLSICETransportListener) */
  v8::Handle<v8::FunctionTemplate> _exports_DTLSICETransportListener_class_0 = SWIGV8_CreateClassTemplate("DTLSICETransportListener");
  _exports_DTLSICETransportListener_class_0->SetCallHandler(_wrap_new_DTLSICETransportListener);
  _exports_DTLSICETransportListener_class_0->Inherit(_exports_DTLSICETransportListener_class);
  _exports_DTLSICETransportListener_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_DTLSICETransportListener_obj = _exports_DTLSICETransportListener_class_0->GetFunction();
  /* Class: RemoteRateEstimatorListener (_exports_RemoteRateEstimatorListener) */
  v8::Handle<v8::FunctionTemplate> _exports_RemoteRateEstimatorListener_class_0 = SWIGV8_CreateClassTemplate("RemoteRateEstimatorListener");
  _exports_RemoteRateEstimatorListener_class_0->SetCallHandler(_wrap_new_veto_RemoteRateEstimatorListener);
  _exports_RemoteRateEstimatorListener_class_0->Inherit(_exports_RemoteRateEstimatorListener_class);
  _exports_RemoteRateEstimatorListener_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RemoteRateEstimatorListener_obj = _exports_RemoteRateEstimatorListener_class_0->GetFunction();
  /* Class: DTLSICETransport (_exports_DTLSICETransport) */
  v8::Handle<v8::FunctionTemplate> _exports_DTLSICETransport_class_0 = SWIGV8_CreateClassTemplate("DTLSICETransport");
  _exports_DTLSICETransport_class_0->SetCallHandler(_wrap_new_veto_DTLSICETransport);
  _exports_DTLSICETransport_class_0->Inherit(_exports_DTLSICETransport_class);
  _exports_DTLSICETransport_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_DTLSICETransport_obj = _exports_DTLSICETransport_class_0->GetFunction();
  /* Class: RTPSessionFacade (_exports_RTPSessionFacade) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPSessionFacade_class_0 = SWIGV8_CreateClassTemplate("RTPSessionFacade");
  _exports_RTPSessionFacade_class_0->SetCallHandler(_wrap_new_RTPSessionFacade);
  _exports_RTPSessionFacade_class_0->Inherit(_exports_RTPSessionFacade_class);
  _exports_RTPSessionFacade_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPSessionFacade_obj = _exports_RTPSessionFacade_class_0->GetFunction();
  /* Class: RTPSenderFacade (_exports_RTPSenderFacade) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPSenderFacade_class_0 = SWIGV8_CreateClassTemplate("RTPSenderFacade");
  _exports_RTPSenderFacade_class_0->SetCallHandler(_wrap_new_RTPSenderFacade);
  _exports_RTPSenderFacade_class_0->Inherit(_exports_RTPSenderFacade_class);
  _exports_RTPSenderFacade_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPSenderFacade_obj = _exports_RTPSenderFacade_class_0->GetFunction();
  /* Class: RTPReceiverFacade (_exports_RTPReceiverFacade) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPReceiverFacade_class_0 = SWIGV8_CreateClassTemplate("RTPReceiverFacade");
  _exports_RTPReceiverFacade_class_0->SetCallHandler(_wrap_new_RTPReceiverFacade);
  _exports_RTPReceiverFacade_class_0->Inherit(_exports_RTPReceiverFacade_class);
  _exports_RTPReceiverFacade_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPReceiverFacade_obj = _exports_RTPReceiverFacade_class_0->GetFunction();
  /* Class: RTPStreamTransponderFacade (_exports_RTPStreamTransponderFacade) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPStreamTransponderFacade_class_0 = SWIGV8_CreateClassTemplate("RTPStreamTransponderFacade");
  _exports_RTPStreamTransponderFacade_class_0->SetCallHandler(_wrap_new_RTPStreamTransponderFacade);
  _exports_RTPStreamTransponderFacade_class_0->Inherit(_exports_RTPStreamTransponderFacade_class);
  _exports_RTPStreamTransponderFacade_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPStreamTransponderFacade_obj = _exports_RTPStreamTransponderFacade_class_0->GetFunction();
  /* Class: MediaFrameListener (_exports_MediaFrameListener) */
  v8::Handle<v8::FunctionTemplate> _exports_MediaFrameListener_class_0 = SWIGV8_CreateClassTemplate("MediaFrameListener");
  _exports_MediaFrameListener_class_0->SetCallHandler(_wrap_new_veto_MediaFrameListener);
  _exports_MediaFrameListener_class_0->Inherit(_exports_MediaFrameListener_class);
  _exports_MediaFrameListener_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_MediaFrameListener_obj = _exports_MediaFrameListener_class_0->GetFunction();
  /* Class: RTPIncomingMediaStreamDepacketizer (_exports_RTPIncomingMediaStreamDepacketizer) */
  v8::Handle<v8::FunctionTemplate> _exports_RTPIncomingMediaStreamDepacketizer_class_0 = SWIGV8_CreateClassTemplate("RTPIncomingMediaStreamDepacketizer");
  _exports_RTPIncomingMediaStreamDepacketizer_class_0->SetCallHandler(_wrap_new_RTPIncomingMediaStreamDepacketizer);
  _exports_RTPIncomingMediaStreamDepacketizer_class_0->Inherit(_exports_RTPIncomingMediaStreamDepacketizer_class);
  _exports_RTPIncomingMediaStreamDepacketizer_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_RTPIncomingMediaStreamDepacketizer_obj = _exports_RTPIncomingMediaStreamDepacketizer_class_0->GetFunction();
  /* Class: MP4RecorderFacade (_exports_MP4RecorderFacade) */
  v8::Handle<v8::FunctionTemplate> _exports_MP4RecorderFacade_class_0 = SWIGV8_CreateClassTemplate("MP4RecorderFacade");
  _exports_MP4RecorderFacade_class_0->SetCallHandler(_wrap_new_MP4RecorderFacade);
  _exports_MP4RecorderFacade_class_0->Inherit(_exports_MP4RecorderFacade_class);
  _exports_MP4RecorderFacade_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_MP4RecorderFacade_obj = _exports_MP4RecorderFacade_class_0->GetFunction();
  /* Class: PlayerFacade (_exports_PlayerFacade) */
  v8::Handle<v8::FunctionTemplate> _exports_PlayerFacade_class_0 = SWIGV8_CreateClassTemplate("PlayerFacade");
  _exports_PlayerFacade_class_0->SetCallHandler(_wrap_new_PlayerFacade);
  _exports_PlayerFacade_class_0->Inherit(_exports_PlayerFacade_class);
  _exports_PlayerFacade_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_PlayerFacade_obj = _exports_PlayerFacade_class_0->GetFunction();
  /* Class: SenderSideEstimatorListener (_exports_SenderSideEstimatorListener) */
  v8::Handle<v8::FunctionTemplate> _exports_SenderSideEstimatorListener_class_0 = SWIGV8_CreateClassTemplate("SenderSideEstimatorListener");
  _exports_SenderSideEstimatorListener_class_0->SetCallHandler(_wrap_new_SenderSideEstimatorListener);
  _exports_SenderSideEstimatorListener_class_0->Inherit(_exports_SenderSideEstimatorListener_class);
  _exports_SenderSideEstimatorListener_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_SenderSideEstimatorListener_obj = _exports_SenderSideEstimatorListener_class_0->GetFunction();
  /* Class: ActiveSpeakerDetectorFacade (_exports_ActiveSpeakerDetectorFacade) */
  v8::Handle<v8::FunctionTemplate> _exports_ActiveSpeakerDetectorFacade_class_0 = SWIGV8_CreateClassTemplate("ActiveSpeakerDetectorFacade");
  _exports_ActiveSpeakerDetectorFacade_class_0->SetCallHandler(_wrap_new_ActiveSpeakerDetectorFacade);
  _exports_ActiveSpeakerDetectorFacade_class_0->Inherit(_exports_ActiveSpeakerDetectorFacade_class);
  _exports_ActiveSpeakerDetectorFacade_class_0->SetHiddenPrototype(true);
  v8::Handle<v8::Object> _exports_ActiveSpeakerDetectorFacade_obj = _exports_ActiveSpeakerDetectorFacade_class_0->GetFunction();
  
  
    /* add static class functions and variables */
    SWIGV8_AddStaticVariable(_exports_LayerInfo_obj, "MaxLayerId", _wrap_LayerInfo_MaxLayerId_get, _wrap_LayerInfo_MaxLayerId_set);
  SWIGV8_AddStaticFunction(_exports_MediaServer_obj, "Initialize", _wrap_MediaServer_Initialize);
  SWIGV8_AddStaticFunction(_exports_MediaServer_obj, "Terminate", _wrap_MediaServer_Terminate);
  SWIGV8_AddStaticFunction(_exports_MediaServer_obj, "EnableLog", _wrap_MediaServer_EnableLog);
  SWIGV8_AddStaticFunction(_exports_MediaServer_obj, "EnableDebug", _wrap_MediaServer_EnableDebug);
  SWIGV8_AddStaticFunction(_exports_MediaServer_obj, "EnableUltraDebug", _wrap_MediaServer_EnableUltraDebug);
  SWIGV8_AddStaticFunction(_exports_MediaServer_obj, "SetCertificate", _wrap_MediaServer_SetCertificate);
  SWIGV8_AddStaticFunction(_exports_MediaServer_obj, "GetFingerprint", _wrap_MediaServer_GetFingerprint);
  SWIGV8_AddStaticFunction(_exports_MediaServer_obj, "SetPortRange", _wrap_MediaServer_SetPortRange);
  SWIGV8_AddStaticFunction(exports_obj, "TransportToSender", _wrap_TransportToSender);
  SWIGV8_AddStaticFunction(exports_obj, "TransportToReceiver", _wrap_TransportToReceiver);
  SWIGV8_AddStaticFunction(exports_obj, "PCAPTransportEmulatorToReceiver", _wrap_PCAPTransportEmulatorToReceiver);
  SWIGV8_AddStaticFunction(exports_obj, "SessionToSender", _wrap_SessionToSender);
  SWIGV8_AddStaticFunction(exports_obj, "SessionToReceiver", _wrap_SessionToReceiver);
  
  
    /* register classes */
    exports_obj->Set(SWIGV8_SYMBOL_NEW("LayerInfo"), _exports_LayerInfo_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("LayerSource"), _exports_LayerSource_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("LayerSources"), _exports_LayerSources_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPSource"), _exports_RTPSource_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPIncomingSource"), _exports_RTPIncomingSource_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPOutgoingSource"), _exports_RTPOutgoingSource_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("TimeService"), _exports_TimeService_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPOutgoingSourceGroup"), _exports_RTPOutgoingSourceGroup_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPSender"), _exports_RTPSender_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPReceiver"), _exports_RTPReceiver_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPIncomingMediaStreamListener"), _exports_RTPIncomingMediaStreamListener_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPIncomingMediaStream"), _exports_RTPIncomingMediaStream_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPIncomingSourceGroup"), _exports_RTPIncomingSourceGroup_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPIncomingMediaStreamMultiplexer"), _exports_RTPIncomingMediaStreamMultiplexer_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("PropertiesFacade"), _exports_PropertiesFacade_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("MediaServer"), _exports_MediaServer_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPBundleTransportConnection"), _exports_RTPBundleTransportConnection_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPBundleTransport"), _exports_RTPBundleTransport_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("UDPReader"), _exports_UDPReader_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("PCAPTransportEmulator"), _exports_PCAPTransportEmulator_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("DTLSICETransportListener"), _exports_DTLSICETransportListener_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RemoteRateEstimatorListener"), _exports_RemoteRateEstimatorListener_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("DTLSICETransport"), _exports_DTLSICETransport_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPSessionFacade"), _exports_RTPSessionFacade_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPSenderFacade"), _exports_RTPSenderFacade_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPReceiverFacade"), _exports_RTPReceiverFacade_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPStreamTransponderFacade"), _exports_RTPStreamTransponderFacade_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("MediaFrameListener"), _exports_MediaFrameListener_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("RTPIncomingMediaStreamDepacketizer"), _exports_RTPIncomingMediaStreamDepacketizer_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("MP4RecorderFacade"), _exports_MP4RecorderFacade_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("PlayerFacade"), _exports_PlayerFacade_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("SenderSideEstimatorListener"), _exports_SenderSideEstimatorListener_obj);
  exports_obj->Set(SWIGV8_SYMBOL_NEW("ActiveSpeakerDetectorFacade"), _exports_ActiveSpeakerDetectorFacade_obj);
  
  
    /* create and register namespace objects */
    
  }
  
  #if defined(BUILDING_NODE_EXTENSION)
  NODE_MODULE(medooze, medooze_initialize)
  #endif
  