/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.7
 * 
 * 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. 
 * ----------------------------------------------------------------------------- */

#define SWIGCSHARP
#define SWIG_DIRECTORS


#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 (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  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



#include <stdlib.h>
#include <string.h>
#include <stdio.h>


/* Support for throwing C# exceptions from C/C++. There are two types: 
 * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
typedef enum {
  SWIG_CSharpApplicationException,
  SWIG_CSharpArithmeticException,
  SWIG_CSharpDivideByZeroException,
  SWIG_CSharpIndexOutOfRangeException,
  SWIG_CSharpInvalidCastException,
  SWIG_CSharpInvalidOperationException,
  SWIG_CSharpIOException,
  SWIG_CSharpNullReferenceException,
  SWIG_CSharpOutOfMemoryException,
  SWIG_CSharpOverflowException,
  SWIG_CSharpSystemException
} SWIG_CSharpExceptionCodes;

typedef enum {
  SWIG_CSharpArgumentException,
  SWIG_CSharpArgumentNullException,
  SWIG_CSharpArgumentOutOfRangeException
} SWIG_CSharpExceptionArgumentCodes;

typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);

typedef struct {
  SWIG_CSharpExceptionCodes code;
  SWIG_CSharpExceptionCallback_t callback;
} SWIG_CSharpException_t;

typedef struct {
  SWIG_CSharpExceptionArgumentCodes code;
  SWIG_CSharpExceptionArgumentCallback_t callback;
} SWIG_CSharpExceptionArgument_t;

static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
  { SWIG_CSharpApplicationException, NULL },
  { SWIG_CSharpArithmeticException, NULL },
  { SWIG_CSharpDivideByZeroException, NULL },
  { SWIG_CSharpIndexOutOfRangeException, NULL },
  { SWIG_CSharpInvalidCastException, NULL },
  { SWIG_CSharpInvalidOperationException, NULL },
  { SWIG_CSharpIOException, NULL },
  { SWIG_CSharpNullReferenceException, NULL },
  { SWIG_CSharpOutOfMemoryException, NULL },
  { SWIG_CSharpOverflowException, NULL },
  { SWIG_CSharpSystemException, NULL }
};

static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
  { SWIG_CSharpArgumentException, NULL },
  { SWIG_CSharpArgumentNullException, NULL },
  { SWIG_CSharpArgumentOutOfRangeException, NULL }
};

static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
    callback = SWIG_csharp_exceptions[code].callback;
  }
  callback(msg);
}

static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
  SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
    callback = SWIG_csharp_exceptions_argument[code].callback;
  }
  callback(msg, param_name);
}


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_cAudioCSharpWrapper(
                                                SWIG_CSharpExceptionCallback_t applicationCallback,
                                                SWIG_CSharpExceptionCallback_t arithmeticCallback,
                                                SWIG_CSharpExceptionCallback_t divideByZeroCallback, 
                                                SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, 
                                                SWIG_CSharpExceptionCallback_t invalidCastCallback,
                                                SWIG_CSharpExceptionCallback_t invalidOperationCallback,
                                                SWIG_CSharpExceptionCallback_t ioCallback,
                                                SWIG_CSharpExceptionCallback_t nullReferenceCallback,
                                                SWIG_CSharpExceptionCallback_t outOfMemoryCallback, 
                                                SWIG_CSharpExceptionCallback_t overflowCallback, 
                                                SWIG_CSharpExceptionCallback_t systemCallback) {
  SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
  SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
}

#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_cAudioCSharpWrapper(
                                                SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
}


/* Callback for returning strings to C# without leaking memory */
typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_cAudioCSharpWrapper(SWIG_CSharpStringHelperCallback callback) {
  SWIG_csharp_string_callback = callback;
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else

/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that C# proxy 
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus

#if defined(DEBUG_DIRECTOR_OWNED)
#include <iostream>
#endif
#include <string>

namespace Swig {
  /* Director base class - not currently used in C# directors */
  class Director {
  };

  /* Base class for director exceptions */
  class DirectorException {
  protected:
    std::string swig_msg;

  public:
    DirectorException(const char* msg) : swig_msg(msg) {
    }
    DirectorException(const std::string &msg) : swig_msg(msg) {
    }
    const std::string& what() const {
      return swig_msg;
    }
    virtual ~DirectorException() {
    }
  };

  /* Pure virtual method exception */
  class DirectorPureVirtualException : public Swig::DirectorException {
  public:
    DirectorPureVirtualException(const char* msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
    }
  };
}

#endif /* __cplusplus */



#include <string>


#include <stdexcept>


#include <vector>
#include <algorithm>
#include <stdexcept>


#include <map>
#include <algorithm>
#include <stdexcept>


#include "cAudioString.h"
#include "IRefCounted.h"
#include "EAudioFormats.h"
#include "IAudioEffects.h"
#include "IAudioManager.h"
#include "IAudioPlugin.h"
#include "IAudioSource.h"
#include "ICaptureEventHandler.h"
#include "IDataSource.h"
#include "IDataSourceFactory.h"
#include "IEffect.h"
#include "IEffectParameters.h"
#include "IFilter.h"
#include "IListener.h"
#include "ILogger.h"
#include "ILogReceiver.h"
#include "IManagerEventHandler.h"
#include "IMemoryProvider.h"
#include "IPluginManager.h"
#include "ISourceEventHandler.h"
#include "IThread.h"
#include "cAudio.h"
#include "cAudioDefines.h"
#include "cAudioMemory.h"
#include "cAudioPlatform.h"
#include "cAudioSleep.h"
#include "cSTLAllocator.h"
#include "cVector3.h"
#include "IAudioCapture.h"
#include "IAudioDecoder.h"
#include "IAudioDecoderFactory.h"
#include "IAudioDeviceList.h"
#include "IAudioDeviceContext.h"

SWIGINTERN std::vector< int > *new_std_vector_Sl_int_Sg___SWIG_2(int capacity){
        std::vector< int >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< int >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN int std_vector_Sl_int_Sg__getitemcopy(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__getitem(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__setitem(std::vector< int > *self,int index,int const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__AddRange(std::vector< int > *self,std::vector< int > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__GetRange(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< int >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int_Sg__Insert(std::vector< int > *self,int index,int const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__InsertRange(std::vector< int > *self,int index,std::vector< int > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__RemoveAt(std::vector< int > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_int_Sg__RemoveRange(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< int > *std_vector_Sl_int_Sg__Repeat(int const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< int >(count, value);
      }
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_0(std::vector< int > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_int_Sg__Reverse__SWIG_1(std::vector< int > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_int_Sg__SetRange(std::vector< int > *self,int index,std::vector< int > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_int_Sg__Contains(std::vector< int > *self,int const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_int_Sg__IndexOf(std::vector< int > *self,int const &value){
        int index = -1;
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_int_Sg__LastIndexOf(std::vector< int > *self,int const &value){
        int index = -1;
        std::vector< int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_int_Sg__Remove(std::vector< int > *self,int const &value){
        std::vector< int >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< double > *new_std_vector_Sl_double_Sg___SWIG_2(int capacity){
        std::vector< double >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< double >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN double std_vector_Sl_double_Sg__getitemcopy(std::vector< double > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< double >::const_reference std_vector_Sl_double_Sg__getitem(std::vector< double > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__setitem(std::vector< double > *self,int index,double const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__AddRange(std::vector< double > *self,std::vector< double > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__GetRange(std::vector< double > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< double >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_double_Sg__Insert(std::vector< double > *self,int index,double const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__InsertRange(std::vector< double > *self,int index,std::vector< double > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__RemoveAt(std::vector< double > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_double_Sg__RemoveRange(std::vector< double > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< double > *std_vector_Sl_double_Sg__Repeat(double const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< double >(count, value);
      }
SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_0(std::vector< double > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_double_Sg__Reverse__SWIG_1(std::vector< double > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_double_Sg__SetRange(std::vector< double > *self,int index,std::vector< double > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_double_Sg__Contains(std::vector< double > *self,double const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_double_Sg__IndexOf(std::vector< double > *self,double const &value){
        int index = -1;
        std::vector< double >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_double_Sg__LastIndexOf(std::vector< double > *self,double const &value){
        int index = -1;
        std::vector< double >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_double_Sg__Remove(std::vector< double > *self,double const &value){
        std::vector< double >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::vector< std::string > *new_std_vector_Sl_std_string_Sg___SWIG_2(int capacity){
        std::vector< std::string >* pv = 0;
        if (capacity >= 0) {
          pv = new std::vector< std::string >();
          pv->reserve(capacity);
       } else {
          throw std::out_of_range("capacity");
       }
       return pv;
      }
SWIGINTERN std::string std_vector_Sl_std_string_Sg__getitemcopy(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__getitem(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          return (*self)[index];
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__setitem(std::vector< std::string > *self,int index,std::string const &val){
        if (index>=0 && index<(int)self->size())
          (*self)[index] = val;
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__AddRange(std::vector< std::string > *self,std::vector< std::string > const &values){
        self->insert(self->end(), values.begin(), values.end());
      }
SWIGINTERN std::vector< std::string > *std_vector_Sl_std_string_Sg__GetRange(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        return new std::vector< std::string >(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Insert(std::vector< std::string > *self,int index,std::string const &x){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, x);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__InsertRange(std::vector< std::string > *self,int index,std::vector< std::string > const &values){
        if (index>=0 && index<(int)self->size()+1)
          self->insert(self->begin()+index, values.begin(), values.end());
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__RemoveAt(std::vector< std::string > *self,int index){
        if (index>=0 && index<(int)self->size())
          self->erase(self->begin() + index);
        else
          throw std::out_of_range("index");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__RemoveRange(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        self->erase(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN std::vector< std::string > *std_vector_Sl_std_string_Sg__Repeat(std::string const &value,int count){
        if (count < 0)
          throw std::out_of_range("count");
        return new std::vector< std::string >(count, value);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Reverse__SWIG_0(std::vector< std::string > *self){
        std::reverse(self->begin(), self->end());
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__Reverse__SWIG_1(std::vector< std::string > *self,int index,int count){
        if (index < 0)
          throw std::out_of_range("index");
        if (count < 0)
          throw std::out_of_range("count");
        if (index >= (int)self->size()+1 || index+count > (int)self->size())
          throw std::invalid_argument("invalid range");
        std::reverse(self->begin()+index, self->begin()+index+count);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__SetRange(std::vector< std::string > *self,int index,std::vector< std::string > const &values){
        if (index < 0)
          throw std::out_of_range("index");
        if (index+values.size() > self->size())
          throw std::out_of_range("index");
        std::copy(values.begin(), values.end(), self->begin()+index);
      }
SWIGINTERN bool std_vector_Sl_std_string_Sg__Contains(std::vector< std::string > *self,std::string const &value){
        return std::find(self->begin(), self->end(), value) != self->end();
      }
SWIGINTERN int std_vector_Sl_std_string_Sg__IndexOf(std::vector< std::string > *self,std::string const &value){
        int index = -1;
        std::vector< std::string >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end())
          index = (int)(it - self->begin());
        return index;
      }
SWIGINTERN int std_vector_Sl_std_string_Sg__LastIndexOf(std::vector< std::string > *self,std::string const &value){
        int index = -1;
        std::vector< std::string >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
        if (rit != self->rend())
          index = (int)(self->rend() - 1 - rit);
        return index;
      }
SWIGINTERN bool std_vector_Sl_std_string_Sg__Remove(std::vector< std::string > *self,std::string const &value){
        std::vector< std::string >::iterator it = std::find(self->begin(), self->end(), value);
        if (it != self->end()) {
          self->erase(it);
	  return true;
        }
        return false;
      }
SWIGINTERN std::map< std::string,std::string >::mapped_type const &std_map_Sl_std_string_Sc_std_string_Sg__getitem(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
        std::map< std::string,std::string >::iterator iter = self->find(key);
        if (iter != self->end())
          return iter->second;
        else
          throw std::out_of_range("key not found");
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__setitem(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key,std::map< std::string,std::string >::mapped_type const &x){
        (*self)[key] = x;
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__ContainsKey(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
        std::map< std::string, std::string >::iterator iter = self->find(key);
        return iter != self->end();
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__Add(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key,std::map< std::string,std::string >::mapped_type const &val){
        std::map< std::string, std::string >::iterator iter = self->find(key);
        if (iter != self->end())
          throw std::out_of_range("key already exists");
        self->insert(std::pair< std::string, std::string >(key, val));
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__Remove(std::map< std::string,std::string > *self,std::map< std::string,std::string >::key_type const &key){
        std::map< std::string, std::string >::iterator iter = self->find(key);
        if (iter != self->end()) {
          self->erase(iter);
          return true;
        }                
        return false;
      }
SWIGINTERN std::map< std::string,std::string >::iterator *std_map_Sl_std_string_Sc_std_string_Sg__create_iterator_begin(std::map< std::string,std::string > *self){
        return new std::map< std::string, std::string >::iterator(self->begin());
      }
SWIGINTERN std::map< std::string,std::string >::key_type const &std_map_Sl_std_string_Sc_std_string_Sg__get_next_key(std::map< std::string,std::string > *self,std::map< std::string,std::string >::iterator *swigiterator){
        std::map< std::string, std::string >::iterator iter = *swigiterator;
        (*swigiterator)++;
        return (*iter).first;
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__destroy_iterator(std::map< std::string,std::string > *self,std::map< std::string,std::string >::iterator *swigiterator){
        delete swigiterator;
      }

static float *new_floatp() { 
  return new float(); 
}

static float *copy_floatp(float value) { 
  return new float(value); 
}

static void delete_floatp(float *obj) { 
  if (obj) delete obj; 
}

static void floatp_assign(float *obj, float value) {
  *obj = value;
}

static float floatp_value(float *obj) {
  return *obj;
}



/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "cAudioWrapped_wrap.h"

SwigDirector_IDataSource::SwigDirector_IDataSource() : cAudio::IDataSource(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_IDataSource::~SwigDirector_IDataSource() {
  
}


void SwigDirector_IDataSource::grab() {
  if (!swig_callbackgrab) {
    cAudio::IRefCounted::grab();
    return;
  } else {
    swig_callbackgrab();
  }
}

bool SwigDirector_IDataSource::drop() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackdrop) {
    return cAudio::IRefCounted::drop();
  } else {
    jresult = (unsigned int) swig_callbackdrop();
    c_result = jresult ? true : false; 
  }
  return c_result;
}

bool SwigDirector_IDataSource::isValid() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackisValid) {
    throw Swig::DirectorPureVirtualException("cAudio::IDataSource::isValid");
  } else {
    jresult = (unsigned int) swig_callbackisValid();
    c_result = jresult ? true : false; 
  }
  return c_result;
}

int SwigDirector_IDataSource::getCurrentPos() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackgetCurrentPos) {
    throw Swig::DirectorPureVirtualException("cAudio::IDataSource::getCurrentPos");
  } else {
    jresult = (int) swig_callbackgetCurrentPos();
    c_result = (int)jresult; 
  }
  return c_result;
}

int SwigDirector_IDataSource::getSize() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackgetSize) {
    throw Swig::DirectorPureVirtualException("cAudio::IDataSource::getSize");
  } else {
    jresult = (int) swig_callbackgetSize();
    c_result = (int)jresult; 
  }
  return c_result;
}

int SwigDirector_IDataSource::read(void *output, int size) {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  void * joutput = 0 ;
  int jsize  ;
  
  if (!swig_callbackread) {
    throw Swig::DirectorPureVirtualException("cAudio::IDataSource::read");
  } else {
    joutput = (void *) output; 
    jsize = size;
    jresult = (int) swig_callbackread(joutput, jsize);
    c_result = (int)jresult; 
  }
  return c_result;
}

bool SwigDirector_IDataSource::seek(int amount, bool relative) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  int jamount  ;
  unsigned int jrelative  ;
  
  if (!swig_callbackseek) {
    throw Swig::DirectorPureVirtualException("cAudio::IDataSource::seek");
  } else {
    jamount = amount;
    jrelative = relative;
    jresult = (unsigned int) swig_callbackseek(jamount, jrelative);
    c_result = jresult ? true : false; 
  }
  return c_result;
}

void SwigDirector_IDataSource::swig_connect_director(SWIG_Callback0_t callbackgrab, SWIG_Callback1_t callbackdrop, SWIG_Callback2_t callbackisValid, SWIG_Callback3_t callbackgetCurrentPos, SWIG_Callback4_t callbackgetSize, SWIG_Callback5_t callbackread, SWIG_Callback6_t callbackseek) {
  swig_callbackgrab = callbackgrab;
  swig_callbackdrop = callbackdrop;
  swig_callbackisValid = callbackisValid;
  swig_callbackgetCurrentPos = callbackgetCurrentPos;
  swig_callbackgetSize = callbackgetSize;
  swig_callbackread = callbackread;
  swig_callbackseek = callbackseek;
}

void SwigDirector_IDataSource::swig_init_callbacks() {
  swig_callbackgrab = 0;
  swig_callbackdrop = 0;
  swig_callbackisValid = 0;
  swig_callbackgetCurrentPos = 0;
  swig_callbackgetSize = 0;
  swig_callbackread = 0;
  swig_callbackseek = 0;
}

SwigDirector_IDataSourceFactory::SwigDirector_IDataSourceFactory() : cAudio::IDataSourceFactory(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_IDataSourceFactory::~SwigDirector_IDataSourceFactory() {
  
}


cAudio::IDataSource *SwigDirector_IDataSourceFactory::CreateDataSource(char const *filename, bool streamingRequested) {
  cAudio::IDataSource *c_result = 0 ;
  void * jresult = 0 ;
  char * jfilename = 0 ;
  unsigned int jstreamingRequested  ;
  
  if (!swig_callbackCreateDataSource) {
    throw Swig::DirectorPureVirtualException("cAudio::IDataSourceFactory::CreateDataSource");
  } else {
    jfilename = SWIG_csharp_string_callback((const char *)filename); 
    jstreamingRequested = streamingRequested;
    jresult = (void *) swig_callbackCreateDataSource(jfilename, jstreamingRequested);
    c_result = (cAudio::IDataSource *)jresult; 
  }
  return c_result;
}

void SwigDirector_IDataSourceFactory::swig_connect_director(SWIG_Callback0_t callbackCreateDataSource) {
  swig_callbackCreateDataSource = callbackCreateDataSource;
}

void SwigDirector_IDataSourceFactory::swig_init_callbacks() {
  swig_callbackCreateDataSource = 0;
}

SwigDirector_ILogReceiver::SwigDirector_ILogReceiver() : cAudio::ILogReceiver(), Swig::Director() {
  swig_init_callbacks();
}

bool SwigDirector_ILogReceiver::OnLogMessage(char const *sender, char const *message, cAudio::LogLevel level, float time) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  char * jsender = 0 ;
  char * jmessage = 0 ;
  int jlevel  ;
  float jtime  ;
  
  if (!swig_callbackOnLogMessage) {
    throw Swig::DirectorPureVirtualException("cAudio::ILogReceiver::OnLogMessage");
  } else {
    jsender = SWIG_csharp_string_callback((const char *)sender); 
    jmessage = SWIG_csharp_string_callback((const char *)message); 
    jlevel = level;
    jtime = time;
    jresult = (unsigned int) swig_callbackOnLogMessage(jsender, jmessage, jlevel, jtime);
    c_result = jresult ? true : false; 
  }
  return c_result;
}

void SwigDirector_ILogReceiver::swig_connect_director(SWIG_Callback0_t callbackOnLogMessage) {
  swig_callbackOnLogMessage = callbackOnLogMessage;
}

void SwigDirector_ILogReceiver::swig_init_callbacks() {
  swig_callbackOnLogMessage = 0;
}

SwigDirector_IManagerEventHandler::SwigDirector_IManagerEventHandler() : cAudio::IManagerEventHandler(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_IManagerEventHandler::onInit() {
  if (!swig_callbackonInit) {
    throw Swig::DirectorPureVirtualException("cAudio::IManagerEventHandler::onInit");
  } else {
    swig_callbackonInit();
  }
}

void SwigDirector_IManagerEventHandler::onUpdate() {
  if (!swig_callbackonUpdate) {
    throw Swig::DirectorPureVirtualException("cAudio::IManagerEventHandler::onUpdate");
  } else {
    swig_callbackonUpdate();
  }
}

void SwigDirector_IManagerEventHandler::onRelease() {
  if (!swig_callbackonRelease) {
    throw Swig::DirectorPureVirtualException("cAudio::IManagerEventHandler::onRelease");
  } else {
    swig_callbackonRelease();
  }
}

void SwigDirector_IManagerEventHandler::onSourceCreate() {
  if (!swig_callbackonSourceCreate) {
    throw Swig::DirectorPureVirtualException("cAudio::IManagerEventHandler::onSourceCreate");
  } else {
    swig_callbackonSourceCreate();
  }
}

void SwigDirector_IManagerEventHandler::onDecoderRegister() {
  if (!swig_callbackonDecoderRegister) {
    throw Swig::DirectorPureVirtualException("cAudio::IManagerEventHandler::onDecoderRegister");
  } else {
    swig_callbackonDecoderRegister();
  }
}

void SwigDirector_IManagerEventHandler::onDataSourceRegister() {
  if (!swig_callbackonDataSourceRegister) {
    throw Swig::DirectorPureVirtualException("cAudio::IManagerEventHandler::onDataSourceRegister");
  } else {
    swig_callbackonDataSourceRegister();
  }
}

void SwigDirector_IManagerEventHandler::swig_connect_director(SWIG_Callback0_t callbackonInit, SWIG_Callback1_t callbackonUpdate, SWIG_Callback2_t callbackonRelease, SWIG_Callback3_t callbackonSourceCreate, SWIG_Callback4_t callbackonDecoderRegister, SWIG_Callback5_t callbackonDataSourceRegister) {
  swig_callbackonInit = callbackonInit;
  swig_callbackonUpdate = callbackonUpdate;
  swig_callbackonRelease = callbackonRelease;
  swig_callbackonSourceCreate = callbackonSourceCreate;
  swig_callbackonDecoderRegister = callbackonDecoderRegister;
  swig_callbackonDataSourceRegister = callbackonDataSourceRegister;
}

void SwigDirector_IManagerEventHandler::swig_init_callbacks() {
  swig_callbackonInit = 0;
  swig_callbackonUpdate = 0;
  swig_callbackonRelease = 0;
  swig_callbackonSourceCreate = 0;
  swig_callbackonDecoderRegister = 0;
  swig_callbackonDataSourceRegister = 0;
}

SwigDirector_ISourceEventHandler::SwigDirector_ISourceEventHandler() : cAudio::ISourceEventHandler(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_ISourceEventHandler::onUpdate() {
  if (!swig_callbackonUpdate) {
    throw Swig::DirectorPureVirtualException("cAudio::ISourceEventHandler::onUpdate");
  } else {
    swig_callbackonUpdate();
  }
}

void SwigDirector_ISourceEventHandler::onRelease() {
  if (!swig_callbackonRelease) {
    throw Swig::DirectorPureVirtualException("cAudio::ISourceEventHandler::onRelease");
  } else {
    swig_callbackonRelease();
  }
}

void SwigDirector_ISourceEventHandler::onPlay() {
  if (!swig_callbackonPlay) {
    throw Swig::DirectorPureVirtualException("cAudio::ISourceEventHandler::onPlay");
  } else {
    swig_callbackonPlay();
  }
}

void SwigDirector_ISourceEventHandler::onStop() {
  if (!swig_callbackonStop) {
    throw Swig::DirectorPureVirtualException("cAudio::ISourceEventHandler::onStop");
  } else {
    swig_callbackonStop();
  }
}

void SwigDirector_ISourceEventHandler::onPause() {
  if (!swig_callbackonPause) {
    throw Swig::DirectorPureVirtualException("cAudio::ISourceEventHandler::onPause");
  } else {
    swig_callbackonPause();
  }
}

void SwigDirector_ISourceEventHandler::swig_connect_director(SWIG_Callback0_t callbackonUpdate, SWIG_Callback1_t callbackonRelease, SWIG_Callback2_t callbackonPlay, SWIG_Callback3_t callbackonStop, SWIG_Callback4_t callbackonPause) {
  swig_callbackonUpdate = callbackonUpdate;
  swig_callbackonRelease = callbackonRelease;
  swig_callbackonPlay = callbackonPlay;
  swig_callbackonStop = callbackonStop;
  swig_callbackonPause = callbackonPause;
}

void SwigDirector_ISourceEventHandler::swig_init_callbacks() {
  swig_callbackonUpdate = 0;
  swig_callbackonRelease = 0;
  swig_callbackonPlay = 0;
  swig_callbackonStop = 0;
  swig_callbackonPause = 0;
}

SwigDirector_ICaptureEventHandler::SwigDirector_ICaptureEventHandler() : cAudio::ICaptureEventHandler(), Swig::Director() {
  swig_init_callbacks();
}

void SwigDirector_ICaptureEventHandler::onInit() {
  if (!swig_callbackonInit) {
    throw Swig::DirectorPureVirtualException("cAudio::ICaptureEventHandler::onInit");
  } else {
    swig_callbackonInit();
  }
}

void SwigDirector_ICaptureEventHandler::onUpdate() {
  if (!swig_callbackonUpdate) {
    throw Swig::DirectorPureVirtualException("cAudio::ICaptureEventHandler::onUpdate");
  } else {
    swig_callbackonUpdate();
  }
}

void SwigDirector_ICaptureEventHandler::onRelease() {
  if (!swig_callbackonRelease) {
    throw Swig::DirectorPureVirtualException("cAudio::ICaptureEventHandler::onRelease");
  } else {
    swig_callbackonRelease();
  }
}

void SwigDirector_ICaptureEventHandler::onBeginCapture() {
  if (!swig_callbackonBeginCapture) {
    throw Swig::DirectorPureVirtualException("cAudio::ICaptureEventHandler::onBeginCapture");
  } else {
    swig_callbackonBeginCapture();
  }
}

void SwigDirector_ICaptureEventHandler::onEndCapture() {
  if (!swig_callbackonEndCapture) {
    throw Swig::DirectorPureVirtualException("cAudio::ICaptureEventHandler::onEndCapture");
  } else {
    swig_callbackonEndCapture();
  }
}

void SwigDirector_ICaptureEventHandler::onUserRequestBuffer() {
  if (!swig_callbackonUserRequestBuffer) {
    throw Swig::DirectorPureVirtualException("cAudio::ICaptureEventHandler::onUserRequestBuffer");
  } else {
    swig_callbackonUserRequestBuffer();
  }
}

void SwigDirector_ICaptureEventHandler::swig_connect_director(SWIG_Callback0_t callbackonInit, SWIG_Callback1_t callbackonUpdate, SWIG_Callback2_t callbackonRelease, SWIG_Callback3_t callbackonBeginCapture, SWIG_Callback4_t callbackonEndCapture, SWIG_Callback5_t callbackonUserRequestBuffer) {
  swig_callbackonInit = callbackonInit;
  swig_callbackonUpdate = callbackonUpdate;
  swig_callbackonRelease = callbackonRelease;
  swig_callbackonBeginCapture = callbackonBeginCapture;
  swig_callbackonEndCapture = callbackonEndCapture;
  swig_callbackonUserRequestBuffer = callbackonUserRequestBuffer;
}

void SwigDirector_ICaptureEventHandler::swig_init_callbacks() {
  swig_callbackonInit = 0;
  swig_callbackonUpdate = 0;
  swig_callbackonRelease = 0;
  swig_callbackonBeginCapture = 0;
  swig_callbackonEndCapture = 0;
  swig_callbackonUserRequestBuffer = 0;
}

SwigDirector_IAudioDecoder::SwigDirector_IAudioDecoder(cAudio::IDataSource *stream) : cAudio::IAudioDecoder(stream), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_IAudioDecoder::~SwigDirector_IAudioDecoder() {
  
}


void SwigDirector_IAudioDecoder::grab() {
  if (!swig_callbackgrab) {
    cAudio::IRefCounted::grab();
    return;
  } else {
    swig_callbackgrab();
  }
}

bool SwigDirector_IAudioDecoder::drop() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackdrop) {
    return cAudio::IRefCounted::drop();
  } else {
    jresult = (unsigned int) swig_callbackdrop();
    c_result = jresult ? true : false; 
  }
  return c_result;
}

cAudio::AudioFormats SwigDirector_IAudioDecoder::getFormat() {
  cAudio::AudioFormats c_result = SwigValueInit< cAudio::AudioFormats >() ;
  int jresult = 0 ;
  
  if (!swig_callbackgetFormat) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::getFormat");
  } else {
    jresult = (int) swig_callbackgetFormat();
    c_result = (cAudio::AudioFormats)jresult; 
  }
  return c_result;
}

int SwigDirector_IAudioDecoder::getFrequency() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackgetFrequency) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::getFrequency");
  } else {
    jresult = (int) swig_callbackgetFrequency();
    c_result = (int)jresult; 
  }
  return c_result;
}

bool SwigDirector_IAudioDecoder::isSeekingSupported() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackisSeekingSupported) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::isSeekingSupported");
  } else {
    jresult = (unsigned int) swig_callbackisSeekingSupported();
    c_result = jresult ? true : false; 
  }
  return c_result;
}

bool SwigDirector_IAudioDecoder::isValid() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackisValid) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::isValid");
  } else {
    jresult = (unsigned int) swig_callbackisValid();
    c_result = jresult ? true : false; 
  }
  return c_result;
}

int SwigDirector_IAudioDecoder::readAudioData(void *output, int amount) {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  void * joutput = 0 ;
  int jamount  ;
  
  if (!swig_callbackreadAudioData) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::readAudioData");
  } else {
    joutput = (void *) output; 
    jamount = amount;
    jresult = (int) swig_callbackreadAudioData(joutput, jamount);
    c_result = (int)jresult; 
  }
  return c_result;
}

bool SwigDirector_IAudioDecoder::setPosition(int position, bool relative) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  int jposition  ;
  unsigned int jrelative  ;
  
  if (!swig_callbacksetPosition) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::setPosition");
  } else {
    jposition = position;
    jrelative = relative;
    jresult = (unsigned int) swig_callbacksetPosition(jposition, jrelative);
    c_result = jresult ? true : false; 
  }
  return c_result;
}

bool SwigDirector_IAudioDecoder::seek(float seconds, bool relative) {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  float jseconds  ;
  unsigned int jrelative  ;
  
  if (!swig_callbackseek) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::seek");
  } else {
    jseconds = seconds;
    jrelative = relative;
    jresult = (unsigned int) swig_callbackseek(jseconds, jrelative);
    c_result = jresult ? true : false; 
  }
  return c_result;
}

float SwigDirector_IAudioDecoder::getTotalTime() {
  float c_result = SwigValueInit< float >() ;
  float jresult = 0 ;
  
  if (!swig_callbackgetTotalTime) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::getTotalTime");
  } else {
    jresult = (float) swig_callbackgetTotalTime();
    c_result = (float)jresult; 
  }
  return c_result;
}

int SwigDirector_IAudioDecoder::getTotalSize() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackgetTotalSize) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::getTotalSize");
  } else {
    jresult = (int) swig_callbackgetTotalSize();
    c_result = (int)jresult; 
  }
  return c_result;
}

int SwigDirector_IAudioDecoder::getCompressedSize() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackgetCompressedSize) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::getCompressedSize");
  } else {
    jresult = (int) swig_callbackgetCompressedSize();
    c_result = (int)jresult; 
  }
  return c_result;
}

float SwigDirector_IAudioDecoder::getCurrentTime() {
  float c_result = SwigValueInit< float >() ;
  float jresult = 0 ;
  
  if (!swig_callbackgetCurrentTime) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::getCurrentTime");
  } else {
    jresult = (float) swig_callbackgetCurrentTime();
    c_result = (float)jresult; 
  }
  return c_result;
}

int SwigDirector_IAudioDecoder::getCurrentPosition() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackgetCurrentPosition) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::getCurrentPosition");
  } else {
    jresult = (int) swig_callbackgetCurrentPosition();
    c_result = (int)jresult; 
  }
  return c_result;
}

int SwigDirector_IAudioDecoder::getCurrentCompressedPosition() {
  int c_result = SwigValueInit< int >() ;
  int jresult = 0 ;
  
  if (!swig_callbackgetCurrentCompressedPosition) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::getCurrentCompressedPosition");
  } else {
    jresult = (int) swig_callbackgetCurrentCompressedPosition();
    c_result = (int)jresult; 
  }
  return c_result;
}

cAudio::cAudioString SwigDirector_IAudioDecoder::getType() const {
  cAudio::cAudioString c_result ;
  char * jresult = 0 ;
  
  if (!swig_callbackgetType) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoder::getType");
  } else {
    jresult = (char *) swig_callbackgetType();
    if (!jresult) {
      SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
      return c_result;
    }
    c_result.assign(jresult); 
  }
  return c_result;
}

void SwigDirector_IAudioDecoder::swig_connect_director(SWIG_Callback0_t callbackgrab, SWIG_Callback1_t callbackdrop, SWIG_Callback2_t callbackgetFormat, SWIG_Callback3_t callbackgetFrequency, SWIG_Callback4_t callbackisSeekingSupported, SWIG_Callback5_t callbackisValid, SWIG_Callback6_t callbackreadAudioData, SWIG_Callback7_t callbacksetPosition, SWIG_Callback8_t callbackseek, SWIG_Callback9_t callbackgetTotalTime, SWIG_Callback10_t callbackgetTotalSize, SWIG_Callback11_t callbackgetCompressedSize, SWIG_Callback12_t callbackgetCurrentTime, SWIG_Callback13_t callbackgetCurrentPosition, SWIG_Callback14_t callbackgetCurrentCompressedPosition, SWIG_Callback15_t callbackgetType) {
  swig_callbackgrab = callbackgrab;
  swig_callbackdrop = callbackdrop;
  swig_callbackgetFormat = callbackgetFormat;
  swig_callbackgetFrequency = callbackgetFrequency;
  swig_callbackisSeekingSupported = callbackisSeekingSupported;
  swig_callbackisValid = callbackisValid;
  swig_callbackreadAudioData = callbackreadAudioData;
  swig_callbacksetPosition = callbacksetPosition;
  swig_callbackseek = callbackseek;
  swig_callbackgetTotalTime = callbackgetTotalTime;
  swig_callbackgetTotalSize = callbackgetTotalSize;
  swig_callbackgetCompressedSize = callbackgetCompressedSize;
  swig_callbackgetCurrentTime = callbackgetCurrentTime;
  swig_callbackgetCurrentPosition = callbackgetCurrentPosition;
  swig_callbackgetCurrentCompressedPosition = callbackgetCurrentCompressedPosition;
  swig_callbackgetType = callbackgetType;
}

void SwigDirector_IAudioDecoder::swig_init_callbacks() {
  swig_callbackgrab = 0;
  swig_callbackdrop = 0;
  swig_callbackgetFormat = 0;
  swig_callbackgetFrequency = 0;
  swig_callbackisSeekingSupported = 0;
  swig_callbackisValid = 0;
  swig_callbackreadAudioData = 0;
  swig_callbacksetPosition = 0;
  swig_callbackseek = 0;
  swig_callbackgetTotalTime = 0;
  swig_callbackgetTotalSize = 0;
  swig_callbackgetCompressedSize = 0;
  swig_callbackgetCurrentTime = 0;
  swig_callbackgetCurrentPosition = 0;
  swig_callbackgetCurrentCompressedPosition = 0;
  swig_callbackgetType = 0;
}

SwigDirector_IAudioDecoderFactory::SwigDirector_IAudioDecoderFactory() : cAudio::IAudioDecoderFactory(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_IAudioDecoderFactory::~SwigDirector_IAudioDecoderFactory() {
  
}


cAudio::IAudioDecoder *SwigDirector_IAudioDecoderFactory::CreateAudioDecoder(cAudio::IDataSource *stream) {
  cAudio::IAudioDecoder *c_result = 0 ;
  void * jresult = 0 ;
  void * jstream = 0 ;
  
  if (!swig_callbackCreateAudioDecoder) {
    throw Swig::DirectorPureVirtualException("cAudio::IAudioDecoderFactory::CreateAudioDecoder");
  } else {
    jstream = (void *) stream; 
    jresult = (void *) swig_callbackCreateAudioDecoder(jstream);
    c_result = (cAudio::IAudioDecoder *)jresult; 
  }
  return c_result;
}

void SwigDirector_IAudioDecoderFactory::swig_connect_director(SWIG_Callback0_t callbackCreateAudioDecoder) {
  swig_callbackCreateAudioDecoder = callbackCreateAudioDecoder;
}

void SwigDirector_IAudioDecoderFactory::swig_init_callbacks() {
  swig_callbackCreateAudioDecoder = 0;
}


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT char * SWIGSTDCALL CSharp_toWINSTR(char * jarg1) {
  char * jresult ;
  char *arg1 = (char *) 0 ;
  char *result = 0 ;
  
  arg1 = (char *)jarg1; 
  result = (char *)cAudio::toWINSTR((char const *)arg1);
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_toUTF8(char * jarg1) {
  char * jresult ;
  cAudio::cAudioString *arg1 = 0 ;
  char *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  cAudio::cAudioString arg1_str(jarg1);
  arg1 = &arg1_str; 
  result = (char *)cAudio::toUTF8((std::string const &)*arg1);
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_fromUTF8(char * jarg1) {
  char * jresult ;
  char *arg1 = (char *) 0 ;
  cAudio::cAudioString result;
  
  arg1 = (char *)jarg1; 
  result = cAudio::fromUTF8((char const *)arg1);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IMemoryProvider_Allocate(void * jarg1, unsigned long jarg2, char * jarg3, int jarg4, char * jarg5) {
  void * jresult ;
  cAudio::IMemoryProvider *arg1 = (cAudio::IMemoryProvider *) 0 ;
  size_t arg2 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  char *arg5 = (char *) 0 ;
  void *result = 0 ;
  
  arg1 = (cAudio::IMemoryProvider *)jarg1; 
  arg2 = (size_t)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (int)jarg4; 
  arg5 = (char *)jarg5; 
  result = (void *)(arg1)->Allocate(arg2,(char const *)arg3,arg4,(char const *)arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IMemoryProvider_Free(void * jarg1, void * jarg2) {
  cAudio::IMemoryProvider *arg1 = (cAudio::IMemoryProvider *) 0 ;
  void *arg2 = (void *) 0 ;
  
  arg1 = (cAudio::IMemoryProvider *)jarg1; 
  arg2 = (void *)jarg2; 
  (arg1)->Free(arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_IMemoryProvider_getMaxAllocationSize(void * jarg1) {
  unsigned long jresult ;
  cAudio::IMemoryProvider *arg1 = (cAudio::IMemoryProvider *) 0 ;
  size_t result;
  
  arg1 = (cAudio::IMemoryProvider *)jarg1; 
  result = (arg1)->getMaxAllocationSize();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IMemoryProvider(void * jarg1) {
  cAudio::IMemoryProvider *arg1 = (cAudio::IMemoryProvider *) 0 ;
  
  arg1 = (cAudio::IMemoryProvider *)jarg1; 
  delete arg1;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CAUDIO_VERSION_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("2.2.0");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CAUDIO_SOURCE_BUFFER_SIZE_get() {
  int jresult ;
  int result;
  
  result = (int)((1024*64));
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CAUDIO_SOURCE_NUM_BUFFERS_get() {
  int jresult ;
  int result;
  
  result = (int)(3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_CAUDIO_SOURCE_MAX_EFFECT_SLOTS_get() {
  int jresult ;
  int result;
  
  result = (int)(4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_getMemoryProvider() {
  void * jresult ;
  cAudio::IMemoryProvider *result = 0 ;
  
  result = (cAudio::IMemoryProvider *)cAudio::getMemoryProvider();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_cAudioSleep(unsigned int jarg1) {
  unsigned int arg1 ;
  
  arg1 = (unsigned int)jarg1; 
  cAudio::cAudioSleep(arg1);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioDeviceList_getDeviceCount(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioDeviceList *arg1 = (cAudio::IAudioDeviceList *) 0 ;
  unsigned int result;
  
  arg1 = (cAudio::IAudioDeviceList *)jarg1; 
  result = (unsigned int)(arg1)->getDeviceCount();
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_IAudioDeviceList_getDeviceName(void * jarg1, unsigned int jarg2) {
  char * jresult ;
  cAudio::IAudioDeviceList *arg1 = (cAudio::IAudioDeviceList *) 0 ;
  unsigned int arg2 ;
  cAudio::cAudioString result;
  
  arg1 = (cAudio::IAudioDeviceList *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (arg1)->getDeviceName(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_IAudioDeviceList_getDeviceDescription(void * jarg1, unsigned int jarg2) {
  char * jresult ;
  cAudio::IAudioDeviceList *arg1 = (cAudio::IAudioDeviceList *) 0 ;
  unsigned int arg2 ;
  cAudio::cAudioString result;
  
  arg1 = (cAudio::IAudioDeviceList *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (arg1)->getDeviceDescription(arg2);
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_IAudioDeviceList_getDefaultDeviceName(void * jarg1) {
  char * jresult ;
  cAudio::IAudioDeviceList *arg1 = (cAudio::IAudioDeviceList *) 0 ;
  cAudio::cAudioString result;
  
  arg1 = (cAudio::IAudioDeviceList *)jarg1; 
  result = (arg1)->getDefaultDeviceName();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioDeviceList_isSupported(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioDeviceList *arg1 = (cAudio::IAudioDeviceList *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioDeviceList *)jarg1; 
  result = (bool)(arg1)->isSupported();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IAudioDeviceList(void * jarg1) {
  cAudio::IAudioDeviceList *arg1 = (cAudio::IAudioDeviceList *) 0 ;
  
  arg1 = (cAudio::IAudioDeviceList *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_IRefCounted() {
  void * jresult ;
  cAudio::IRefCounted *result = 0 ;
  
  result = (cAudio::IRefCounted *)new cAudio::IRefCounted();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IRefCounted(void * jarg1) {
  cAudio::IRefCounted *arg1 = (cAudio::IRefCounted *) 0 ;
  
  arg1 = (cAudio::IRefCounted *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IRefCounted_grab(void * jarg1) {
  cAudio::IRefCounted *arg1 = (cAudio::IRefCounted *) 0 ;
  
  arg1 = (cAudio::IRefCounted *)jarg1; 
  (arg1)->grab();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IRefCounted_drop(void * jarg1) {
  unsigned int jresult ;
  cAudio::IRefCounted *arg1 = (cAudio::IRefCounted *) 0 ;
  bool result;
  
  arg1 = (cAudio::IRefCounted *)jarg1; 
  result = (bool)(arg1)->drop();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IRefCounted_getReferenceCount(void * jarg1) {
  int jresult ;
  cAudio::IRefCounted *arg1 = (cAudio::IRefCounted *) 0 ;
  int result;
  
  arg1 = (cAudio::IRefCounted *)jarg1; 
  result = (int)((cAudio::IRefCounted const *)arg1)->getReferenceCount();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_IDataSource() {
  void * jresult ;
  cAudio::IDataSource *result = 0 ;
  
  result = (cAudio::IDataSource *)new SwigDirector_IDataSource();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IDataSource(void * jarg1) {
  cAudio::IDataSource *arg1 = (cAudio::IDataSource *) 0 ;
  
  arg1 = (cAudio::IDataSource *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IDataSource_isValid(void * jarg1) {
  unsigned int jresult ;
  cAudio::IDataSource *arg1 = (cAudio::IDataSource *) 0 ;
  bool result;
  
  arg1 = (cAudio::IDataSource *)jarg1; 
  result = (bool)(arg1)->isValid();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IDataSource_getCurrentPos(void * jarg1) {
  int jresult ;
  cAudio::IDataSource *arg1 = (cAudio::IDataSource *) 0 ;
  int result;
  
  arg1 = (cAudio::IDataSource *)jarg1; 
  result = (int)(arg1)->getCurrentPos();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IDataSource_getSize(void * jarg1) {
  int jresult ;
  cAudio::IDataSource *arg1 = (cAudio::IDataSource *) 0 ;
  int result;
  
  arg1 = (cAudio::IDataSource *)jarg1; 
  result = (int)(arg1)->getSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IDataSource_read(void * jarg1, void * jarg2, int jarg3) {
  int jresult ;
  cAudio::IDataSource *arg1 = (cAudio::IDataSource *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int result;
  
  arg1 = (cAudio::IDataSource *)jarg1; 
  arg2 = (void *)jarg2; 
  arg3 = (int)jarg3; 
  result = (int)(arg1)->read(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IDataSource_seek(void * jarg1, int jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  cAudio::IDataSource *arg1 = (cAudio::IDataSource *) 0 ;
  int arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (cAudio::IDataSource *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->seek(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IDataSource_director_connect(void *objarg, SwigDirector_IDataSource::SWIG_Callback0_t callback0, SwigDirector_IDataSource::SWIG_Callback1_t callback1, SwigDirector_IDataSource::SWIG_Callback2_t callback2, SwigDirector_IDataSource::SWIG_Callback3_t callback3, SwigDirector_IDataSource::SWIG_Callback4_t callback4, SwigDirector_IDataSource::SWIG_Callback5_t callback5, SwigDirector_IDataSource::SWIG_Callback6_t callback6) {
  cAudio::IDataSource *obj = (cAudio::IDataSource *)objarg;
  SwigDirector_IDataSource *director = dynamic_cast<SwigDirector_IDataSource *>(obj);
  if (director) {
    director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6);
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_IDataSourceFactory() {
  void * jresult ;
  cAudio::IDataSourceFactory *result = 0 ;
  
  result = (cAudio::IDataSourceFactory *)new SwigDirector_IDataSourceFactory();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IDataSourceFactory(void * jarg1) {
  cAudio::IDataSourceFactory *arg1 = (cAudio::IDataSourceFactory *) 0 ;
  
  arg1 = (cAudio::IDataSourceFactory *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IDataSourceFactory_CreateDataSource(void * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  cAudio::IDataSourceFactory *arg1 = (cAudio::IDataSourceFactory *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  cAudio::IDataSource *result = 0 ;
  
  arg1 = (cAudio::IDataSourceFactory *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = jarg3 ? true : false; 
  result = (cAudio::IDataSource *)(arg1)->CreateDataSource((char const *)arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IDataSourceFactory_director_connect(void *objarg, SwigDirector_IDataSourceFactory::SWIG_Callback0_t callback0) {
  cAudio::IDataSourceFactory *obj = (cAudio::IDataSourceFactory *)objarg;
  SwigDirector_IDataSourceFactory *director = dynamic_cast<SwigDirector_IDataSourceFactory *>(obj);
  if (director) {
    director->swig_connect_director(callback0);
  }
}


SWIGEXPORT float SWIGSTDCALL CSharp_Epsilon_get() {
  float jresult ;
  float result;
  
  result = (float)(float)cAudio::Epsilon;
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_float_equals(float jarg1, float jarg2) {
  unsigned int jresult ;
  float arg1 ;
  float arg2 ;
  bool result;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  result = (bool)cAudio::float_equals(arg1,arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_cVector3_x_set(void * jarg1, float jarg2) {
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->x = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_cVector3_x_get(void * jarg1) {
  float jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  result = (float) ((arg1)->x);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_cVector3_y_set(void * jarg1, float jarg2) {
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->y = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_cVector3_y_get(void * jarg1) {
  float jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  result = (float) ((arg1)->y);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_cVector3_z_set(void * jarg1, float jarg2) {
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->z = arg2;
}


SWIGEXPORT float SWIGSTDCALL CSharp_cVector3_z_get(void * jarg1) {
  float jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  result = (float) ((arg1)->z);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_cVector3__SWIG_0() {
  void * jresult ;
  cAudio::cVector3 *result = 0 ;
  
  result = (cAudio::cVector3 *)new cAudio::cVector3();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_cVector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
  void * jresult ;
  float arg1 ;
  float arg2 ;
  float arg3 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (float)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  result = (cAudio::cVector3 *)new cAudio::cVector3(arg1,arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_cVector3__SWIG_2(float jarg1) {
  void * jresult ;
  float arg1 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (float)jarg1; 
  result = (cAudio::cVector3 *)new cAudio::cVector3(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_cVector3__SWIG_3(void * jarg1) {
  void * jresult ;
  cAudio::cVector3 *arg1 = 0 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (cAudio::cVector3 *)new cAudio::cVector3((cAudio::cVector3 const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_cVector3__SWIG_4(void * jarg1) {
  void * jresult ;
  float *arg1 = (float *) 0 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (float *)jarg1; 
  result = (cAudio::cVector3 *)new cAudio::cVector3(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Minus__SWIG_0(void * jarg1) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  result = ((cAudio::cVector3 const *)arg1)->operator -();
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Equal(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (cAudio::cVector3 *) &(arg1)->operator =((cAudio::cVector3 const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Plus__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = ((cAudio::cVector3 const *)arg1)->operator +((cAudio::cVector3 const &)*arg2);
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_PlusEqual__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (cAudio::cVector3 *) &(arg1)->operator +=((cAudio::cVector3 const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Plus__SWIG_1(void * jarg1, float jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  result = ((cAudio::cVector3 const *)arg1)->operator +(arg2);
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_PlusEqual__SWIG_1(void * jarg1, float jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  result = (cAudio::cVector3 *) &(arg1)->operator +=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Minus__SWIG_1(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = ((cAudio::cVector3 const *)arg1)->operator -((cAudio::cVector3 const &)*arg2);
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_MinusEqual__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (cAudio::cVector3 *) &(arg1)->operator -=((cAudio::cVector3 const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Minus__SWIG_2(void * jarg1, float jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  result = ((cAudio::cVector3 const *)arg1)->operator -(arg2);
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_MinusEqual__SWIG_1(void * jarg1, float jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  result = (cAudio::cVector3 *) &(arg1)->operator -=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = ((cAudio::cVector3 const *)arg1)->operator *((cAudio::cVector3 const &)*arg2);
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_MultiplyEqual__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (cAudio::cVector3 *) &(arg1)->operator *=((cAudio::cVector3 const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  result = ((cAudio::cVector3 const *)arg1)->operator *(arg2);
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_MultiplyEqual__SWIG_1(void * jarg1, float jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  result = (cAudio::cVector3 *) &(arg1)->operator *=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = ((cAudio::cVector3 const *)arg1)->operator /((cAudio::cVector3 const &)*arg2);
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_DivideEqual__SWIG_0(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (cAudio::cVector3 *) &(arg1)->operator /=((cAudio::cVector3 const &)*arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_Divide__SWIG_1(void * jarg1, float jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  result = ((cAudio::cVector3 const *)arg1)->operator /(arg2);
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_DivideEqual__SWIG_1(void * jarg1, float jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  cAudio::cVector3 *result = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  result = (cAudio::cVector3 *) &(arg1)->operator /=(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_cVector3_LessThanEqual(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  bool result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (bool)((cAudio::cVector3 const *)arg1)->operator <=((cAudio::cVector3 const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_cVector3_GreaterThanEqual(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  bool result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (bool)((cAudio::cVector3 const *)arg1)->operator >=((cAudio::cVector3 const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_cVector3_LessThan(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  bool result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (bool)((cAudio::cVector3 const *)arg1)->operator <((cAudio::cVector3 const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_cVector3_GreaterThan(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  bool result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (bool)((cAudio::cVector3 const *)arg1)->operator >((cAudio::cVector3 const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_cVector3_EqualEqual(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  bool result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (bool)((cAudio::cVector3 const *)arg1)->operator ==((cAudio::cVector3 const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_cVector3_NotEqual(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  bool result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (bool)((cAudio::cVector3 const *)arg1)->operator !=((cAudio::cVector3 const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_cVector3_length(void * jarg1) {
  float jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  result = (float)((cAudio::cVector3 const *)arg1)->length();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_cVector3_normalize(void * jarg1) {
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  (arg1)->normalize();
}


SWIGEXPORT float SWIGSTDCALL CSharp_cVector3_dot(void * jarg1, void * jarg2) {
  float jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  float result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (float)((cAudio::cVector3 const *)arg1)->dot((cAudio::cVector3 const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_cVector3_cross(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = ((cAudio::cVector3 const *)arg1)->cross((cAudio::cVector3 const &)*arg2);
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_cVector3_set__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = (float)jarg3; 
  arg4 = (float)jarg4; 
  (arg1)->set(arg2,arg3,arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_cVector3_set__SWIG_1(void * jarg1, float jarg2) {
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float arg2 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float)jarg2; 
  (arg1)->set(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_cVector3_set__SWIG_2(void * jarg1, void * jarg2) {
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->set((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_cVector3_getAsArray(void * jarg1, void * jarg2) {
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  float *arg2 = (float *) 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  arg2 = (float *)jarg2; 
  (arg1)->getAsArray(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_cVector3(void * jarg1) {
  cAudio::cVector3 *arg1 = (cAudio::cVector3 *) 0 ;
  
  arg1 = (cAudio::cVector3 *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IListener(void * jarg1) {
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  
  arg1 = (cAudio::IListener *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IListener_setPosition(void * jarg1, void * jarg2) {
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IListener *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->setPosition((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IListener_setDirection(void * jarg1, void * jarg2) {
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IListener *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->setDirection((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IListener_setUpVector(void * jarg1, void * jarg2) {
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IListener *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->setUpVector((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IListener_setVelocity(void * jarg1, void * jarg2) {
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IListener *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->setVelocity((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IListener_setMasterVolume(void * jarg1, float jarg2) {
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IListener *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setMasterVolume((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IListener_move(void * jarg1, void * jarg2) {
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IListener *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->move((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IListener_getPosition(void * jarg1) {
  void * jresult ;
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::IListener *)jarg1; 
  result = ((cAudio::IListener const *)arg1)->getPosition();
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IListener_getDirection(void * jarg1) {
  void * jresult ;
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::IListener *)jarg1; 
  result = ((cAudio::IListener const *)arg1)->getDirection();
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IListener_getUpVector(void * jarg1) {
  void * jresult ;
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::IListener *)jarg1; 
  result = ((cAudio::IListener const *)arg1)->getUpVector();
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IListener_getVelocity(void * jarg1) {
  void * jresult ;
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::IListener *)jarg1; 
  result = ((cAudio::IListener const *)arg1)->getVelocity();
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IListener_getMasterVolume(void * jarg1) {
  float jresult ;
  cAudio::IListener *arg1 = (cAudio::IListener *) 0 ;
  float result;
  
  arg1 = (cAudio::IListener *)jarg1; 
  result = (float)((cAudio::IListener const *)arg1)->getMasterVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_LogLevelStrings_get() {
  void * jresult ;
  char **result = 0 ;
  
  result = (char **)(char **)cAudio::LogLevelStrings;
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ILogReceiver() {
  void * jresult ;
  cAudio::ILogReceiver *result = 0 ;
  
  result = (cAudio::ILogReceiver *)new SwigDirector_ILogReceiver();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ILogReceiver(void * jarg1) {
  cAudio::ILogReceiver *arg1 = (cAudio::ILogReceiver *) 0 ;
  
  arg1 = (cAudio::ILogReceiver *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ILogReceiver_OnLogMessage(void * jarg1, char * jarg2, char * jarg3, int jarg4, float jarg5) {
  unsigned int jresult ;
  cAudio::ILogReceiver *arg1 = (cAudio::ILogReceiver *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  cAudio::LogLevel arg4 ;
  float arg5 ;
  bool result;
  
  arg1 = (cAudio::ILogReceiver *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (cAudio::LogLevel)jarg4; 
  arg5 = (float)jarg5; 
  result = (bool)(arg1)->OnLogMessage((char const *)arg2,(char const *)arg3,arg4,arg5);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ILogReceiver_director_connect(void *objarg, SwigDirector_ILogReceiver::SWIG_Callback0_t callback0) {
  cAudio::ILogReceiver *obj = (cAudio::ILogReceiver *)objarg;
  SwigDirector_ILogReceiver *director = dynamic_cast<SwigDirector_ILogReceiver *>(obj);
  if (director) {
    director->swig_connect_director(callback0);
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ILogger(void * jarg1) {
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ILogger_logCritical(void * jarg1, char * jarg2, char * jarg3) {
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  (arg1)->logCritical((char const *)arg2,(char const *)arg3,arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ILogger_logError(void * jarg1, char * jarg2, char * jarg3) {
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  (arg1)->logError((char const *)arg2,(char const *)arg3,arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ILogger_logWarning(void * jarg1, char * jarg2, char * jarg3) {
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  (arg1)->logWarning((char const *)arg2,(char const *)arg3,arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ILogger_logInfo(void * jarg1, char * jarg2, char * jarg3) {
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  (arg1)->logInfo((char const *)arg2,(char const *)arg3,arg4);
}


SWIGEXPORT void SWIGSTDCALL CSharp_ILogger_logDebug(void * jarg1, char * jarg2, char * jarg3) {
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  void *arg4 = 0 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  (arg1)->logDebug((char const *)arg2,(char const *)arg3,arg4);
}


SWIGEXPORT int SWIGSTDCALL CSharp_ILogger_getLogLevel(void * jarg1) {
  int jresult ;
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  cAudio::LogLevel *result = 0 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  result = (cAudio::LogLevel *) &((cAudio::ILogger const *)arg1)->getLogLevel();
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ILogger_setLogLevel(void * jarg1, int jarg2) {
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  cAudio::LogLevel *arg2 = 0 ;
  cAudio::LogLevel temp2 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  temp2 = (cAudio::LogLevel)jarg2; 
  arg2 = &temp2; 
  (arg1)->setLogLevel((cAudio::LogLevel const &)*arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ILogger_registerLogReceiver(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ;
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  cAudio::ILogReceiver *arg2 = (cAudio::ILogReceiver *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  arg2 = (cAudio::ILogReceiver *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->registerLogReceiver(arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ILogger_unRegisterLogReceiver(void * jarg1, char * jarg2) {
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  arg2 = (char *)jarg2; 
  (arg1)->unRegisterLogReceiver((char const *)arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ILogger_isLogReceiverRegistered(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->isLogReceiverRegistered((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_ILogger_getLogReceiver(void * jarg1, char * jarg2) {
  void * jresult ;
  cAudio::ILogger *arg1 = (cAudio::ILogger *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::ILogReceiver *result = 0 ;
  
  arg1 = (cAudio::ILogger *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (cAudio::ILogReceiver *)(arg1)->getLogReceiver((char const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IManagerEventHandler_onInit(void * jarg1) {
  cAudio::IManagerEventHandler *arg1 = (cAudio::IManagerEventHandler *) 0 ;
  
  arg1 = (cAudio::IManagerEventHandler *)jarg1; 
  (arg1)->onInit();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IManagerEventHandler_onUpdate(void * jarg1) {
  cAudio::IManagerEventHandler *arg1 = (cAudio::IManagerEventHandler *) 0 ;
  
  arg1 = (cAudio::IManagerEventHandler *)jarg1; 
  (arg1)->onUpdate();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IManagerEventHandler_onRelease(void * jarg1) {
  cAudio::IManagerEventHandler *arg1 = (cAudio::IManagerEventHandler *) 0 ;
  
  arg1 = (cAudio::IManagerEventHandler *)jarg1; 
  (arg1)->onRelease();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IManagerEventHandler_onSourceCreate(void * jarg1) {
  cAudio::IManagerEventHandler *arg1 = (cAudio::IManagerEventHandler *) 0 ;
  
  arg1 = (cAudio::IManagerEventHandler *)jarg1; 
  (arg1)->onSourceCreate();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IManagerEventHandler_onDecoderRegister(void * jarg1) {
  cAudio::IManagerEventHandler *arg1 = (cAudio::IManagerEventHandler *) 0 ;
  
  arg1 = (cAudio::IManagerEventHandler *)jarg1; 
  (arg1)->onDecoderRegister();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IManagerEventHandler_onDataSourceRegister(void * jarg1) {
  cAudio::IManagerEventHandler *arg1 = (cAudio::IManagerEventHandler *) 0 ;
  
  arg1 = (cAudio::IManagerEventHandler *)jarg1; 
  (arg1)->onDataSourceRegister();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_IManagerEventHandler() {
  void * jresult ;
  cAudio::IManagerEventHandler *result = 0 ;
  
  result = (cAudio::IManagerEventHandler *)new SwigDirector_IManagerEventHandler();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IManagerEventHandler(void * jarg1) {
  cAudio::IManagerEventHandler *arg1 = (cAudio::IManagerEventHandler *) 0 ;
  
  arg1 = (cAudio::IManagerEventHandler *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IManagerEventHandler_director_connect(void *objarg, SwigDirector_IManagerEventHandler::SWIG_Callback0_t callback0, SwigDirector_IManagerEventHandler::SWIG_Callback1_t callback1, SwigDirector_IManagerEventHandler::SWIG_Callback2_t callback2, SwigDirector_IManagerEventHandler::SWIG_Callback3_t callback3, SwigDirector_IManagerEventHandler::SWIG_Callback4_t callback4, SwigDirector_IManagerEventHandler::SWIG_Callback5_t callback5) {
  cAudio::IManagerEventHandler *obj = (cAudio::IManagerEventHandler *)objarg;
  SwigDirector_IManagerEventHandler *director = dynamic_cast<SwigDirector_IManagerEventHandler *>(obj);
  if (director) {
    director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5);
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ISourceEventHandler_onUpdate(void * jarg1) {
  cAudio::ISourceEventHandler *arg1 = (cAudio::ISourceEventHandler *) 0 ;
  
  arg1 = (cAudio::ISourceEventHandler *)jarg1; 
  (arg1)->onUpdate();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ISourceEventHandler_onRelease(void * jarg1) {
  cAudio::ISourceEventHandler *arg1 = (cAudio::ISourceEventHandler *) 0 ;
  
  arg1 = (cAudio::ISourceEventHandler *)jarg1; 
  (arg1)->onRelease();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ISourceEventHandler_onPlay(void * jarg1) {
  cAudio::ISourceEventHandler *arg1 = (cAudio::ISourceEventHandler *) 0 ;
  
  arg1 = (cAudio::ISourceEventHandler *)jarg1; 
  (arg1)->onPlay();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ISourceEventHandler_onStop(void * jarg1) {
  cAudio::ISourceEventHandler *arg1 = (cAudio::ISourceEventHandler *) 0 ;
  
  arg1 = (cAudio::ISourceEventHandler *)jarg1; 
  (arg1)->onStop();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ISourceEventHandler_onPause(void * jarg1) {
  cAudio::ISourceEventHandler *arg1 = (cAudio::ISourceEventHandler *) 0 ;
  
  arg1 = (cAudio::ISourceEventHandler *)jarg1; 
  (arg1)->onPause();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ISourceEventHandler() {
  void * jresult ;
  cAudio::ISourceEventHandler *result = 0 ;
  
  result = (cAudio::ISourceEventHandler *)new SwigDirector_ISourceEventHandler();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ISourceEventHandler(void * jarg1) {
  cAudio::ISourceEventHandler *arg1 = (cAudio::ISourceEventHandler *) 0 ;
  
  arg1 = (cAudio::ISourceEventHandler *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ISourceEventHandler_director_connect(void *objarg, SwigDirector_ISourceEventHandler::SWIG_Callback0_t callback0, SwigDirector_ISourceEventHandler::SWIG_Callback1_t callback1, SwigDirector_ISourceEventHandler::SWIG_Callback2_t callback2, SwigDirector_ISourceEventHandler::SWIG_Callback3_t callback3, SwigDirector_ISourceEventHandler::SWIG_Callback4_t callback4) {
  cAudio::ISourceEventHandler *obj = (cAudio::ISourceEventHandler *)objarg;
  SwigDirector_ISourceEventHandler *director = dynamic_cast<SwigDirector_ISourceEventHandler *>(obj);
  if (director) {
    director->swig_connect_director(callback0, callback1, callback2, callback3, callback4);
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ICaptureEventHandler_onInit(void * jarg1) {
  cAudio::ICaptureEventHandler *arg1 = (cAudio::ICaptureEventHandler *) 0 ;
  
  arg1 = (cAudio::ICaptureEventHandler *)jarg1; 
  (arg1)->onInit();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ICaptureEventHandler_onUpdate(void * jarg1) {
  cAudio::ICaptureEventHandler *arg1 = (cAudio::ICaptureEventHandler *) 0 ;
  
  arg1 = (cAudio::ICaptureEventHandler *)jarg1; 
  (arg1)->onUpdate();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ICaptureEventHandler_onRelease(void * jarg1) {
  cAudio::ICaptureEventHandler *arg1 = (cAudio::ICaptureEventHandler *) 0 ;
  
  arg1 = (cAudio::ICaptureEventHandler *)jarg1; 
  (arg1)->onRelease();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ICaptureEventHandler_onBeginCapture(void * jarg1) {
  cAudio::ICaptureEventHandler *arg1 = (cAudio::ICaptureEventHandler *) 0 ;
  
  arg1 = (cAudio::ICaptureEventHandler *)jarg1; 
  (arg1)->onBeginCapture();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ICaptureEventHandler_onEndCapture(void * jarg1) {
  cAudio::ICaptureEventHandler *arg1 = (cAudio::ICaptureEventHandler *) 0 ;
  
  arg1 = (cAudio::ICaptureEventHandler *)jarg1; 
  (arg1)->onEndCapture();
}


SWIGEXPORT void SWIGSTDCALL CSharp_ICaptureEventHandler_onUserRequestBuffer(void * jarg1) {
  cAudio::ICaptureEventHandler *arg1 = (cAudio::ICaptureEventHandler *) 0 ;
  
  arg1 = (cAudio::ICaptureEventHandler *)jarg1; 
  (arg1)->onUserRequestBuffer();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ICaptureEventHandler() {
  void * jresult ;
  cAudio::ICaptureEventHandler *result = 0 ;
  
  result = (cAudio::ICaptureEventHandler *)new SwigDirector_ICaptureEventHandler();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ICaptureEventHandler(void * jarg1) {
  cAudio::ICaptureEventHandler *arg1 = (cAudio::ICaptureEventHandler *) 0 ;
  
  arg1 = (cAudio::ICaptureEventHandler *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ICaptureEventHandler_director_connect(void *objarg, SwigDirector_ICaptureEventHandler::SWIG_Callback0_t callback0, SwigDirector_ICaptureEventHandler::SWIG_Callback1_t callback1, SwigDirector_ICaptureEventHandler::SWIG_Callback2_t callback2, SwigDirector_ICaptureEventHandler::SWIG_Callback3_t callback3, SwigDirector_ICaptureEventHandler::SWIG_Callback4_t callback4, SwigDirector_ICaptureEventHandler::SWIG_Callback5_t callback5) {
  cAudio::ICaptureEventHandler *obj = (cAudio::ICaptureEventHandler *)objarg;
  SwigDirector_ICaptureEventHandler *director = dynamic_cast<SwigDirector_ICaptureEventHandler *>(obj);
  if (director) {
    director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5);
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IAudioCapture(void * jarg1) {
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_initialize__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  cAudio::AudioFormats arg4 ;
  unsigned int arg5 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (unsigned int)jarg3; 
  arg4 = (cAudio::AudioFormats)jarg4; 
  arg5 = (unsigned int)jarg5; 
  result = (bool)(arg1)->initialize((char const *)arg2,arg3,arg4,arg5);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_initialize__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3, int jarg4) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  cAudio::AudioFormats arg4 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (unsigned int)jarg3; 
  arg4 = (cAudio::AudioFormats)jarg4; 
  result = (bool)(arg1)->initialize((char const *)arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_initialize__SWIG_2(void * jarg1, char * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  char *arg2 = (char *) 0 ;
  unsigned int arg3 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (unsigned int)jarg3; 
  result = (bool)(arg1)->initialize((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_initialize__SWIG_3(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->initialize((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_initialize__SWIG_4(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (bool)(arg1)->initialize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_isReady(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (bool)(arg1)->isReady();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioCapture_updateCaptureBuffer__SWIG_0(void * jarg1, unsigned int jarg2) {
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  bool arg2 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = jarg2 ? true : false; 
  (arg1)->updateCaptureBuffer(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioCapture_updateCaptureBuffer__SWIG_1(void * jarg1) {
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  (arg1)->updateCaptureBuffer();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioCapture_shutdown(void * jarg1) {
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  (arg1)->shutdown();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_isUpdateThreadRunning(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (bool)(arg1)->isUpdateThreadRunning();
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_IAudioCapture_getDeviceName(void * jarg1) {
  char * jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  char *result = 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (char *)(arg1)->getDeviceName();
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_getFrequency(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  unsigned int result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (unsigned int)(arg1)->getFrequency();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioCapture_getFormat(void * jarg1) {
  int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  cAudio::AudioFormats result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (cAudio::AudioFormats)(arg1)->getFormat();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_getInternalBufferSize(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  unsigned int result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (unsigned int)(arg1)->getInternalBufferSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_getSampleSize(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  unsigned int result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (unsigned int)(arg1)->getSampleSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_setDevice(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->setDevice((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_setFrequency(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  unsigned int arg2 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (bool)(arg1)->setFrequency(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_setFormat(void * jarg1, int jarg2) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  cAudio::AudioFormats arg2 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (cAudio::AudioFormats)jarg2; 
  result = (bool)(arg1)->setFormat(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_setInternalBufferSize(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  unsigned int arg2 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (unsigned int)jarg2; 
  result = (bool)(arg1)->setInternalBufferSize(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_beginCapture(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (bool)(arg1)->beginCapture();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioCapture_stopCapture(void * jarg1) {
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  (arg1)->stopCapture();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_getCapturedAudio(void * jarg1, void * jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  void *arg2 = (void *) 0 ;
  unsigned int arg3 ;
  unsigned int result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (void *)jarg2; 
  arg3 = (unsigned int)jarg3; 
  result = (unsigned int)(arg1)->getCapturedAudio(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioCapture_getCapturedAudioBuffer(void * jarg1) {
  void * jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  cAudio::AudioCaptureBuffer *result = 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (cAudio::AudioCaptureBuffer *)(arg1)->getCapturedAudioBuffer();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioCapture_getCurrentCapturedAudioSize(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  unsigned int result;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  result = (unsigned int)(arg1)->getCurrentCapturedAudioSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioCapture_registerEventHandler(void * jarg1, void * jarg2) {
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  cAudio::ICaptureEventHandler *arg2 = (cAudio::ICaptureEventHandler *) 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (cAudio::ICaptureEventHandler *)jarg2; 
  (arg1)->registerEventHandler(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioCapture_unRegisterEventHandler(void * jarg1, void * jarg2) {
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  cAudio::ICaptureEventHandler *arg2 = (cAudio::ICaptureEventHandler *) 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  arg2 = (cAudio::ICaptureEventHandler *)jarg2; 
  (arg1)->unRegisterEventHandler(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioCapture_unRegisterAllEventHandlers(void * jarg1) {
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  (arg1)->unRegisterAllEventHandlers();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AudioCaptureBuffer__SWIG_0(unsigned long jarg1) {
  void * jresult ;
  size_t arg1 ;
  cAudio::AudioCaptureBuffer *result = 0 ;
  
  arg1 = (size_t)jarg1; 
  result = (cAudio::AudioCaptureBuffer *)new cAudio::AudioCaptureBuffer(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_AudioCaptureBuffer__SWIG_1(void * jarg1) {
  void * jresult ;
  cAudio::AudioCaptureBuffer *arg1 = 0 ;
  cAudio::AudioCaptureBuffer *result = 0 ;
  
  arg1 = (cAudio::AudioCaptureBuffer *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::AudioCaptureBuffer const & type is null", 0);
    return 0;
  } 
  result = (cAudio::AudioCaptureBuffer *)new cAudio::AudioCaptureBuffer((cAudio::AudioCaptureBuffer const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_AudioCaptureBuffer(void * jarg1) {
  cAudio::AudioCaptureBuffer *arg1 = (cAudio::AudioCaptureBuffer *) 0 ;
  
  arg1 = (cAudio::AudioCaptureBuffer *)jarg1; 
  delete arg1;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AudioCaptureBuffer_getReadBuffer(void * jarg1) {
  char * jresult ;
  cAudio::AudioCaptureBuffer *arg1 = (cAudio::AudioCaptureBuffer *) 0 ;
  char *result = 0 ;
  
  arg1 = (cAudio::AudioCaptureBuffer *)jarg1; 
  result = (char *)((cAudio::AudioCaptureBuffer const *)arg1)->getReadBuffer();
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_AudioCaptureBuffer_getWriteBuffer(void * jarg1) {
  char * jresult ;
  cAudio::AudioCaptureBuffer *arg1 = (cAudio::AudioCaptureBuffer *) 0 ;
  char *result = 0 ;
  
  arg1 = (cAudio::AudioCaptureBuffer *)jarg1; 
  result = (char *)(arg1)->getWriteBuffer();
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_AudioCaptureBuffer_getLength(void * jarg1) {
  unsigned long jresult ;
  cAudio::AudioCaptureBuffer *arg1 = (cAudio::AudioCaptureBuffer *) 0 ;
  size_t result;
  
  arg1 = (cAudio::AudioCaptureBuffer *)jarg1; 
  result = ((cAudio::AudioCaptureBuffer const *)arg1)->getLength();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_IAudioDecoder(void * jarg1) {
  void * jresult ;
  cAudio::IDataSource *arg1 = (cAudio::IDataSource *) 0 ;
  cAudio::IAudioDecoder *result = 0 ;
  
  arg1 = (cAudio::IDataSource *)jarg1; 
  result = (cAudio::IAudioDecoder *)new SwigDirector_IAudioDecoder(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IAudioDecoder(void * jarg1) {
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  delete arg1;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioDecoder_getFormat(void * jarg1) {
  int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  cAudio::AudioFormats result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (cAudio::AudioFormats)(arg1)->getFormat();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioDecoder_getFrequency(void * jarg1) {
  int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  int result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (int)(arg1)->getFrequency();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioDecoder_isSeekingSupported(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (bool)(arg1)->isSeekingSupported();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioDecoder_isValid(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (bool)(arg1)->isValid();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioDecoder_readAudioData(void * jarg1, void * jarg2, int jarg3) {
  int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  void *arg2 = (void *) 0 ;
  int arg3 ;
  int result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  arg2 = (void *)jarg2; 
  arg3 = (int)jarg3; 
  result = (int)(arg1)->readAudioData(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioDecoder_setPosition(void * jarg1, int jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  int arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->setPosition(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioDecoder_seek(void * jarg1, float jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  float arg2 ;
  bool arg3 ;
  bool result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  arg2 = (float)jarg2; 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->seek(arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioDecoder_getTotalTime(void * jarg1) {
  float jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (float)(arg1)->getTotalTime();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioDecoder_getTotalSize(void * jarg1) {
  int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  int result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (int)(arg1)->getTotalSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioDecoder_getCompressedSize(void * jarg1) {
  int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  int result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (int)(arg1)->getCompressedSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioDecoder_getCurrentTime(void * jarg1) {
  float jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (float)(arg1)->getCurrentTime();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioDecoder_getCurrentPosition(void * jarg1) {
  int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  int result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (int)(arg1)->getCurrentPosition();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioDecoder_getCurrentCompressedPosition(void * jarg1) {
  int jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  int result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = (int)(arg1)->getCurrentCompressedPosition();
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_IAudioDecoder_getType(void * jarg1) {
  char * jresult ;
  cAudio::IAudioDecoder *arg1 = (cAudio::IAudioDecoder *) 0 ;
  cAudio::cAudioString result;
  
  arg1 = (cAudio::IAudioDecoder *)jarg1; 
  result = ((cAudio::IAudioDecoder const *)arg1)->getType();
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioDecoder_director_connect(void *objarg, SwigDirector_IAudioDecoder::SWIG_Callback0_t callback0, SwigDirector_IAudioDecoder::SWIG_Callback1_t callback1, SwigDirector_IAudioDecoder::SWIG_Callback2_t callback2, SwigDirector_IAudioDecoder::SWIG_Callback3_t callback3, SwigDirector_IAudioDecoder::SWIG_Callback4_t callback4, SwigDirector_IAudioDecoder::SWIG_Callback5_t callback5, SwigDirector_IAudioDecoder::SWIG_Callback6_t callback6, SwigDirector_IAudioDecoder::SWIG_Callback7_t callback7, SwigDirector_IAudioDecoder::SWIG_Callback8_t callback8, SwigDirector_IAudioDecoder::SWIG_Callback9_t callback9, SwigDirector_IAudioDecoder::SWIG_Callback10_t callback10, SwigDirector_IAudioDecoder::SWIG_Callback11_t callback11, SwigDirector_IAudioDecoder::SWIG_Callback12_t callback12, SwigDirector_IAudioDecoder::SWIG_Callback13_t callback13, SwigDirector_IAudioDecoder::SWIG_Callback14_t callback14, SwigDirector_IAudioDecoder::SWIG_Callback15_t callback15) {
  cAudio::IAudioDecoder *obj = (cAudio::IAudioDecoder *)objarg;
  SwigDirector_IAudioDecoder *director = dynamic_cast<SwigDirector_IAudioDecoder *>(obj);
  if (director) {
    director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15);
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_IAudioDecoderFactory() {
  void * jresult ;
  cAudio::IAudioDecoderFactory *result = 0 ;
  
  result = (cAudio::IAudioDecoderFactory *)new SwigDirector_IAudioDecoderFactory();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IAudioDecoderFactory(void * jarg1) {
  cAudio::IAudioDecoderFactory *arg1 = (cAudio::IAudioDecoderFactory *) 0 ;
  
  arg1 = (cAudio::IAudioDecoderFactory *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioDecoderFactory_CreateAudioDecoder(void * jarg1, void * jarg2) {
  void * jresult ;
  cAudio::IAudioDecoderFactory *arg1 = (cAudio::IAudioDecoderFactory *) 0 ;
  cAudio::IDataSource *arg2 = (cAudio::IDataSource *) 0 ;
  cAudio::IAudioDecoder *result = 0 ;
  
  arg1 = (cAudio::IAudioDecoderFactory *)jarg1; 
  arg2 = (cAudio::IDataSource *)jarg2; 
  result = (cAudio::IAudioDecoder *)(arg1)->CreateAudioDecoder(arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioDecoderFactory_director_connect(void *objarg, SwigDirector_IAudioDecoderFactory::SWIG_Callback0_t callback0) {
  cAudio::IAudioDecoderFactory *obj = (cAudio::IAudioDecoderFactory *)objarg;
  SwigDirector_IAudioDecoderFactory *director = dynamic_cast<SwigDirector_IAudioDecoderFactory *>(obj);
  if (director) {
    director->swig_connect_director(callback0);
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IAudioManager(void * jarg1) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_initialize__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
  unsigned int jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  bool result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = (int)jarg4; 
  result = (bool)(arg1)->initialize((char const *)arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_initialize__SWIG_1(void * jarg1, char * jarg2, int jarg3) {
  unsigned int jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  bool result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  result = (bool)(arg1)->initialize((char const *)arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_initialize__SWIG_2(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->initialize((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_initialize__SWIG_3(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  result = (bool)(arg1)->initialize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_shutDown(void * jarg1) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  (arg1)->shutDown();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_update(void * jarg1) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  (arg1)->update();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_isUpdateThreadRunning(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  result = (bool)(arg1)->isUpdateThreadRunning();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_getSoundByName(void * jarg1, char * jarg2) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (cAudio::IAudioSource *)(arg1)->getSoundByName((char const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_releaseAllSources(void * jarg1) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  (arg1)->releaseAllSources();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_release(void * jarg1, void * jarg2) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  cAudio::IAudioSource *arg2 = (cAudio::IAudioSource *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (cAudio::IAudioSource *)jarg2; 
  (arg1)->release(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_play2D__SWIG_0(void * jarg1, char * jarg2, unsigned int jarg3, unsigned int jarg4) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  bool arg4 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = jarg3 ? true : false; 
  arg4 = jarg4 ? true : false; 
  result = (cAudio::IAudioSource *)(arg1)->play2D((char const *)arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_play2D__SWIG_1(void * jarg1, char * jarg2, unsigned int jarg3) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  bool arg3 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = jarg3 ? true : false; 
  result = (cAudio::IAudioSource *)(arg1)->play2D((char const *)arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_play2D__SWIG_2(void * jarg1, char * jarg2) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (cAudio::IAudioSource *)(arg1)->play2D((char const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_play3D__SWIG_0(void * jarg1, char * jarg2, void * jarg3, unsigned int jarg4, unsigned int jarg5) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::cVector3 arg3 ;
  bool arg4 ;
  bool arg5 ;
  cAudio::cVector3 *argp3 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  argp3 = (cAudio::cVector3 *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null cAudio::cVector3", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = jarg4 ? true : false; 
  arg5 = jarg5 ? true : false; 
  result = (cAudio::IAudioSource *)(arg1)->play3D((char const *)arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_play3D__SWIG_1(void * jarg1, char * jarg2, void * jarg3, unsigned int jarg4) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::cVector3 arg3 ;
  bool arg4 ;
  cAudio::cVector3 *argp3 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  argp3 = (cAudio::cVector3 *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null cAudio::cVector3", 0);
    return 0;
  }
  arg3 = *argp3; 
  arg4 = jarg4 ? true : false; 
  result = (cAudio::IAudioSource *)(arg1)->play3D((char const *)arg2,arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_play3D__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::cVector3 arg3 ;
  cAudio::cVector3 *argp3 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  argp3 = (cAudio::cVector3 *)jarg3; 
  if (!argp3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null cAudio::cVector3", 0);
    return 0;
  }
  arg3 = *argp3; 
  result = (cAudio::IAudioSource *)(arg1)->play3D((char const *)arg2,arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_setMasterVolume(void * jarg1, float jarg2) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  float arg2 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (float)jarg2; 
  (arg1)->setMasterVolume(arg2);
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioManager_getMasterVolume(void * jarg1) {
  float jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  result = (float)((cAudio::IAudioManager const *)arg1)->getMasterVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_stopAllSounds(void * jarg1) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  (arg1)->stopAllSounds();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_create__SWIG_0(void * jarg1, char * jarg2, char * jarg3, unsigned int jarg4) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool arg4 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = jarg4 ? true : false; 
  result = (cAudio::IAudioSource *)(arg1)->create((char const *)arg2,(char const *)arg3,arg4);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_create__SWIG_1(void * jarg1, char * jarg2, char * jarg3) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (cAudio::IAudioSource *)(arg1)->create((char const *)arg2,(char const *)arg3);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_createFromMemory(void * jarg1, char * jarg2, char * jarg3, unsigned long jarg4, char * jarg5) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  size_t arg4 ;
  char *arg5 = (char *) 0 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (size_t)jarg4; 
  arg5 = (char *)jarg5; 
  result = (cAudio::IAudioSource *)(arg1)->createFromMemory((char const *)arg2,(char const *)arg3,arg4,(char const *)arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_createFromRaw(void * jarg1, char * jarg2, char * jarg3, unsigned long jarg4, unsigned int jarg5, int jarg6) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  size_t arg4 ;
  unsigned int arg5 ;
  cAudio::AudioFormats arg6 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (size_t)jarg4; 
  arg5 = (unsigned int)jarg5; 
  arg6 = (cAudio::AudioFormats)jarg6; 
  result = (cAudio::IAudioSource *)(arg1)->createFromRaw((char const *)arg2,(char const *)arg3,arg4,arg5,arg6);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_createFromAudioBuffer(void * jarg1, char * jarg2, void * jarg3, unsigned int jarg4, int jarg5) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::AudioCaptureBuffer *arg3 = (cAudio::AudioCaptureBuffer *) 0 ;
  unsigned int arg4 ;
  cAudio::AudioFormats arg5 ;
  cAudio::IAudioSource *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (cAudio::AudioCaptureBuffer *)jarg3; 
  arg4 = (unsigned int)jarg4; 
  arg5 = (cAudio::AudioFormats)jarg5; 
  result = (cAudio::IAudioSource *)(arg1)->createFromAudioBuffer((char const *)arg2,arg3,arg4,arg5);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_registerAudioDecoder(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  cAudio::IAudioDecoderFactory *arg2 = (cAudio::IAudioDecoderFactory *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (cAudio::IAudioDecoderFactory *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->registerAudioDecoder(arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_unRegisterAudioDecoder(void * jarg1, char * jarg2) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  (arg1)->unRegisterAudioDecoder((char const *)arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_isAudioDecoderRegistered(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->isAudioDecoderRegistered((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_getAudioDecoderFactory(void * jarg1, char * jarg2) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::IAudioDecoderFactory *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (cAudio::IAudioDecoderFactory *)(arg1)->getAudioDecoderFactory((char const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_unRegisterAllAudioDecoders(void * jarg1) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  (arg1)->unRegisterAllAudioDecoders();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_registerDataSource(void * jarg1, void * jarg2, char * jarg3, int jarg4) {
  unsigned int jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  cAudio::IDataSourceFactory *arg2 = (cAudio::IDataSourceFactory *) 0 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  bool result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (cAudio::IDataSourceFactory *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (int)jarg4; 
  result = (bool)(arg1)->registerDataSource(arg2,(char const *)arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_unRegisterDataSource(void * jarg1, char * jarg2) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  (arg1)->unRegisterDataSource((char const *)arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioManager_isDataSourceRegistered(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->isDataSourceRegistered((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_getDataSourceFactory(void * jarg1, char * jarg2) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::IDataSourceFactory *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (cAudio::IDataSourceFactory *)(arg1)->getDataSourceFactory((char const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_unRegisterAllDataSources(void * jarg1) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  (arg1)->unRegisterAllDataSources();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_registerEventHandler(void * jarg1, void * jarg2) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  cAudio::IManagerEventHandler *arg2 = (cAudio::IManagerEventHandler *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (cAudio::IManagerEventHandler *)jarg2; 
  (arg1)->registerEventHandler(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_unRegisterEventHandler(void * jarg1, void * jarg2) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  cAudio::IManagerEventHandler *arg2 = (cAudio::IManagerEventHandler *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  arg2 = (cAudio::IManagerEventHandler *)jarg2; 
  (arg1)->unRegisterEventHandler(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioManager_unRegisterAllEventHandlers(void * jarg1) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  (arg1)->unRegisterAllEventHandlers();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioManager_getListener(void * jarg1) {
  void * jresult ;
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  cAudio::IListener *result = 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  result = (cAudio::IListener *)(arg1)->getListener();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioDeviceContext_initialize(void * jarg1, char * jarg2, int jarg3, int jarg4) {
  unsigned int jresult ;
  cAudio::IAudioDeviceContext *arg1 = (cAudio::IAudioDeviceContext *) 0 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  int arg4 ;
  bool result;
  
  arg1 = (cAudio::IAudioDeviceContext *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = (int)jarg4; 
  result = (bool)(arg1)->initialize((char const *)arg2,arg3,arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioDeviceContext_shutDown(void * jarg1) {
  cAudio::IAudioDeviceContext *arg1 = (cAudio::IAudioDeviceContext *) 0 ;
  
  arg1 = (cAudio::IAudioDeviceContext *)jarg1; 
  (arg1)->shutDown();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioDeviceContext_update(void * jarg1) {
  cAudio::IAudioDeviceContext *arg1 = (cAudio::IAudioDeviceContext *) 0 ;
  
  arg1 = (cAudio::IAudioDeviceContext *)jarg1; 
  (arg1)->update();
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioDeviceContext_getAudioManager(void * jarg1) {
  void * jresult ;
  cAudio::IAudioDeviceContext *arg1 = (cAudio::IAudioDeviceContext *) 0 ;
  cAudio::IAudioManager *result = 0 ;
  
  arg1 = (cAudio::IAudioDeviceContext *)jarg1; 
  result = (cAudio::IAudioManager *)((cAudio::IAudioDeviceContext const *)arg1)->getAudioManager();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioDeviceContext_getEffects(void * jarg1) {
  void * jresult ;
  cAudio::IAudioDeviceContext *arg1 = (cAudio::IAudioDeviceContext *) 0 ;
  cAudio::IAudioEffects *result = 0 ;
  
  arg1 = (cAudio::IAudioDeviceContext *)jarg1; 
  result = (cAudio::IAudioEffects *)((cAudio::IAudioDeviceContext const *)arg1)->getEffects();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IAudioDeviceContext(void * jarg1) {
  cAudio::IAudioDeviceContext *arg1 = (cAudio::IAudioDeviceContext *) 0 ;
  
  arg1 = (cAudio::IAudioDeviceContext *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IAudioPlugin(void * jarg1) {
  cAudio::IAudioPlugin *arg1 = (cAudio::IAudioPlugin *) 0 ;
  
  arg1 = (cAudio::IAudioPlugin *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioPlugin_installPlugin(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  cAudio::IAudioPlugin *arg1 = (cAudio::IAudioPlugin *) 0 ;
  cAudio::ILogger *arg2 = (cAudio::ILogger *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioPlugin *)jarg1; 
  arg2 = (cAudio::ILogger *)jarg2; 
  result = (bool)(arg1)->installPlugin(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_IAudioPlugin_getPluginName(void * jarg1) {
  char * jresult ;
  cAudio::IAudioPlugin *arg1 = (cAudio::IAudioPlugin *) 0 ;
  char *result = 0 ;
  
  arg1 = (cAudio::IAudioPlugin *)jarg1; 
  result = (char *)(arg1)->getPluginName();
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioPlugin_uninstallPlugin(void * jarg1) {
  cAudio::IAudioPlugin *arg1 = (cAudio::IAudioPlugin *) 0 ;
  
  arg1 = (cAudio::IAudioPlugin *)jarg1; 
  (arg1)->uninstallPlugin();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioPlugin_onCreateAudioManager(void * jarg1, void * jarg2) {
  cAudio::IAudioPlugin *arg1 = (cAudio::IAudioPlugin *) 0 ;
  cAudio::IAudioManager *arg2 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioPlugin *)jarg1; 
  arg2 = (cAudio::IAudioManager *)jarg2; 
  (arg1)->onCreateAudioManager(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioPlugin_onCreateAudioCapture(void * jarg1, void * jarg2) {
  cAudio::IAudioPlugin *arg1 = (cAudio::IAudioPlugin *) 0 ;
  cAudio::IAudioCapture *arg2 = (cAudio::IAudioCapture *) 0 ;
  
  arg1 = (cAudio::IAudioPlugin *)jarg1; 
  arg2 = (cAudio::IAudioCapture *)jarg2; 
  (arg1)->onCreateAudioCapture(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioPlugin_onDestroyAudioManager(void * jarg1, void * jarg2) {
  cAudio::IAudioPlugin *arg1 = (cAudio::IAudioPlugin *) 0 ;
  cAudio::IAudioManager *arg2 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioPlugin *)jarg1; 
  arg2 = (cAudio::IAudioManager *)jarg2; 
  (arg1)->onDestroyAudioManager(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioPlugin_onDestoryAudioCapture(void * jarg1, void * jarg2) {
  cAudio::IAudioPlugin *arg1 = (cAudio::IAudioPlugin *) 0 ;
  cAudio::IAudioCapture *arg2 = (cAudio::IAudioCapture *) 0 ;
  
  arg1 = (cAudio::IAudioPlugin *)jarg1; 
  arg2 = (cAudio::IAudioCapture *)jarg2; 
  (arg1)->onDestoryAudioCapture(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IAudioSource(void * jarg1) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_play(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (bool)(arg1)->play();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_play2d__SWIG_0(void * jarg1, unsigned int jarg2) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool *arg2 = 0 ;
  bool temp2 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = jarg2 ? true : false; 
  arg2 = &temp2; 
  result = (bool)(arg1)->play2d((bool const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_play2d__SWIG_1(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (bool)(arg1)->play2d();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_play3d__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  float *arg3 = 0 ;
  bool *arg4 = 0 ;
  float temp3 ;
  bool temp4 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  temp3 = (float)jarg3; 
  arg3 = &temp3; 
  temp4 = jarg4 ? true : false; 
  arg4 = &temp4; 
  result = (bool)(arg1)->play3d((cAudio::cVector3 const &)*arg2,(float const &)*arg3,(bool const &)*arg4);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_play3d__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  float *arg3 = 0 ;
  float temp3 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  temp3 = (float)jarg3; 
  arg3 = &temp3; 
  result = (bool)(arg1)->play3d((cAudio::cVector3 const &)*arg2,(float const &)*arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_play3d__SWIG_2(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return 0;
  } 
  result = (bool)(arg1)->play3d((cAudio::cVector3 const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_pause(void * jarg1) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  (arg1)->pause();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_stop(void * jarg1) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  (arg1)->stop();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_loop(void * jarg1, unsigned int jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool *arg2 = 0 ;
  bool temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = jarg2 ? true : false; 
  arg2 = &temp2; 
  (arg1)->loop((bool const &)*arg2);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_seek__SWIG_0(void * jarg1, float jarg2, unsigned int jarg3) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  bool arg3 ;
  float temp2 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  arg3 = jarg3 ? true : false; 
  result = (bool)(arg1)->seek((float const &)*arg2,arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_seek__SWIG_1(void * jarg1, float jarg2) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  result = (bool)(arg1)->seek((float const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getTotalAudioTime(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)(arg1)->getTotalAudioTime();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioSource_getTotalAudioSize(void * jarg1) {
  int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  int result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (int)(arg1)->getTotalAudioSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioSource_getCompressedAudioSize(void * jarg1) {
  int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  int result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (int)(arg1)->getCompressedAudioSize();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getCurrentAudioTime(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)(arg1)->getCurrentAudioTime();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioSource_getCurrentAudioPosition(void * jarg1) {
  int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  int result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (int)(arg1)->getCurrentAudioPosition();
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IAudioSource_getCurrentCompressedAudioPosition(void * jarg1) {
  int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  int result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (int)(arg1)->getCurrentCompressedAudioPosition();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_update(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (bool)(arg1)->update();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_isValid(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (bool)((cAudio::IAudioSource const *)arg1)->isValid();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_isPlaying(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (bool)((cAudio::IAudioSource const *)arg1)->isPlaying();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_isPaused(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (bool)((cAudio::IAudioSource const *)arg1)->isPaused();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_isStopped(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (bool)((cAudio::IAudioSource const *)arg1)->isStopped();
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IAudioSource_isLooping(void * jarg1) {
  unsigned int jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  bool result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (bool)((cAudio::IAudioSource const *)arg1)->isLooping();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setPosition(void * jarg1, void * jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->setPosition((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setVelocity(void * jarg1, void * jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->setVelocity((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setDirection(void * jarg1, void * jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->setDirection((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setRolloffFactor(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setRolloffFactor((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setStrength(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setStrength((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setMinDistance(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setMinDistance((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setMaxAttenuationDistance(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setMaxAttenuationDistance((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setPitch(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setPitch((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setVolume(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setVolume((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setMinVolume(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setMinVolume((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setMaxVolume(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setMaxVolume((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setInnerConeAngle(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setInnerConeAngle((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setOuterConeAngle(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setOuterConeAngle((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setOuterConeVolume(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setOuterConeVolume((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setDopplerStrength(void * jarg1, float jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float *arg2 = 0 ;
  float temp2 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  temp2 = (float)jarg2; 
  arg2 = &temp2; 
  (arg1)->setDopplerStrength((float const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_setDopplerVelocity(void * jarg1, void * jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->setDopplerVelocity((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_move(void * jarg1, void * jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 *arg2 = 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::cVector3 *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "cAudio::cVector3 const & type is null", 0);
    return ;
  } 
  (arg1)->move((cAudio::cVector3 const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioSource_getPosition(void * jarg1) {
  void * jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = ((cAudio::IAudioSource const *)arg1)->getPosition();
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioSource_getVelocity(void * jarg1) {
  void * jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = ((cAudio::IAudioSource const *)arg1)->getVelocity();
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioSource_getDirection(void * jarg1) {
  void * jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = ((cAudio::IAudioSource const *)arg1)->getDirection();
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getRolloffFactor(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getRolloffFactor();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getStrength(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getStrength();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getMinDistance(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getMinDistance();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getMaxDistance(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getMaxDistance();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getPitch(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getPitch();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getVolume(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getMinVolume(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getMinVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getMaxVolume(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getMaxVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getInnerConeAngle(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getInnerConeAngle();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getOuterConeAngle(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getOuterConeAngle();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getOuterConeVolume(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getOuterConeVolume();
  jresult = result; 
  return jresult;
}


SWIGEXPORT float SWIGSTDCALL CSharp_IAudioSource_getDopplerStrength(void * jarg1) {
  float jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  float result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = (float)((cAudio::IAudioSource const *)arg1)->getDopplerStrength();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IAudioSource_getDopplerVelocity(void * jarg1) {
  void * jresult ;
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::cVector3 result;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  result = ((cAudio::IAudioSource const *)arg1)->getDopplerVelocity();
  jresult = new cAudio::cVector3((const cAudio::cVector3 &)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_registerEventHandler(void * jarg1, void * jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::ISourceEventHandler *arg2 = (cAudio::ISourceEventHandler *) 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::ISourceEventHandler *)jarg2; 
  (arg1)->registerEventHandler(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_unRegisterEventHandler(void * jarg1, void * jarg2) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  cAudio::ISourceEventHandler *arg2 = (cAudio::ISourceEventHandler *) 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  arg2 = (cAudio::ISourceEventHandler *)jarg2; 
  (arg1)->unRegisterEventHandler(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IAudioSource_unRegisterAllEventHandlers(void * jarg1) {
  cAudio::IAudioSource *arg1 = (cAudio::IAudioSource *) 0 ;
  
  arg1 = (cAudio::IAudioSource *)jarg1; 
  (arg1)->unRegisterAllEventHandlers();
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IPluginManager(void * jarg1) {
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  delete arg1;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IPluginManager_installPlugin__SWIG_0(void * jarg1, void * jarg2, char * jarg3) {
  unsigned int jresult ;
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  cAudio::IAudioPlugin *arg2 = (cAudio::IAudioPlugin *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  arg2 = (cAudio::IAudioPlugin *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->installPlugin(arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IPluginManager_installPlugin__SWIG_1(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  cAudio::IAudioPlugin *arg2 = (cAudio::IAudioPlugin *) 0 ;
  bool result;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  arg2 = (cAudio::IAudioPlugin *)jarg2; 
  result = (bool)(arg1)->installPlugin(arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IPluginManager_installPlugin__SWIG_2(void * jarg1, char * jarg2, char * jarg3) {
  unsigned int jresult ;
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  result = (bool)(arg1)->installPlugin((char const *)arg2,(char const *)arg3);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IPluginManager_installPlugin__SWIG_3(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->installPlugin((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IPluginManager_checkForPlugin(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (bool)(arg1)->checkForPlugin((char const *)arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IPluginManager_getPlugin(void * jarg1, char * jarg2) {
  void * jresult ;
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  char *arg2 = (char *) 0 ;
  cAudio::IAudioPlugin *result = 0 ;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  arg2 = (char *)jarg2; 
  result = (cAudio::IAudioPlugin *)(arg1)->getPlugin((char const *)arg2);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IPluginManager_getPluginCount(void * jarg1) {
  unsigned int jresult ;
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  unsigned int result;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  result = (unsigned int)(arg1)->getPluginCount();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IPluginManager_uninstallPlugin__SWIG_0(void * jarg1, void * jarg2) {
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  cAudio::IAudioPlugin *arg2 = (cAudio::IAudioPlugin *) 0 ;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  arg2 = (cAudio::IAudioPlugin *)jarg2; 
  (arg1)->uninstallPlugin(arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IPluginManager_uninstallPlugin__SWIG_1(void * jarg1, char * jarg2) {
  cAudio::IPluginManager *arg1 = (cAudio::IPluginManager *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (cAudio::IPluginManager *)jarg1; 
  arg2 = (char *)jarg2; 
  (arg1)->uninstallPlugin((char const *)arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_getPluginManager() {
  void * jresult ;
  cAudio::IPluginManager *result = 0 ;
  
  result = (cAudio::IPluginManager *)cAudio::getPluginManager();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IThread_start(void * jarg1) {
  unsigned int jresult ;
  cAudio::IThread *arg1 = (cAudio::IThread *) 0 ;
  bool result;
  
  arg1 = (cAudio::IThread *)jarg1; 
  result = (bool)(arg1)->start();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IThread_join(void * jarg1) {
  cAudio::IThread *arg1 = (cAudio::IThread *) 0 ;
  
  arg1 = (cAudio::IThread *)jarg1; 
  (arg1)->join();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IThread_shutdown(void * jarg1) {
  cAudio::IThread *arg1 = (cAudio::IThread *) 0 ;
  
  arg1 = (cAudio::IThread *)jarg1; 
  (arg1)->shutdown();
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IThread_isRunning(void * jarg1) {
  unsigned int jresult ;
  cAudio::IThread *arg1 = (cAudio::IThread *) 0 ;
  bool result;
  
  arg1 = (cAudio::IThread *)jarg1; 
  result = (bool)(arg1)->isRunning();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IThread(void * jarg1) {
  cAudio::IThread *arg1 = (cAudio::IThread *) 0 ;
  
  arg1 = (cAudio::IThread *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IThreadWorker_run(void * jarg1) {
  cAudio::IThreadWorker *arg1 = (cAudio::IThreadWorker *) 0 ;
  
  arg1 = (cAudio::IThreadWorker *)jarg1; 
  (arg1)->run();
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IThreadWorker(void * jarg1) {
  cAudio::IThreadWorker *arg1 = (cAudio::IThreadWorker *) 0 ;
  
  arg1 = (cAudio::IThreadWorker *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_createAudioManager__SWIG_0(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  cAudio::IAudioManager *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  result = (cAudio::IAudioManager *)cAudio::createAudioManager(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_createAudioManager__SWIG_1() {
  void * jresult ;
  cAudio::IAudioManager *result = 0 ;
  
  result = (cAudio::IAudioManager *)cAudio::createAudioManager();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_destroyAudioManager(void * jarg1) {
  cAudio::IAudioManager *arg1 = (cAudio::IAudioManager *) 0 ;
  
  arg1 = (cAudio::IAudioManager *)jarg1; 
  cAudio::destroyAudioManager(arg1);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_createAudioCapture__SWIG_0(unsigned int jarg1) {
  void * jresult ;
  bool arg1 ;
  cAudio::IAudioCapture *result = 0 ;
  
  arg1 = jarg1 ? true : false; 
  result = (cAudio::IAudioCapture *)cAudio::createAudioCapture(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_createAudioCapture__SWIG_1() {
  void * jresult ;
  cAudio::IAudioCapture *result = 0 ;
  
  result = (cAudio::IAudioCapture *)cAudio::createAudioCapture();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_destroyAudioCapture(void * jarg1) {
  cAudio::IAudioCapture *arg1 = (cAudio::IAudioCapture *) 0 ;
  
  arg1 = (cAudio::IAudioCapture *)jarg1; 
  cAudio::destroyAudioCapture(arg1);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_getLogger() {
  void * jresult ;
  cAudio::ILogger *result = 0 ;
  
  result = (cAudio::ILogger *)cAudio::getLogger();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_createAudioDeviceList__SWIG_0(int jarg1) {
  void * jresult ;
  cAudio::IDeviceType arg1 ;
  cAudio::IAudioDeviceList *result = 0 ;
  
  arg1 = (cAudio::IDeviceType)jarg1; 
  result = (cAudio::IAudioDeviceList *)cAudio::createAudioDeviceList(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_createAudioDeviceList__SWIG_1() {
  void * jresult ;
  cAudio::IAudioDeviceList *result = 0 ;
  
  result = (cAudio::IAudioDeviceList *)cAudio::createAudioDeviceList();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_Clear(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_Add(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  (arg1)->push_back((int const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_IntVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int > *)jarg1; 
  result = ((std::vector< int > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_IntVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  arg1 = (std::vector< int > *)jarg1; 
  result = ((std::vector< int > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (std::vector< int >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_IntVector__SWIG_0() {
  void * jresult ;
  std::vector< int > *result = 0 ;
  
  result = (std::vector< int > *)new std::vector< int >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_IntVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< int > *arg1 = 0 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_IntVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< int > *)new_std_vector_Sl_int_Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IntVector_getitemcopy(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (int)std_vector_Sl_int_Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IntVector_getitem(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (int *) &std_vector_Sl_int_Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_setitem(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_int_Sg__setitem(arg1,arg2,(int const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int > *arg2 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (std::vector< int > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_int_Sg__AddRange(arg1,(std::vector< int > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IntVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< int > *result = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< int > *)std_vector_Sl_int_Sg__GetRange(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_Insert(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int *arg3 = 0 ;
  int temp3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (int)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_int_Sg__Insert(arg1,arg2,(int const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_int_Sg__InsertRange(arg1,arg2,(std::vector< int > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_int_Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_int_Sg__RemoveRange(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_IntVector_Repeat(int jarg1, int jarg2) {
  void * jresult ;
  int *arg1 = 0 ;
  int arg2 ;
  int temp1 ;
  std::vector< int > *result = 0 ;
  
  temp1 = (int)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< int > *)std_vector_Sl_int_Sg__Repeat((int const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  std_vector_Sl_int_Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_IntVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int > *arg3 = 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< int > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< int > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_int_Sg__SetRange(arg1,arg2,(std::vector< int > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IntVector_Contains(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int_Sg__Contains(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IntVector_IndexOf(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_int_Sg__IndexOf(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_IntVector_LastIndexOf(void * jarg1, int jarg2) {
  int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  int result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_int_Sg__LastIndexOf(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_IntVector_Remove(void * jarg1, int jarg2) {
  unsigned int jresult ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  arg1 = (std::vector< int > *)jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_int_Sg__Remove(arg1,(int const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IntVector(void * jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  
  arg1 = (std::vector< int > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_Clear(void * jarg1) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_Add(void * jarg1, double jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  (arg1)->push_back((double const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DoubleVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type result;
  
  arg1 = (std::vector< double > *)jarg1; 
  result = ((std::vector< double > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_DoubleVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type result;
  
  arg1 = (std::vector< double > *)jarg1; 
  result = ((std::vector< double > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double >::size_type arg2 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (std::vector< double >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_DoubleVector__SWIG_0() {
  void * jresult ;
  std::vector< double > *result = 0 ;
  
  result = (std::vector< double > *)new std::vector< double >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_DoubleVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< double > *arg1 = 0 ;
  std::vector< double > *result = 0 ;
  
  arg1 = (std::vector< double > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< double > *)new std::vector< double >((std::vector< double > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_DoubleVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< double > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< double > *)new_std_vector_Sl_double_Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_DoubleVector_getitemcopy(void * jarg1, int jarg2) {
  double jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  double result;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (double)std_vector_Sl_double_Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_DoubleVector_getitem(void * jarg1, int jarg2) {
  double jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  double *result = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (double *) &std_vector_Sl_double_Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = *result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_setitem(void * jarg1, int jarg2, double jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  double temp3 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (double)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_double_Sg__setitem(arg1,arg2,(double const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  std::vector< double > *arg2 = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (std::vector< double > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_double_Sg__AddRange(arg1,(std::vector< double > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_DoubleVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< double > *result = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< double > *)std_vector_Sl_double_Sg__GetRange(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_Insert(void * jarg1, int jarg2, double jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  double *arg3 = 0 ;
  double temp3 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (double)jarg3; 
  arg3 = &temp3; 
  try {
    std_vector_Sl_double_Sg__Insert(arg1,arg2,(double const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  std::vector< double > *arg3 = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_double_Sg__InsertRange(arg1,arg2,(std::vector< double > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_double_Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_double_Sg__RemoveRange(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_DoubleVector_Repeat(double jarg1, int jarg2) {
  void * jresult ;
  double *arg1 = 0 ;
  int arg2 ;
  double temp1 ;
  std::vector< double > *result = 0 ;
  
  temp1 = (double)jarg1; 
  arg1 = &temp1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< double > *)std_vector_Sl_double_Sg__Repeat((double const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  std_vector_Sl_double_Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_double_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_DoubleVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  int arg2 ;
  std::vector< double > *arg3 = 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< double > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< double > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_double_Sg__SetRange(arg1,arg2,(std::vector< double > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_DoubleVector_Contains(void * jarg1, double jarg2) {
  unsigned int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  bool result;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_double_Sg__Contains(arg1,(double const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_DoubleVector_IndexOf(void * jarg1, double jarg2) {
  int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  int result;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_double_Sg__IndexOf(arg1,(double const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_DoubleVector_LastIndexOf(void * jarg1, double jarg2) {
  int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  int result;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  result = (int)std_vector_Sl_double_Sg__LastIndexOf(arg1,(double const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_DoubleVector_Remove(void * jarg1, double jarg2) {
  unsigned int jresult ;
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  double *arg2 = 0 ;
  double temp2 ;
  bool result;
  
  arg1 = (std::vector< double > *)jarg1; 
  temp2 = (double)jarg2; 
  arg2 = &temp2; 
  result = (bool)std_vector_Sl_double_Sg__Remove(arg1,(double const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_DoubleVector(void * jarg1) {
  std::vector< double > *arg1 = (std::vector< double > *) 0 ;
  
  arg1 = (std::vector< double > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_Clear(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_Add(void * jarg1, char * jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  (arg1)->push_back((std::string const &)*arg2);
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_StringVector_size(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  result = ((std::vector< std::string > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_StringVector_capacity(void * jarg1) {
  unsigned long jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  result = ((std::vector< std::string > const *)arg1)->capacity();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_reserve(void * jarg1, unsigned long jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (std::vector< std::string >::size_type)jarg2; 
  (arg1)->reserve(arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StringVector__SWIG_0() {
  void * jresult ;
  std::vector< std::string > *result = 0 ;
  
  result = (std::vector< std::string > *)new std::vector< std::string >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StringVector__SWIG_1(void * jarg1) {
  void * jresult ;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return 0;
  } 
  result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StringVector__SWIG_2(int jarg1) {
  void * jresult ;
  int arg1 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (int)jarg1; 
  try {
    result = (std::vector< std::string > *)new_std_vector_Sl_std_string_Sg___SWIG_2(arg1);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_StringVector_getitemcopy(void * jarg1, int jarg2) {
  char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = std_vector_Sl_std_string_Sg__getitemcopy(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_StringVector_getitem(void * jarg1, int jarg2) {
  char * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    result = (std::string *) &std_vector_Sl_std_string_Sg__getitem(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_setitem(void * jarg1, int jarg2, char * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  try {
    std_vector_Sl_std_string_Sg__setitem(arg1,arg2,(std::string const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_AddRange(void * jarg1, void * jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string > *arg2 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (std::vector< std::string > *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  std_vector_Sl_std_string_Sg__AddRange(arg1,(std::vector< std::string > const &)*arg2);
}


SWIGEXPORT void * SWIGSTDCALL CSharp_StringVector_GetRange(void * jarg1, int jarg2, int jarg3) {
  void * jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  int arg3 ;
  std::vector< std::string > *result = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    result = (std::vector< std::string > *)std_vector_Sl_std_string_Sg__GetRange(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_Insert(void * jarg1, int jarg2, char * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::string *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::string arg3_str(jarg3);
  arg3 = &arg3_str; 
  try {
    std_vector_Sl_std_string_Sg__Insert(arg1,arg2,(std::string const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_InsertRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_string_Sg__InsertRange(arg1,arg2,(std::vector< std::string > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_RemoveAt(void * jarg1, int jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  try {
    std_vector_Sl_std_string_Sg__RemoveAt(arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_RemoveRange(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_string_Sg__RemoveRange(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
  
}


SWIGEXPORT void * SWIGSTDCALL CSharp_StringVector_Repeat(char * jarg1, int jarg2) {
  void * jresult ;
  std::string *arg1 = 0 ;
  int arg2 ;
  std::vector< std::string > *result = 0 ;
  
  if (!jarg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg1_str(jarg1);
  arg1 = &arg1_str; 
  arg2 = (int)jarg2; 
  try {
    result = (std::vector< std::string > *)std_vector_Sl_std_string_Sg__Repeat((std::string const &)*arg1,arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_Reverse__SWIG_0(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  std_vector_Sl_std_string_Sg__Reverse__SWIG_0(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  int arg3 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  try {
    std_vector_Sl_std_string_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  catch(std::invalid_argument &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
    return ;
  }
  
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringVector_SetRange(void * jarg1, int jarg2, void * jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string > *arg3 = 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::vector< std::string > *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::string > const & type is null", 0);
    return ;
  } 
  try {
    std_vector_Sl_std_string_Sg__SetRange(arg1,arg2,(std::vector< std::string > const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_StringVector_Contains(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (bool)std_vector_Sl_std_string_Sg__Contains(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_StringVector_IndexOf(void * jarg1, char * jarg2) {
  int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (int)std_vector_Sl_std_string_Sg__IndexOf(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_StringVector_LastIndexOf(void * jarg1, char * jarg2) {
  int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  int result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (int)std_vector_Sl_std_string_Sg__LastIndexOf(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_StringVector_Remove(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::string arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (bool)std_vector_Sl_std_string_Sg__Remove(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_StringVector(void * jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  
  arg1 = (std::vector< std::string > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StringMap__SWIG_0() {
  void * jresult ;
  std::map< std::string,std::string > *result = 0 ;
  
  result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_StringMap__SWIG_1(void * jarg1) {
  void * jresult ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string > *result = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::map< std::string,std::string > const & type is null", 0);
    return 0;
  } 
  result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >((std::map< std::string,std::string > const &)*arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_StringMap_size(void * jarg1) {
  unsigned long jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::size_type result;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  result = ((std::map< std::string,std::string > const *)arg1)->size();
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_StringMap_empty(void * jarg1) {
  unsigned int jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  bool result;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  result = (bool)((std::map< std::string,std::string > const *)arg1)->empty();
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringMap_Clear(void * jarg1) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  (arg1)->clear();
}


SWIGEXPORT char * SWIGSTDCALL CSharp_StringMap_getitem(void * jarg1, char * jarg2) {
  char * jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  std::map< std::string,std::string >::mapped_type *result = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  try {
    result = (std::map< std::string,std::string >::mapped_type *) &std_map_Sl_std_string_Sc_std_string_Sg__getitem(arg1,(std::string const &)*arg2);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return 0;
  }
  
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringMap_setitem(void * jarg1, char * jarg2, char * jarg3) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  std::map< std::string,std::string >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,std::string >::mapped_type arg3_str(jarg3);
  arg3 = &arg3_str; 
  std_map_Sl_std_string_Sc_std_string_Sg__setitem(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_StringMap_ContainsKey(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__ContainsKey(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringMap_Add(void * jarg1, char * jarg2, char * jarg3) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  std::map< std::string,std::string >::mapped_type *arg3 = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  if (!jarg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return ;
  }
  std::map< std::string,std::string >::mapped_type arg3_str(jarg3);
  arg3 = &arg3_str; 
  try {
    std_map_Sl_std_string_Sc_std_string_Sg__Add(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  }
  catch(std::out_of_range &_e) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
    return ;
  }
  
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_StringMap_Remove(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::key_type *arg2 = 0 ;
  bool result;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  if (!jarg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
    return 0;
  }
  std::map< std::string,std::string >::key_type arg2_str(jarg2);
  arg2 = &arg2_str; 
  result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__Remove(arg1,(std::string const &)*arg2);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_StringMap_create_iterator_begin(void * jarg1) {
  void * jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::iterator *result = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  result = (std::map< std::string,std::string >::iterator *)std_map_Sl_std_string_Sc_std_string_Sg__create_iterator_begin(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_StringMap_get_next_key(void * jarg1, void * jarg2) {
  char * jresult ;
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::iterator *arg2 = (std::map< std::string,std::string >::iterator *) 0 ;
  std::map< std::string,std::string >::key_type *result = 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  arg2 = (std::map< std::string,std::string >::iterator *)jarg2; 
  result = (std::map< std::string,std::string >::key_type *) &std_map_Sl_std_string_Sc_std_string_Sg__get_next_key(arg1,arg2);
  jresult = SWIG_csharp_string_callback(result->c_str()); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_StringMap_destroy_iterator(void * jarg1, void * jarg2) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  std::map< std::string,std::string >::iterator *arg2 = (std::map< std::string,std::string >::iterator *) 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  arg2 = (std::map< std::string,std::string >::iterator *)jarg2; 
  std_map_Sl_std_string_Sc_std_string_Sg__destroy_iterator(arg1,arg2);
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_StringMap(void * jarg1) {
  std::map< std::string,std::string > *arg1 = (std::map< std::string,std::string > *) 0 ;
  
  arg1 = (std::map< std::string,std::string > *)jarg1; 
  delete arg1;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_floatp() {
  void * jresult ;
  float *result = 0 ;
  
  result = (float *)new_floatp();
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_copy_floatp(float jarg1) {
  void * jresult ;
  float arg1 ;
  float *result = 0 ;
  
  arg1 = (float)jarg1; 
  result = (float *)copy_floatp(arg1);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_floatp(void * jarg1) {
  float *arg1 = (float *) 0 ;
  
  arg1 = (float *)jarg1; 
  delete_floatp(arg1);
}


SWIGEXPORT void SWIGSTDCALL CSharp_floatp_assign(void * jarg1, float jarg2) {
  float *arg1 = (float *) 0 ;
  float arg2 ;
  
  arg1 = (float *)jarg1; 
  arg2 = (float)jarg2; 
  floatp_assign(arg1,arg2);
}


SWIGEXPORT float SWIGSTDCALL CSharp_floatp_value(void * jarg1) {
  float jresult ;
  float *arg1 = (float *) 0 ;
  float result;
  
  arg1 = (float *)jarg1; 
  result = (float)floatp_value(arg1);
  jresult = result; 
  return jresult;
}


SWIGEXPORT cAudio::IRefCounted * SWIGSTDCALL CSharp_IDataSource_SWIGUpcast(cAudio::IDataSource *jarg1) {
    return (cAudio::IRefCounted *)jarg1;
}

SWIGEXPORT cAudio::IRefCounted * SWIGSTDCALL CSharp_IAudioDecoder_SWIGUpcast(cAudio::IAudioDecoder *jarg1) {
    return (cAudio::IRefCounted *)jarg1;
}

SWIGEXPORT cAudio::IRefCounted * SWIGSTDCALL CSharp_IAudioPlugin_SWIGUpcast(cAudio::IAudioPlugin *jarg1) {
    return (cAudio::IRefCounted *)jarg1;
}

SWIGEXPORT cAudio::IRefCounted * SWIGSTDCALL CSharp_IAudioSource_SWIGUpcast(cAudio::IAudioSource *jarg1) {
    return (cAudio::IRefCounted *)jarg1;
}

#ifdef __cplusplus
}
#endif

